상속, 오버라이딩(Overriding)

<상속(확장)>

 

: 상위 클래스의 자원을 하위 클래스에서 받아 쓰는 것.

하위 클래스 본래의 멤버에 상위 클래스의 멤버가 추가되기 때문에 하위 클래스의 범위가 더욱 크다. 상위 클래스에서 확장된 클래스다.

 

단, 자바는 다중상속(동시에 여러 개의 클래스에서 상속 받음)을 금지한다. -> 모호성 발생

상위 클래스는 하위 클래스의 자원을 쓸 수 없다★

 

 

 

 

<★오버라이딩★>

 

= 재정의

 
상위 클래스에 정의된 메소드를 하위 클래스에서 상속받은 뒤, 재정의하는 것. 
즉, 상위 클래스에서 하던 일이 하위 클래스에 가서 바뀐다. 객체지향의 다형성이라는 특징을 나타낸다.

 

1)상속일 때 이루어진다.

 

2)원형(prototype: 선언, declare)이 동일해야 한다.
-> {괄호: 정의(statement)}시작하기 전까지 완벽히 같아야 한다.

 

3)특히, 반환형 절대 바꿀 수 없다.({ } 전까지는 아무것도 바꿀 수 없다)

 

4)접근제한자는 상위에서 하위로 내려갈수록 같거나 넓어질 수는 있어도, 좁아질 수는 없다. 

 

오버라이딩 후, 상위 클래스의 원형을 호출할 때:  super.a(); 사용

-> main함수 안에서는 this로 멤버변수를 직접 호출할 수 없기 때문이다. 하위 클래스 안에서 상위 클래스의 원형을 호출하는 메소드를 만들어야 한다.

 

 

<예제>

 

 
class OverA {
    void show(String str) {
        System.out.println("상위클래스의 메소드 show(String str) 수행 " + str);
    }
}
 
class SubOverA extends OverA {
    void show() { //오버라이딩X 원형이 다름 -> 오버로딩! in 
        System.out.println("하위클래스의 메소드 show() 수행 ")
    }
}
 
public class OverrideExam1 {
    public static void main(String args[]) {
        SubOverA over = new SubOverA();
        over.show("STUDY JAVA");
        over.show();
        //상속받은 메소드 모두 사용 가능
    }
}

오버라이딩? 오버로드?

 

오버로딩(Overloading) 
: 동일한 클래스 안에 같은 이름의 메소드를 인자의 개수와 형을 달리하면서 여러번 선언하는 것.
같은 이름의 함수에게 여러가지 일을 시킨다. 리턴(반환) 타입이 달라도 된다.

 

1)이름만 같다. 2)동일한 클래스다.

 

 

 

 
class OverB {
    void show() {
        System.out.println("상위클래스의 메소드 show() 수행 ");
    }
}
 
class SubOverB extends OverB {
    void show() { //메소드 오버라이딩: 상위클래스의 메소드를 재정의
        System.out.println("하위클래스의 메소드 show() 수행 ")
    }
}
 
public class OverrideExam2 {
    public static void main(String args[]) {
        OverB ob = new OverB();
        ob.show();
 
        SubOverB over = new SubOverB();
        over.show();
        //하위클래스에서 상위클래스 호출하기 위해서는
        //super.show(); 호출하는 메소드 만들어야 한다.
    }
}

오버라이딩

 

 

 

 

 

 

 

 

<객체 형변환>

 

: 말 그대로 객체의 타입을 변환시켜주는 것.

상위클래스 객체 - new 하위클래스 객체로 생성자를 생성한 경우, 다시 하위클래스에 존재하는 메소드를 호출할 때 하위객체의 변수를 선언해줘야 한다. 이때 상위 인스턴스의 메모리 영역에 다시 하위 객체를 선언해야 하는데, 이 과정에서 상위 객체의 형을 하위 객체로 변환시켜야 한다.(예제 참고)

 

 

*객체 생성 공식
1)상객 = new 상생()

 

2)하객 = new 하생() -> 상속(상, 하위객체 멤버 모두 사용가능)

 

3) 상객 = new 하생() -> 다형성(오버라이딩, 상위멤버)

 

4)하객 != new 상생() -> X 성립 자체가 되지 않는다.

 

5)하객 != (하)상객 -> O 객체 형변환

 

 

<예제>

 

 
class OverD {
    void show(int k) {
        System.out.println("OverD: " + (k*10));
    } // ---> 은닉화
 
    void prn(int i) {
        System.out.println("OverD: prn(): " + i);
    }
}
 
class SubOverD extends OverD {
    void show(int i) {
        System.out.println("SubOverD: " + (i * 10000));
    } //오버라이딩
 
    void prn(String s) {
        System.out.println("SubOverD: prn(String s): " +s);
    } //오버로딩
 
    void scr() {
        System.out.pritnln("scr(): ");
    } //확장 메소드
}
 
class OverrideExam4 {
    public static void main(Stirng args[]) {
        OverD od = new SubOverD();
 
        od.show(1);
        //하위클래스의 메소드가 호출됨(오버라이딩)
        od.prn(1);
//--------------------여기까지는 상위클래스 멤버밖에 사용불가
        SubOverd sod = (SubOverD)od; // 하위객체 변수선언
                    // -> 객체 형변환
        sod.show(1);
        sod.prn("AAA");
        sod.scr();
    }
}

*선언은 두 번 했지만 인스턴스는 한 개만 생성되었다.(heap 영역 한 개 할당)