[7일차] 국비교육

1.메소드 연습(영화표 예매)

 

package 영화표예매;

import java.util.Scanner;
// 좌석에 대한 영화표 판매하고 총 금액 구하기
// 좌석은 배열로 총 10개 생성
// 판매액은 좌석 당 12000원
// 이미 예약된 좌석은 이미 판매되었다고 표시
public class MovieTicket {
    int ticketPrice;
    int seat[] = new int[10]; // 배열로 좌석을 10개 생성
    //화면에 선택 가능한 좌석 표시, 판매된 좌석은 [V], 판매되지 않은 좌석은 [ ]
    MovieTicket(int price){ //매개변수는 호출하는 애를 넣어줘야함
        ticketPrice = price;
    }//인스턴스 변수
    void printSeat(){ //void 반환값이 없기 때문에 ()매개변수에 넣어주지 않아도 됨
        //외부 메인에서 부르지 않음
        for(int i = 0; i < seat.length; i++){
            if(this.seat[i] == 0) System.out.print("[ ]");
            //배열에 값을 넣지 않아서 0이면 팔리지 않은 것
            else System.out.print("[v]");
        }
        System.out.println();
    }
    // 좌석을 선택하는 메소드
    void selectSeat() {
        printSeat(); // 현재 좌석 상태를 보여줌
        Scanner sc = new Scanner(System.in);
        System.out.print("좌석 번호를 입력 하세요 : ");
        //메소드 안에 지역 변수
        int seatPos = sc.nextInt(); // 사용자의 좌석 번호는 배열의 인덱스 보다 1이크다.
        if (seat[seatPos - 1] == 0) {// 아직 판매되지 않은 좌석
            seat[seatPos - 1] = 1;// 판매된 좌석으로 변경
            printSeat();// 판매 이후 좌석 상태를 보여줌

        } else System.out.println("이미 판매된 좌석입니다. 다른 좌석을 선택하세요");
    }
    int totalAmount(){ //메인에서 반환 할 것 이기 때문에 int
        int cnt = 0;
        for(int e : seat){
            if(e == 1) cnt++;
            //1은 이미 팔린 좌석이므로 그거에 갯수를 세면 몇개 팔려나 볼 수있다.
        }
        return cnt * ticketPrice;
    }


}

 <main>

package 영화표예매;

import java.util.Scanner;

public class MovieMaiin {
    public static void main(String[] args) {
        MovieTicket ticket = new MovieTicket(12000);
        //()기본생성자 호출, 초기값 설정 없으므로
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("[1]예매하기");
            System.out.println("[2]종료하기");
            int selectMenu = sc.nextInt();
            if(selectMenu == 1) ticket.selectSeat();
            else {
                System.out.println(ticket.totalAmount());
                break;
            }
        }
    }
}

 

출력

[1]예매하기
[2]종료하기
1
[ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]
좌석 번호를 입력 하세요 : 1
[v][ ][ ][ ][ ][ ][ ][ ][ ][ ]
[1]예매하기
[2]종료하기
1
[v][ ][ ][ ][ ][ ][ ][ ][ ][ ]
좌석 번호를 입력 하세요 : 2
[v][v][ ][ ][ ][ ][ ][ ][ ][ ]
[1]예매하기
[2]종료하기
1
[v][v][ ][ ][ ][ ][ ][ ][ ][ ]
좌석 번호를 입력 하세요 : 2
이미 판매된 좌석입니다. 다른 좌석을 선택하세요
[1]예매하기
[2]종료하기
1
[v][v][ ][ ][ ][ ][ ][ ][ ][ ]
좌석 번호를 입력 하세요 : 3
[v][v][v][ ][ ][ ][ ][ ][ ][ ]
[1]예매하기
[2]종료하기
2
36000

 

 

비슷한 예제))

 

package PC방알바;

import java.util.Scanner;

// PC는 총 100대 : 배열을 100개 생성(int)
// 첫번째 입력은 손님의 수
// 손님의 수 만큼 원하는 좌석번호를 입력받음
// 이미 예약된 좌석의 경우 거절하고 거절횟수를 누적
// 결과는 몇번 거절이 발생했는지 결과 출력
public class PcRoomEx {
    public static void main(String[] args) {
        int pcRoom[] = new int[100];
        int rejcetCnt = 0;
        // 손님의 수와 손님이 요청하는 좌석을 입력받기 위한 스캐너 객체 생성
        Scanner sc = new Scanner(System.in);
        // 손님의 수를 정수로 입력 받음
        int n = sc.nextInt();
        // 손님의 수만큼 반복문을 수행하면서 손님이 원하는 좌석 번호를 입력 받음

        for(int i = 0; i < n; i++){ // 손님의 수 만큼 좌석번호를 받기 위한 범위
            // ==(비교연산자로 같다), = (대입연산자) 해당 배열에 값을 넣는다는 의미
            int seatNumber = sc.nextInt(); // 손님이 요청하는 좌석 번호
            if (pcRoom[seatNumber -1] == 1) rejcetCnt++;
            //rejectCnt++는 무슨 수인지 상관없이 거절횟수만을 증가시킴
            //5개의 정수를 받는다고 하고 좌석 번호가 1 2 2 3 3 ->거절 횟수 : 2
            //1이 의미하는 것은 예약된 자리
            else pcRoom[seatNumber -1] = 1; // 손님이 해당 좌석을 예약한다는 의미
        }
        System.out.println("거절 횟수  : " + rejcetCnt);
        // 입력 받은 좌석이 배열에서 예약된 좌석인지를 확인(좌석번호와 배열 인덱스는 -1해줌)


    }
}

 

 

 

출력

10
1 1 2 2 3 3 4 4 5 5 
거절 횟수  : 5

 

<클래스로 변경>

 

package PC방알바;

import java.util.Scanner;

public class PcRoomcls {
    int[] pcRoom = new int[100]; // PC방의 PC 대수
    int person = 0;
    int rejectCnt = 0;
    // 손님의 수를 입력 받음
    void inputPerson() {
        Scanner sc = new Scanner(System.in);
        person = sc.nextInt();
    }
    // 손님의 요청한 자리가 예약되었는지 확인하고 거절횟수를 누적하는 메소드
    void calcSeat(){
        int seatNumber = 0; //지역변수
        Scanner sc = new Scanner(System.in);
        for(int i = 0; i < person; i++){
            seatNumber = sc.nextInt();
            if(pcRoom[seatNumber -1] ==1) rejectCnt++;
            else pcRoom[seatNumber -1] =1;
        }
    }
    //getter setter
    int getRejectCnt(){
        return rejectCnt;
    }
}

 

package PC방알바;

import java.util.Scanner;

// PC는 총 100대 : 배열을 100개 생성(int)
// 첫번째 입력은 손님의 수
// 손님의 수 만큼 원하는 좌석번호를 입력받음
// 이미 예약된 좌석의 경우 거절하고 거절횟수를 누적
// 결과는 몇번 거절이 발생했는지 결과 출력
public class PcRoomEx {
    public static void main(String[] args) {
       PcRoomcls pcRoomcls = new PcRoomcls();
        pcRoomcls.inputPerson(); //사용자 수를 입력 받음
        pcRoomcls.calcSeat(); //사용자가 요청한 좌석에 따라 거절 횟수 누적
        System.out.println(pcRoomcls.getRejectCnt());
    }
}

**모듈화를 한 것임

 

출력

5
1 1 2 2 3
2

 

 

package 손익분기점;
//월드전자에서 생산하는 노트북이 몇대 팔려야 이익이 발생하는 가를 묻는 문제
// 입력 : 고정비용 가변비용 판매단가
// 몇대를 팔아야 손익분기점을 달성하는가를 묻는 문제
// 손익분기점이 존재하지 않으면 -1

import java.util.Scanner;

public class eventPointEx {
    public static void main(String[] args){
        // 스캐너 객체를 생성해서 고정비용 가변비용 생산비용을 입력 받음
        Scanner sc = new Scanner(System.in);
        // 손익분기점을 달성할 수 없으면 -1을 출력하고 끝냄
        // 손익분기점 달성여부 확인은 반복문을 사용해도 되고 공식을 이용해도 됨
        // 결과 출력은 판매 대수
        int cnt = 0;
        int fixCost = sc.nextInt();
        int varCost = sc.nextInt();
        int sellPrice = sc.nextInt();

        if(varCost >= sellPrice){
            System.out.println("-1");
            return;//프로그램을 종료시킴
        }
        while(true){
            if(fixCost +(varCost * cnt) < sellPrice * cnt) break;
            cnt++;
        } //몇대 인지 모르므로 while 으로 돌림
        //생산대수가 많아져서 
        System.out.println(cnt);
    }
}

 

 

package 손익분기점;
//월드전자에서 생산하는 노트북이 몇대 팔려야 이익이 발생하는 가를 묻는 문제
// 입력 : 고정비용 가변비용 판매단가
// 몇대를 팔아야 손익분기점을 달성하는가를 묻는 문제
// 손익분기점이 존재하지 않으면 -1

import java.util.Scanner;

public class eventPointEx {
    public static void main(String[] args){
        // 스캐너 객체를 생성해서 고정비용 가변비용 생산비용을 입력 받음
        Scanner sc = new Scanner(System.in);
        // 손익분기점을 달성할 수 없으면 -1을 출력하고 끝냄
        // 손익분기점 달성여부 확인은 반복문을 사용해도 되고 공식을 이용해도 됨
        // 결과 출력은 판매 대수
        int cnt = 0;
        int fixCost = sc.nextInt();
        int varCost = sc.nextInt();
        int sellPrice = sc.nextInt();

        if(varCost >= sellPrice){
            System.out.println("-1");
            return;//프로그램을 종료시킴
        }
        /*while(true){
           //if(fixCost +(varCost * cnt) < sellPrice * cnt) break;
            if(cnt > fixCost / (sellPrice - varCost)) break;
            //손익분기점 공식 이용
            cnt++;
        } *///몇대 인지 모르므로 while 으로 돌림
        //생산대수가 많아져서 fail 남(정수의 범위를 넘어서기 때문)
        System.out.println((fixCost / (sellPrice - varCost))+1);
    }
}

출력

1000 70 170
11

2.this와 this()

 

• this 참조 변수

this 참조 변수는 인스턴스가 바로 자기 자신을 참조하는데 사용하는 변수 입니다.

이런한 this 참조 변수는 해당 인스턴스의 주소를 가리키고 있습니다.

아래의 예제처럼 생성자의 매개변수 이름과 인스턴스 변수의 이름이 같을 경우에는 인스턴스 변수 앞에 this 키워드를 붙여 구분해야만 합니다.

this 참조자를 사용 할 수 있는 영역은 인스턴스 메소드 뿐이며, 클래스 메소드에서는 사용 할 수 없습니다.

모든 인스턴스 메소드에는 this 참조 변수가 숨겨진 지역 변수로 존재하고 있습니다.

 

• this() 메소드 - 다른 생성자 호출

생성자 오버로딩이 많아 질 경우 생성자 간의 중복된 코드가 발생 할 수 있습니다.

this() 메소드는 생성자 내부에서만 사용할 수 있으며, 같은 클래스의 다른 생성자를 호출 할 때 사용 합니다.

this() 메소드에 인수를 전달하면, 일치하는 생성자를 찾아서 호출해 줍니다.

 

 

 

ackage 자기참조변수;

public class Car {

    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;

    public Car(String modelName, int modelYear, String color, int maxSpeed) {
        this.modelName = modelName; //이름 구분하기 위해 this 를 붙여줌
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }
    // 생성자 오버로딩이 많아지면 생성자 간의 중복코드가 발생할 수 있음
    // this() 생성자 내에서 다른 생성자를 호출 할 때 사용
    Car(String modelName){
        this(modelName, 2020, "은색", 250);
    }
    Car(String modelName, String color, int speed){
        //그래서 3개짜리 변수를 만들어 줌
        this.modelName = modelName;
        this.color = color;
        this.maxSpeed = speed;
    }
    Car(){//생성자 오버로딩 : 생성자 중에 또 찾는것 이 타입에 맞는 생성자가 있는지 찾아봄
        this("GV80", "Black",230);
    }
    void viewCar(){
        System.out.println("차종 : " + modelName);
        System.out.println("연식 : " + modelYear);
        System.out.println("색상 : " + color);
        System.out.println("속도 : "+ maxSpeed);
    }
    }

 

package 자기참조변수;

public class thisMainEx {
    //인스턴스 필드
    public  static void main(String[] args) {
        Car car = new Car();
        //Car()를 불러옴(매개변수 없는 타입)
        car.viewCar();

    }
}

출력

차종 : GV80
연식 : 0
색상 : Black
속도 : 230

 

 

package 자기참조변수;

public class Car {

    private String modelName;
    private int modelYear;
    private String color;
    private int maxSpeed;

    public Car(String modelName, int modelYear, String color, int maxSpeed) {
        this.modelName = modelName; //이름 구분하기 위해 this 를 붙여줌
        this.modelYear = modelYear;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }
    // 생성자 오버로딩이 많아지면 생성자 간의 중복코드가 발생할 수 있음
    // this() 생성자 내에서 다른 생성자를 호출 할 때 사용
    Car(String modelName){
        this(modelName, 2020, "은색", 250);
    }
    Car(String modelName, String color, int speed){
        //그래서 3개짜리 변수를 만들어 줌
        this.modelName = modelName;
        this.color = color;
        this.maxSpeed = speed;
    }
    Car(){//생성자 오버로딩 : 생성자 중에 또 찾는것 이 타입에 맞는 생성자가 있는지 찾아봄
        this("GV80", "Black",230);
    }
    void viewCar(){
        System.out.println("차종 : " + modelName);
        System.out.println("연식 : " + modelYear);
        System.out.println("색상 : " + color);
        System.out.println("속도 : "+ maxSpeed);
    }
    void viewCar(boolean notYear){//메소드 오버로딩
        System.out.println("차종 : " + modelName);
        System.out.println("색상 : " + color);
        System.out.println("속도 : "+ maxSpeed);
    }
    }

package 자기참조변수;

public class thisMainEx {
    //인스턴스 필드
    public  static void main(String[] args) {
        Car car = new Car("아반떼");
        car.viewCar();
        System.out.println();
        Car car2 = new Car();
        //Car()를 불러옴(매개변수 없는 타입)
        car2.viewCar(); //연식을 안나오게 하려면 false를 넣어줌



    }
}

출력

 

차종 : 아반떼
연식 : 2020
색상 : 은색
속도 : 250

차종 : GV80
연식 : 0
색상 : Black
속도 : 230

 

3.상속

 

자식 클래스가 부모 클래스의 기능을 그대로 물려받을 수 있는 상속 기능

재활용성 

다중상속 불가능(한쪽은 실체가 있고, 다른한쪽은 실체가 없음<--실체=객체가 있냐 없냐 )

양쪽으로 상속받으면 본래 의도가 불분명해짐

오버로딩: 한가지 문법으로 다른 형태로 여러번 부르기

              물려받아서 약간만 수정

오버라이딩: 재정의함 

 

<메소드 오버라이딩>

 

package 상속기본;

public class Animal {
    protected String name; // 접근 제한자 private 은 같은 클래스 내에서만 접근가능
    void setName(String name) {
        this.name = name;
    }
}
//protected : 같은 패키지와 상속만 가능
class Dog extends Animal {
    void sleep(){
        System.out.println(this.name + "zzz");
    }
}
class HouseDog extends Dog{
   /* @Override //오버라이드 관계를 나타냄
    void sleep(){
        System.out.println(this.name + "zzz in house");
    }//상속의 상속 마지막 정의한 것이 출력되지만
    상속 관계에 있는 dog 출력문이 나타남 오버라이딩관계계    */
}

 

 

package 상속기본;
// 상속은 부모 클래스의 자원을 자식 클래스에 물려 주는 것
// 키워드는 extends
// private 접근제한자를 사용하면 상속을 줄 수 없다.

public class InheritanceMain {
    public static void main(String[] args){
        HouseDog houseDog = new HouseDog();
        houseDog.setName("댕댕이");
        houseDog.sleep();

    }
}

 

 

출력

댕댕이zzz

 

 

package 상속기본2;

public class Person {
    String eat = "밥을 먹습니다.";
    String getEat() {
        return eat;
    }

}
class Student extends Person {
    String study = "공부 합니다.";
    /*String getEat() {
        return "학생이 " + eat;
    }*/
    void viewStudent(){
        System.out.println(study);
        System.out.println(getEat());
    }
}
class Worker extends  Person {
    String work = "일을 합니다.";
    String getEat(){
        return "직장인이 " + eat;
    }
    void viewWorker(){
        System.out.println(work);
        System.out.println(getEat());
    }
}
class HouseWife extends Person{
    String houseKeeping = "집안일을 합니다.";
    String getEat(){
        return "주부가 "+ eat;
    }
    void viewhouseWife(){
        System.out.println(houseKeeping);
        System.out.println(getEat());
    }
}

package 상속기본2;

public class PersonMain {
    public static void main(String[] args){
         Worker work = new Worker();
         work.viewWorker();
         Student student = new Student();
         student.viewStudent();
         HouseWife houseWife = new HouseWife();
         houseWife.viewhouseWife();

          //양산 시 부모기능이 부족할때 오버라이딩 관계 이용

    }
}

일을 합니다.
직장인이 밥을 먹습니다.
공부 합니다.
밥을 먹습니다.
집안일을 합니다.
주부가 밥을 먹습니다.

 

4. git과 버전관리

 

Git

2005년 리눅스 개발자인 리누스 베네딕트 토르발스가 개발

 

git bash here을 많이 사용

 

설치후 

vscode와 연결