TIL JAVA #3-3

 

상속

오버라이딩 

---

<객체지향의 꽃 상속!>

 

자바에는 상속이라는 개념이 존재하는데 자식 클래스가 부모클래스를 상속 받을 수 있다.(필드와 메서드 같은 것들)

# 상속을 통해 코드 중복 제거, 재사용성 증가 이로 인해 생산성과 유지보수에 유리해진다.

 

상속

-> extends 키워드를 사용해 정의할 수 있다.

- 해당 키워드의 의미대로 상속을 '확장' 의 개념으로 이해하면 좋다.

- 자식 클래스는 부모 클래스를 물려받아 새롭게 필드, 메서드를 정의할 수 있다. 자식 클래스의 멤버 개수는 늘 부모의 것과 같거나 많다.

(자식 클래스가 더 큰 범주라고 생각하면 편함.)

 

예제를 통해 살펴보면 훨씬 이해가 빠르다.

 

#Car -> 부모 클래스

public class Car {

    String company; // 자동차 회사
    private String model; // 자동차 모델
    private String color; // 자동차 색상
    private double price; // 자동차 가격

    double speed;  // 자동차 속도 , km/h
    char gear = 'P'; // 기어의 상태, P,R,N,D
    boolean lights; // 자동차 조명의 상태

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public double gasPedal(double kmh, char type) {
        changeGear(type);
        speed = kmh;
        return speed;
    }

    public double brakePedal() {
        speed = 0;
        return speed;
    }

    public char changeGear(char type) {
        gear = type;
        return gear;
    }

    public boolean onOffLights() {
        lights = !lights;
        return lights;
    }

    public void horn() {
        System.out.println("빵빵");
    }

}

 

#SportsCar -> 자식 클래스

public class SportsCar extends Car{
    String engine;
    public void booster() {
        System.out.println("엔진 " + engine + " 부앙~\n");
    }
}

 

#Main

public class Main {
    public static void main(String[] args) {
        // 부모 클래스 객체에서 자식 클래스 멤버 사용
        Car car = new Car();
        // car.engine = "Orion"; // 오류  ->자식클래스에서 정의된 부분.
        // car.booster(); // 오류

        // 자식 클래스 객체 생성
        SportsCar sportsCar = new SportsCar();
        sportsCar.engine = "Orion"; //여기에서 사용해야 된다.
        sportsCar.booster();

        // 자식 클래스 객체에서 부모 클래스 멤버 사용
        sportsCar.company = "GENESIS";
        sportsCar.setModel("GV80");
        System.out.println("sportsCar.company = " + sportsCar.company);
        System.out.println("sportsCar.getModel() = " + sportsCar.getModel());
        System.out.println();

        sportsCar.horn();
        System.out.println(sportsCar.changeGear('D'));
    }
}

 

코드에서 볼 수 있듯, 자식 클래스는 부모 클래스를 상속 받았기 때문에 해당 클래스에서 따로 정의하지 않아도 부모 클래스의 멤버를 자유자재로 사용이 가능하다.

 

참고) 9번째 줄, 클래스는 설계도일 뿐 인스턴스화를 해서 객체를 만들어야함! 

---

#클래스간의 관계 

- 상속관계: is 

 ex) 스포츠카는 자동차이다. 케이크는 디저트이다.

- 포함관계: has

 ex) 자동차는 타이어를 갖고 있다. 선풍기는 날개를 갖고 있다.

 

-> Car 클래스에 포함되는 세가지 클래스

 

# Car 클래스 (포함관계)

public class Car {

    static final String company = "GENESIS"; // 자동차 회사
    String model; // 자동차 모델
    String color; // 자동차 색상
    double price; // 자동차 가격

    double speed;  // 자동차 속도 , km/h
    char gear = 'P'; // 기어의 상태, P,R,N,D
    boolean lights; // 자동차 조명의 상태

    Tire[] tire;
    Door[] door;
    Handle handle;

    public Car(String model, String color, double price) {
        this.model = model;
        this.color = color;
        this.price = price;
    }

    public void setTire(Tire ... tire) {
        this.tire = tire;
    }

    public void setDoor(Door ... door) {
        this.door = door;
    }

    public void setHandle(Handle handle) {
        this.handle = handle;
    }

    public double gasPedal(double kmh, char type) {
        changeGear(type);
        speed = kmh;
        return speed;
    }

    public double brakePedal() {
        speed = 0;
        return speed;
    }

    public char changeGear(char type) {
        gear = type;
        return gear;
    }

    public boolean onOffLights() {
        lights = !lights;
        return lights;
    }

    public void horn() {
        System.out.println("빵빵");
    }
}

 

포함되는 클래스들이 필드, 생성자에 정의된 것을 볼 수 있다.

 

# Main 클래스 (포함관계)

public class Main {
    public static void main(String[] args) {
        // 자동차 객체 생성
        Car car = new Car("GV80", "Black", 50000000);

        // 자동차 부품 : 타이어, 차문, 핸들 선언
        Tire[] tires = new Tire[]{
                new Tire("KIA", 150000), new Tire("금호", 150000),
                new Tire("Samsung", 150000), new Tire("LG", 150000)
        };
        Door[] doors = new Door[]{
                new Door("LG", "FL"), new Door("KIA", "FR"),
                new Door("Samsung", "BL"), new Door("LG", "BR")
        };
        Handle handle = new Handle("Samsung", "S");


        // 자동차 객체에 부품 등록
        car.setTire(tires);
        car.setDoor(doors);
        car.setHandle(handle);

        // 등록된 부품 확인하기
        for (Tire tire : car.tire) {
            System.out.println("tire.company = " + tire.company);
        }
        System.out.println();

        for (Door door : car.door) {
            System.out.println("door.company = " + door.company);
            System.out.println("door.location = " + door.location);
            System.out.println();
        }
        System.out.println();

        // 자동차 핸들 인스턴스 참조형 변수에 저장
        Handle carHandle = car.handle;
        System.out.println("carHandle.company = " + carHandle.company);
        System.out.println("carHandle.type = " + carHandle.type + "\n");

        // 자동차 핸들 조작해보기
        carHandle.turnHandle("Right");
        carHandle.turnHandle("Left");
    }
}

 

생성자 부분이 긴가민가했는데 포함관계를 공부하면서 자연스럽게 이해가 되었다.

 Main 메서드에 정의된 데이터를 받아와서 해당 클래스 필드에 저장한다. 이것을 각 클래스의 생성자를 통해 할 수 있다!

 

#다중상속

- 자바에서는 다중상속을 지원하지 않는다. 쉽게 말해 부모가 여러 자식을 갖는 건 가능하나 자식이 여러 부모를 가질 수 없음.

- 다중상속을 지원하게 되면 클래스간의 관계가 복잡해지고 만약 자식 클래스가 여러개의 부모클래스를 상속 받았는데

  각기 다른 부모클래스가 같은 이름의 멤버 변수를 갖고 있다면? 이것을 구분할 방법이 없다.

 

# final 클래스, 메서드

- 기본적으로 상속은 자식 클래스가 부모 클래스를 재정의하여 사용할 수 있게 하는 것이 목적이다. 그런데 변경이 불가능한 클래스, 메서드를 상속받는게 무슨 의미가 있을까? 그렇기 때문에 final 키워드가 붙은 클래스는 더 이상 상속할 수 없는 클래스가 된다.

 

#Object

- 말 그대로 "객체"를 의미하는 단어이며 보통 Object 클래스를 의미한다.

** Object 클래스는 Java내의 모튼 클래스들의 최상위 부모 클래스이다!

---

 

오버라이딩 / super

#오버라이딩

- 부모로부터 상속받은 메서드의 내용을 재정의하는 것을 오버라이딩 이라고 한다.

 

애너테이션 @override 를 사용한다.

 

@Override
public String breakPedal(){
	speed =100;		//원래 부모클래스에서는 해당 메서드 호출 시 스피드 0으로 만들었음
    				//자식 클래스에서 재정의
    s.o.println("브레이크란 없다!");
    return speed; //100을 return하게 됨
}

- 이렇듯 부모 클래스의 메서드를 자식 클래스가 재정의해서 사용할 수 있음

 

#super, super()

:this, this() 인스턴스, 생성자 이것과 비슷한 모습이다.

super: 자식클래스에서 부모클래스에 접근할 수 있게 해주는 부모자신을 가리키는 키워드이다.

 

#다형성

: 객체지향&상속에서 중요한 특징이다.

-> 다양한 형태를 가질 수 있다.

객체를 생성할 때 

Mammal mammal = new Whale(); 해당 선언이 가능하다. -> 고래에서 포유류 즉 부모클래스로 자동으로 형변환이 가능하다.

-> 이런식으로 자동형변환하는 방법이 있고

또, 참조변수 타입변환을 활용해서 다형성을 구현할 수 있다!

 

- instance of

: 다형성 기능으로 클래스의 원래 클래스명을 확인하는 것이 필요하다. 해당 명령어를 통해 확인 가능하다.

결과는 boolean 타입으로 출력된다.

 

#추상클래스 -> abstract 키워드 !

부모클래스 abstract 클래스 & 메서드

자식클래스 부모클래스를 extends, 추상메서드를 반드시 @override 해서 사용해야함!

 

만약 클래스 A, B, C 에 메서드가 각각 3개씩 있다. 그런데 코드를 보니 2개는 완전히 똑같고 한 메서드만 내용이 다르다.

그렇다면, 이럴 때 부모 클래스를 생성해 완전히 똑같은 메서드 두개는 일반 메서드로 정의하고 다른 나머지 한 메서드만 추상메서드로 작성해 자식 클래스 A, B, C 가 그것을 @override 하여 해당 부분만 각각 다르게 작성해주면 될 것이다.

 

-> 코드로 확인하기

- Car (부모)

public abstract Car{
	String company;
    String color;
    double speed;
    
    public double gasPedal(){
    	speed = kmh;
        return speed;
    }
    
    public double breakPedal(){
    	speed = 0;
        return speed;
    } 
    
    public abstract void horn();//추상메서드는 중괄호없이 이렇게 작성하면 된다.
    
}

 

- AudiCar (자식) .. 편의상 자식클래스는 하나만 작성하였다.

public AudiCar extends Car { //부모클래스 상속받고
	
    @Override //오버라이딩해서
    public void horn(){
    	System.out.println("빵빵!"); //추상메서드를 완성시켜주면 된다.
    }
    //다른 필드나 메서드는 당연히 상속받은 상태!
}

 

여기까지 상속! 일단 끝!

---

#interface 

 

- 두 객체를 연결해주는 매개체 역할을 한다.

- 상속관계가 없는 서로 다른 클래스들이 서로 동일한 메서드를 구현해야할 때 인터페이스를 사용하면 된다.

- implements 키워드를 사용하여 인스턴스를 구현할 수 있다.

 

^ 모든 멤버변수는 public static final 이어야 함.

^ 모든 메서드는 public abstract 이어야 함.

 

++인터페이스는 추상클래스와 마찬가지로 직!접! 인스턴스를 생성할 수 없기 때문에 클래스에 구현되어 생성된다.

 

+ 인터페이스간의 상속이 가능하고 이때는 extends 사용.

+ 인터페이스는 클래스와 달리 다중상속이 가능하다.

 

예제를 살펴보자!

public class Main extends D implements C { //Main은 D클래스 상속받고
										  //C 인터페이스 implements도 함. 
	//a(), b() -> 인터페이스의 추상메서드 오버라이딩.
    @Override
    public void a() {
        System.out.println("A");
    }

    @Override
    public void b() {
        System.out.println("B");
    }

	
    @Override
    void d() {
        super.d();
    }

    public static void main(String[] args) {
        Main main = new Main();
        main.a();
        main.b();
        main.d();
    }
}

interface A {
    void a(); //추상메서드
}

interface B {
    void b(); //추상메서드 public abstract 는 생략됨
}

interface C extends A, B { //인터페이스간 다중상속!
}

class D {
    void d() {
        System.out.println("D");
    }
}