[8일차] 국비교육

1. 상속 시 오버라이딩을 금지하는 방법

 

package 상속어드벤스;
//기본 클래스 : 상속을 주기위한 클래스
public class Car {
    int speed;
    String color;
    String name;
    final void accelerator(){ // 가속 기능, 
        // 부모 클래스에 final 을 붙이면 오버라이딩 금지 됨
         System.out.println("차의 속도를 증가 시킵니다.");
    }
    final void breakPanel(){
        System.out.println("차의 속도를 감소시킵니다.");
    }
}
//상속을 줄수 있지만 오버라이딩 안됨
class SportsCar extends Car {
    boolean isTurbo;
    SportsCar(String name) {
        isTurbo = false;//디폴트 값으로 false 지정, true 일때만 isTurbo만 실행
        speed = 280;
        color = "Red";
        this.name = name;
        this.color = color;
    }
    int getSpeed() { // getter 메소드 : 값을 읽기 위한 메소드
        if(isTurbo) return speed *= 1.2;
        return  speed;
    }
    boolean isTurbo(){
        return isTurbo;
    }
    void setTurbo(boolean turbo){
        isTurbo = turbo;
    }
    //final로 사용하니 에러뜸
    /*@Override
    void accelerator(){
        System.out.println("속도를 200% 증가합니다.");
    }
    @Override
    void breakPanel(){
        System.out.println("차의 정지 상태로 만듭니다.");
    }*/
    void infoCar(){
        System.out.println("이름 : " + name);
        System.out.println("속도 : " + getSpeed());
        //turbo 모드일때를 호출해야 하므로 클래스 내부의 메소드 호출
        System.out.println("색상 : " +  color);
        System.out.println("터보모드 : " + isTurbo);
    }
}
class ElectricCar extends Car {
    boolean isAutoDrv; // 자율주행 모드
    ElectricCar(String name){
        isAutoDrv = false;
        speed = 200;
        this.name = name;
        color = "White";
    }
    boolean isAutoDrv(){
        return isAutoDrv;
    }
    void setAutoDrv(boolean autoDrv){
        isAutoDrv = autoDrv;
    }
    void infoCar(){
        System.out.println("이름 : " + name);
        System.out.println("속도 : " + speed);
        //turbo 모드일때를 호출해야 하므로 클래스 내부의 메소드 호출
        System.out.println("색상 : " +  color);
        System.out.println("자율주행 모드 : " + isAutoDrv);
    }
}

 

 

package 상속어드벤스;
//상속을 할 수 없는 클래스를 만드는 방법
//String 상속을 할 수 없음
//오버라이딩 금지 방법
public class InheritanceEx2 {
    public static void main(String[] args){
         SportsCar sportsCar = new SportsCar("Ferrari");
         ElectricCar electricCar = new ElectricCar("아이오닉6");
         sportsCar.setTurbo(true);
         sportsCar.infoCar();
         electricCar.setAutoDrv(true);
         electricCar.infoCar();
         sportsCar.accelerator();
         sportsCar.breakPanel();
    }
}

 

출력

이름 : Ferrari
속도 : 336
색상 : Red
터보모드 : true
이름 : 아이오닉6
속도 : 200
색상 : White
터보모드 : true
차의 속도를 증가 시킵니다.
차의 속도를 감소시킵니다.

 

 <super>

 

package 상속어드벤스2;
// super : 자식클래스가 부모 클래스로 부터 상속 받은 멤버를 참조할 때 사용
// this : 인스턴스 필드와 매개변수를 구분하기 위해 사용하는 것과 유사
// super() : super 메소드, 부모 생성자를 호출, 부모 생성자가 디폴트이면 호출할 필요 없음
public class SuperMainEx {
    public static void main(String[] args){
         Child child = new Child(28);
         child.childMethod();
    }
}
class Parent {
    int x = 10;
    String name;
    Parent(){

    }

    Parent(int x){
        this.x = x;
    }
    Parent(String name){
      this.name = name;
    }
}
class Child extends  Parent {
    int x= 20;

    Child(int x) {
        super("우영우"); //매개변수가 있는 생성자의 경우 super 필요,(x)를 넣으면 매개변수가 있는것
        //()값이 없으면 없는 것을 호출
    }

    void childMethod() {
        System.out.println("x : " +x);
        System.out.println("this.x : " +this.x);// 자기자신을 참조
        System.out.println("super.x : " +super.x);
        // 자식클래스가 부모 클래스로 상속 받은 것을 표현
        System.out.println("이름 : " + name);
    }
}

출력

x : 20
this.x : 20
super.x : 10
이름 : 우영우

 

<종합예제>

package 상속종합TV;
// 양산 TV를 만들기 위해 선행 개발된 프로토타입
// 추상상속시 자식은 무조건 상속(양산화를 위함)
// --> 그러므로 추상 상속 하지 않음
public class PrototypeTV {
    boolean isPower; // 전원에 대한 설정값 저장
    int channel;     // 채널에 대한 설정값 저장
    int volume;      // 볼륨에 대한 설정값 저장
    public PrototypeTV() {} // 기본 생성자
    // 생성자 오버로딩
    public PrototypeTV(boolean isPower, int channel, int volume) { //생성자만듦
        this.isPower = isPower;
        this.channel = channel;
        this.volume = volume;
    }
    public void setChannel(int cnl){
        if(cnl > 0 && cnl < 500){
            channel = cnl;
        }else {
            System.out.println("채널 설정 범위를 벗어 났습니다.");
        }
    }
}

 

 

package 상속종합TV;
public class ProductTV extends PrototypeTV{
    String name;
    boolean isInternet; // 인터넷 모드 추가
    ProductTV(){ } //오버로딩
    ProductTV(String name){
        super(false, 3, 30);
        //부모 생성자부터 호출 해야함
        this.name = name;
    }
    void setPower (boolean power) {
        this.isPower = power;
    }
    void setVolume(int vol){
        if(vol >= 0 && vol <= 100){
            volume = vol;
        }else{
            System.out.println("볼륨 설정 범위를 벗어 났습니다.");
        }
    }
    @Override
    //오버라이딩: 부모와 이름이 같고 설정을 다른 경우
    public void setChannel(int cnl){
        if(cnl > 0 && cnl < 1000){
            channel = cnl;
            System.out.println("채녈을 " + channel + "로 변경 했습니다.");
        }else{
            System.out.println("채널 설정 범위가 아닙니다.");
        }
    }
    //메소드 오버로딩 : 동일한 이름의 메소드를 매개변수의 갯수나 타입으로 구분
    public void setChannel(int cnl, boolean internet){
        if(internet){
            System.out.println("인터넷모드 입니다.");
            isInternet = true;
        } else{
            isInternet = false;
            if(cnl > 0 && cnl < 1000){
                channel = cnl;
                System.out.println("채녈을 " + channel + "로 변경 했습니다.");
            }else{
                System.out.println("채널 설정 범위가 아닙니다.");
            }
        }

    }
    public void viewTV(){
        System.out.println("이름 : " +name);
        System.out.println("전원 : " +isPower);
        System.out.println("채널 : " +channel);
        System.out.println("볼륨 : " +volume);
        System.out.println("인터넷모드 : "+isInternet);

    }
}

 

package 상속종합TV;
// 상속 : Protype TV로부터 상속 받아서 Product TV를 만듦
// 오버라이딩 : 채널 설정을 499개에서 999개로 변경 함 (부모의 메소드 재정의) 
// 오버로딩 : 채널 설정을 오버로딩해서 인터넷 모드를 추가
// (동일한 메소드를 매개변수의 개수나 타입으로 자동 호출함) 
// Super() : Product TV생성자 호출 시 부모의 생성자를 호출함 
public class TvUpgradeMain {
    public static void main(String[] args){
         ProductTV lgTV = new ProductTV("우리집 TV");
         lgTV.setPower(true); // default 값 false로 뜸
         lgTV.setVolume(45);
         lgTV.setChannel(3, true);
         lgTV.viewTV();
    }
}

 

인터넷모드 입니다.
이름 : 우리집 TV
전원 : true
채널 : 3
볼륨 : 45
인터넷모드 : true

 

<알고리즘>

package 알고리즘_나머지;
// 10개의 수를 입력 받음
// 입력 받은 수를 42로 나눈 나머지 중 다른 것이 몇개인지 출력
// 42 % 42 = 0
// 44 % 42 = 2
// 84 % 42 = 0
// 1 % 42 = 1
// 5 % 42 = 5
// 86 % 42 = 4
// 88 % 42 = 10
// 11 % 42 = 11
// 13 % 42 = 13
// 9개로 출력

import java.util.Scanner;

public class ModMainEx {
    public static void main(String[] args){
        // 10개의 임의의 수를 입력받기 위한 스캐너 생성
        Scanner sc = new Scanner(System.in);

        // 42로 나눈 나머지는 0~4까지이기 때문에 42의 정수 배열 만들기
        int[] arr = new int[42];
        int cnt = 0;//중복된 개수를 누적하기 위한 변수
        int n; //임의의 정수값을 입력 받기 위한 변수
        // 임의의 10개의 정수 입력 받기 위해 반복문 만들기
        System.out.print("입력값 : ");
        for(int i = 0; i < 10; i++) {
            n = sc.nextInt();// 임의의 정수값을 입력 받음
            // 반복문을 돌면서 임의의 정수값을 입력 받고 42로 나눈 배열에 1을 넣음
            arr[n % 42] = 1; // 나눈 나머지를 배열의 인덱스 변환해서 1을 넣어줌
            // n%42를 나눈 값이 배열 번호와 일치 하므로 1을 넣어줌

        }
        for(int i = 0; i < arr.length; i++){
            cnt += arr[i]; // 1인 값이 다 더해짐
            //결과출력

        }

        System.out.println("결과 : "  + cnt);
    }
}

출력

입력값 : 1 2 3 4 4 5 5 6 6 7 
결과 : 7

 

package 요금제계산하기;

import java.util.Scanner;

// 영식(Y) 요금제 : 30초당 10원 (30초가 되면 2통이 됨)
// 민식(M) 요금제 : 60초당 15원 (60초가 되면 2통이 됨) 
// 입력 : 통화 횟수가 첫째줄에 입력되고 통화 횟수에 대한 시간이 각각 입력됨
// 만약 총 요금이 같은 경우 Y M 통화 요금
// 3(통화 횟수) : 총 통화 횟수는 20을 넘지 않는다.
// 65 45 23 (각각의 통화 시간)
// M 통화에 대한 총 금액
// 통화횟수 : 3
// 통화시간 : 40 40 40
// 요금제 및 요금 : M 45
public class PriceCalcEx {
    public static void main(String[] args) {
        // 통화 횟수에 대한 배열을 만듦 (20개)
        int[] call = new int[20];
        int yPare = 0, mPare = 0; // 영식과 민식 요금제를 구하기위한 변수
        // 스캐너를 만들어 통화횟수를 입력 받음
        Scanner sc = new Scanner(System.in);
        System.out.print("통화횟수 입력 : ");
        int cnt = sc.nextInt();
        // 반복문을 돌면서 통화횟수에 대한 통화 시간을 배열을 넣음
        for (int i = 0; i < cnt; i++) {
            call[i] = sc.nextInt();
        }
        // 통화횟수 만큼 반복문을 돌면서 요금을 계산해서 누적함 -> 총 요금을 구해야하므로
        for (int i = 0; i < cnt; i++) {
            yPare += (call[i] / 30) * 10 + 10;// 기본 1통화 + (30초당 1통)
            mPare += (call[i] / 60) * 15 + 15;//mPare = mPare + (call[i] / 60) * 15 +15
        }
        // 영식요금제와 민식 요금제를 비교해서 싼 요금제를 출력함
        // 같으면 Y M으로 출력
      if(yPare > mPare){
          System.out.println("M " + mPare);
      }else if(yPare < mPare){
          System.out.println("Y " + yPare);
      }else{
          System.out.println("Y M "+yPare);
      }
    }
}

출력

통화횟수 입력 : 3
40 48 50
M 45

 

 

package 에어컨만들기;

import java.util.Calendar;
import java.util.Scanner;

// 필드와 메소드
// 전원 : ON/OFF (boolean)
// 온도 설정 기능 : int
// 현재 온도 표시 기능 : int
// Cooler ON/OFF (boolean)
// Heater On/OFf (boolean)
// 바람세기 (1단/2단/3단)
// 타이머, 리모콘 기능 생략
// 현재 온도가 변경될 때 화면에 에어컨 정보를 표시하도록 함.

public class AirCon {
    private boolean isPower; // 전원 제어
    private int setTemp;     // 온도 설정
    private int currTemp;    // 현재 온도
    private boolean isCooler; // 에어컨 제어
    private boolean isHeater; // 히터 제어
    private int windStep;     // 바람세기 (1단/2단/3단)
    AirCon() { // 생성자는 에어컨이라는 객체가 만들어질 때 어떤 상태로 시작해야 될지를 결정
        //final 은 배열안에 있는 값 수정 불가능
        final int[] monthTemp = {-5, 3, 9, 15, 22, 26, 30, 31, 24, 26, 9, 3};
        Calendar now = Calendar.getInstance(); // 운영체제로부터 현재의 날짜 정보를 가져옴.
        int month = now.get(Calendar.MONTH); // 배열의 인덱스로 넘어 옴, 0번째에 1월이 들어옴.
        currTemp = monthTemp[month];// 현재의 달 온도를 배열로부터 가져옴.
        isPower = false; // 에어컨 초기 상태는 꺼져있음
        setTemp = 18;    // 에어컨의 초기 설정 온도 지정
        isCooler = false;
        isHeater = false;
        windStep = 1;
    }
    void airConInfo(){
        String onOffStr = (isPower) ?  "ON" :"OFF";
        String heaterStr = (isHeater) ?  "ON" :"OFF";
        String coolerStr = (isCooler) ?  "ON" :"OFF";
        final String[] windStr = {"", "1단계", "2단계", "3단계"};
        //값을 바꾸는 것이 아니라 화면에 출력을 하기 위함이므로 final
        System.out.println("=========에어컨 정보==========");
        System.out.println("전원 : " + onOffStr);
        System.out.println("현재 온도 : " + currTemp);
        System.out.println("설정 온도 : " + setTemp);
        System.out.println("히터 : " + heaterStr);
        System.out.println("쿨러 : " +coolerStr);
        System.out.println("바람세기 : " +windStr[windStep]);
    }
    void setAirCon() {
        // 에어컨 설정을 위해 스캐너 객체 생성
        Scanner sc = new Scanner(System.in);
        System.out.println("현재 온도가 " + currTemp + "입니다.");
        System.out.print("온도를 설정하세요 : ");
        setTemp = sc.nextInt(); // 스캐너로부터 현재 온도를 입력받아 setTemp 넣어줌
        System.out.println("설정 온도는 " + setTemp +"입니다.");
        System.out.print("바람 세기를 설정 [1]1단, [2]2단, [3]3단 : ");
        windStep = sc.nextInt();
        if(currTemp > setTemp){
            System.out.println("Cooler 가 동작 합니다.");
            isCooler = true; // 에어컨이 켜졌음
            isHeater = false; // 확실히 하기 위해 넣는 코드
        }else if(currTemp < setTemp){
            System.out.println("Heater 가 동작 합니다.");
            isCooler = false;
            isHeater = true;
        }else{
            isCooler = false;
            isHeater = false;
        }
    }
    // 전원 설정
    void setPower(boolean power) {
        isPower = power;
    }
    // 바람세기 확인
    int getWindStep() {
        return windStep;

    }
    // 히터 상태 확인
    boolean isHeater() {
        return isHeater;
    }
    // 쿨러 상태 확인
    boolean isCooler(){
        return isCooler;
    }
    // 현재 온도 변경
    void setCurrTemp(int n) {
        currTemp += n;
    }
    // 현재 온도 확인
    int getCurrTemp() {
        return currTemp;
    }
    // 설정 온도 확인
    int getSetTemp(){
        return setTemp;
    }
}

 

에어컨만들기;

import java.util.Scanner;

import static java.lang.Thread.sleep;

public class AirConMain {
    public static void main(String[] args) throws InterruptedException {
        AirCon lgAirCon = new AirCon();
        Scanner sc = new Scanner(System.in);
        int elapsedTime = 0; // 경과 시간 계산
        boolean isSetTemp = false; // 온도를 변경하는 조건 체크
        System.out.print("에어컨을 켜시겠습니까?(yes/no) : ");
        String isON = sc.next();
        if(isON.equalsIgnoreCase("yes")){
            lgAirCon.setPower(true);
            lgAirCon.setAirCon();
            while(true){ //1초마다(1000millis = 1초) while 문 돌림
                sleep(1000);
                // Sleep 메서드는 객체가 중단 될 때까지 객체에 대한 잠금을 해제하지 않습니다.
                elapsedTime++; // 경과 시간을 누적함
                switch (lgAirCon.getWindStep()){
                    case 1 : if(elapsedTime >= 60) isSetTemp = true; break;
                    case 2 : if(elapsedTime >= 30) isSetTemp = true; break;
                    case 3 : if(elapsedTime >= 20) isSetTemp = true; break;
                    default : if(elapsedTime >= 61) isSetTemp = true; break;
                }//elaspseTime이 누적 되면서 case1에 경우 60초에 1도씩 내리는 sleep 메소드이고
                //case2는 30초보다 시간이 클때, case3는 20초보다 클때 온도세팅을 함
                if(isSetTemp){
                    if(lgAirCon.isHeater()) lgAirCon.setCurrTemp(1);
                    if(lgAirCon.isCooler()) lgAirCon.setCurrTemp(-1);
                    //setCurrTemp 설정에 따라 case 초마다 setCurrTemp 식에 1또는 -1대입됨
                    lgAirCon.airConInfo();
                    isSetTemp = false; // 다시 초기화
                    elapsedTime = 0; // 다시 초기화
                }
                if(lgAirCon.getCurrTemp() == lgAirCon.getSetTemp()){
                    //현재온도와 설정온도가 같으면 종료
                    System.out.println("에어컨을 종료합니다.");
                    break;
                }

            }
        }
    }



}

출력

에어컨을 켜시겠습니까?(yes/no) : yes
현재 온도가 30입니다.
온도를 설정하세요 : 25
설정 온도는 25입니다.
바람 세기를 설정 [1]1단, [2]2단, [3]3단 : 1
Cooler 가 동작 합니다.
=========에어컨 정보==========
전원 : ON
현재 온도 : 29
설정 온도 : 25
히터 : OFF
쿨러 : ON
바람세기 : 1단계
=========에어컨 정보==========
전원 : ON
현재 온도 : 28
설정 온도 : 25
히터 : OFF
쿨러 : ON
바람세기 : 1단계
=========에어컨 정보==========
전원 : ON
현재 온도 : 27
설정 온도 : 25
히터 : OFF
쿨러 : ON
바람세기 : 1단계
=========에어컨 정보==========
전원 : ON
현재 온도 : 26
설정 온도 : 25
히터 : OFF
쿨러 : ON
바람세기 : 1단계
=========에어컨 정보==========
전원 : ON
현재 온도 : 25
설정 온도 : 25
히터 : OFF
쿨러 : ON
바람세기 : 1단계
에어컨을 종료합니다.

 

3. instance of

 

package 객체타입확인;
// instanceof : 객체 타입을 확인하는 연산자
// 주로 상속 관계에서 부모 객체인지 자식 객체인지 확인
// 주로 형변환 가능 여부 확인용으로 사용 (true인 경우는 형변환이 가능하는 의미)
// 왼쪽은 참조 변수(parent,child,자식), 오른쪽은 클래스 타입(부모)
public class InstanceMain {
    public static void main(String[] args){
        Parent parent = new Parent("부모");
        Child child = new Child("자식");
        System.out.println(parent instanceof Parent);
        System.out.println(child instanceof Parent);
        System.out.println(parent instanceof Child);
        System.out.println(child instanceof Child);
        //부모는 자식의 객체를 마음대로 사용하지 못하므로 Child는 사용 못함
    }
}
class Parent {
    String name;
    public Parent(String name) {
        this.name = name;
    }
}
class Child extends Parent{
    String name;
    public Child(String name) {
        super(name);
        this.name = name;
    }
}

 

 

출력

true
true
false
true

4.매개변수의 다형성

 

package 매개변수의다형성;
// 운전자 클래스

public class Driver {
    String name;

    public Driver(String name) {
        this.name = name;
    }
    void drive(Vehicle vehicle) {
        System.out.print(name + "의 ");
        vehicle.run();
    }
}

package 매개변수의다형성;

import java.util.Scanner;

// 자동 타입 변환
public class TypeCastMain {
    public static void main(String[] args) {
        Driver driver = new Driver("우영우");
        Vehicle vehicle = new Vehicle();
        Bus bus = new Bus();
        Taxi taxi = new Taxi();
        Truck truck = new Truck();
        SportsCar sportsCar = new SportsCar();

        //instanceof 예시
        System.out.println(bus instanceof Vehicle);
        System.out.println(taxi instanceof Vehicle);
        System.out.println(truck instanceof Vehicle);
        System.out.println(truck instanceof Vehicle);
        System.out.println(vehicle instanceof Truck);
        //상속관계가 아니기 때문에 false



        Scanner sc = new Scanner(System.in);
        System.out.print("운전하고 싶은 차를 선택 [1]버스 [2]택시 [3]스포츠카 : ");
        int selectCar = sc.nextInt();
        switch (selectCar){
            case 1 : driver.drive(bus); break;
            case 2 : driver.drive(taxi); break;
            case 3 : driver.drive(sportsCar); break;
            case 4 : driver.drive(truck); break;
            //상속관계가 없으면 에러남 */
        }
    }
}

package 매개변수의다형성;

public class Vehicle {
    public void run(){
        System.out.print("차량이 달립니다.");
    }
}
class Bus extends Vehicle{
    @Override
    public void run(){
        System.out.print("버스가 달립니다.");
    }
}
class Taxi extends Vehicle{
    @Override
    public void run(){
        System.out.print("택시가 달립니다.");
    }
}
class SportsCar extends Vehicle {
    @Override
    public void run() {
        System.out.print("스포츠카가 달립니다.");
    }
}

class Truck extends Vehicle{
    public void run() {
        System.out.print("트럭이 달립니다.");
    }
}

출력

true
true
true
true
false
운전하고 싶은 차를 선택 [1]버스 [2]택시 [3]스포츠카 : 1
우영우의 버스가 달립니다.