• 두 개의 클래스를 만들어야 할 일이 있는데 한 클래스가 다른 클래스의 기능들을 모두 포함하는 형태일 때 상속을 사용해야한다.
• “00은 00의 종류 중 하나다” 라고 말할 수 있다면 이 관계를 상속 관계라고 한다. 상속 관계는 is a 관계 혹은 kind of 관계라고도 한다.
  • ex) 세탁기는 가전 제품이다. 선풍기는 가전 제품이다.
• 이미 개발된 클래스를 재사용하여 새로운 클래스를 만들기 때문에 중복되는 코드를 줄여준다.
• 프로그램에서는 자식이 부모를 선택한다. 자식 클래스를 선언할 때, 어떤 부모 클래스를 상속받을지를 결정한다.

예시

• 전자제품,TV,전자레인지 클래스가 있다고 생각해보자.
• TV와 전자레인지는 전자제품에 포함되기 때문에 전자 제품은 부모 클래스, TV와 전자레인지는 자식 클래스가 된다.
• 자식 클래스는 부모 클래스의 메소드를 사용할 수 있다.
  • ex) TV와 전자레인지는 끄다,켜다 메소드를 사용할 수 있다.
• 여러 종류의 객체를 하나의 이름으로 부를 수 있는 것을 일반화라고 한다.
• 상속은 강한 결합이다. 반드시 써야할 때만 쓰는 것이 좋다. 잘못 받으면 타격이 크다.

선언 방법

[접근 제한자][abstract, final] class 클래스명 extends 부모 클래스명{}

상속의 특징

• 여러 개의 부모 클래스를 상속할 수 없다.
  • extends 뒤에는 단 하나의 부모 클래스만 와야한다
  • 아무 것도 상속받지 않으면 java.lang.Object를 상속받는다.
    • 모든 클래스는 오브젝트의 자식이다
• 부모 클래스에서 private 접근 제한자를 갖는 필드와 메소드는 상속 대상에서 제외된다. 또한 부모 클래스와 자식 클래스가 다른 패키지에 존재한다면 default 접근 제한자를 갖는 필드와 메소드도 상속 대상에서 제외된다.
• 부모 타입으로 자식 타입을 참조할 수 있다.
  • 버스는 자동차다
  • Car car = new Bus();

    • Bus인스턴스가 만들어졌지만 실제 참조는 Car타입으로 한다.

      

    • 앞의 변수 참조 타입만 보면 이 변수가 어떤 메소드를 사용할지 알 수 있음

부모 생성자의 호출

• 자바에서는 자식 객체를 생성하면 부모 객체가 먼저 생성되고 그 다음 자식 객체가 생성된다.
• 메모리로 표현하면 이렇게 참조된다.
  • 스택영역의 자식 클래스 객체 번지 → 힙영역의 자식 객체 번지 → 힙영역의 부모 객체 번지
• 그렇다면 부모 객체를 생성하기 위해 부모 생성자를 어디서 호출하는 것일까??
  • 부모 생성자는 자식 생성자의 맨 첫줄에 super()라는 키워드를 통해 호출된다.
  • super()는 부모의 기본 생성자를 호출한다.
  • super(매개변수,…)는 매개변수의 타입과 일치하는 부모 생성자를 호출한다.
  • super키워드를 생략해도 컴파일러가 super()가 자동으로 추가하기 때문에 부모의 기본 생성자가 호출된다. 만약 부모 클래스에 기본 생성자가 없고 매개 변수가 있는 생성자만 있다면 자식 생성자에서 반드시 부모 생성자 호출을 위해 super(매개변수,..)를 명시적으로 호출해야한다.
  • super 키워드는 자식 생성자 첫 줄에 위치해야한다.

예제

public class Parent {
    public String name;
    public int id;
    
    public Parent(String name, int id) {
        this.name = name;
        this.id = id;
    }
}
public class Child extends Parent{
    int birthData;
    public Child(String name, int id, int birthData){
        super(name,id);
        this.birthData=birthData;
    }
}
public class Exam {
    public static void main(String[] args) {
        Parent parent = new Parent("김민제", 1);
        System.out.println(parent.name + " : " + parent.id);
        Child child = new Child("김민제", 1, 1999);
        System.out.println(child.name + " : " + child.id + ", " + child.birthData);
    }
}
->김민제 : 1
	김민제 : 1, 1999

다형성 - 메소드 오버라이딩(overriding)

• 상위 클래스의 메소드가 하위 클래스의 메소드를 재정의하는 것
• 메소드 오버로딩은 매개 변수를 다양하게 받아들이는 메소드를 여러 개 만들어서 사용자가 편리하게 사용하도록 하는 것
• 메소드 오버라이딩은 부모가 가지고 있는 메소드를 완전히 같은 형태로 가지고 있는 것을 말한다.
  • 메소드가 오버라이딩되면 무조건 자식 클래스에 있는 메소드가 실행된다.
  • 자식 클래스에서 오버라이딩한다는 것은 그 오버라이딩된 메소드에 한해서는 이제부터 자식 클래스의 메소드를 사용한다는 뜻

메소드 오버라이딩 방법

• 부모의 메소드와 동일한 시그니처(리턴 타입, 메소드 이름, 매개 변수 목록)를 가져야한다.
• 접근 제한을 더 강하게 재정의할 수 없다.(ex. public → private,default로 수정 불가능)
• 새로운 예외(Exception)를 throws할 수 없다.
• 자식 클래스에서 부모 클래스의 메소드를 재정의하게되면 부모 클래스의 메소드는 숨겨지고 재정의된 자식 메소드만 사용된다. 자식 클래스 내부에서 부모 클래스의 메소드를 호출해야한다면 super키워드를 붙여서 부모메소드를 호출할 수 있다.
• 예제

public class Parent {
    public void print1() {
        System.out.println("부모 클래스임당!");
    }
    public void print2(){
        System.out.println("부모 메소드 호출!");
    }
}

public class Child extends Parent{
    public void print1(){
        System.out.println("자식임당..");
    }
    public void print2(){
        super.print2();
        System.out.println("자식 클래스 호출!");
    }
}

public class Exam {
    public static void main(String[] args) {
        Parent parent = new Parent();
        parent.print1();
        Child child = new Child();
        child.print1();
        parent.print2();
        child.print2();
    }
}
->부모 클래스임당!
	자식임당..
	부모 메소드 호출!
	부모 메소드 호출!
	자식 클래스 호출!

다형성

• 다형성은 사용 방법은 동일하지만 다양한 객체를 이용하여 다양한 실행결과가 나오도록 하는 성질이다.
• 다형성을 구현하려면 메소드 재정의와 타입 변환이 필요하다.
• 다형성의 장점
  1. 유지보수 : 여러 객체를 하나의 타입으로 관리할 수 있어 유지보수가 용이하다.
  2. 재사용성 : 객체의 재사용이 쉬워 재사용성이 높아진다.
  3. 느슨한 결합 : 클래스 간의 의존성을 줄여 확장성은 높아지고 결합도는 낮아진다.

자동 타입 변환

• 자식은 부모 타입으로 자동 타입 변환이 가능하다.
• 자동 타입 변환은 프로그램 실행 도중에 자동적으로 타입 변환이 일어나는 것을 말한다.
• 자동 타입 변환은 다음과 같은 조건에서 일어난다.

  부모타입 변수명 = new 자식타입;

• 자동 타입 변환의 개념은 부모의 특징과 기능을 상속받기 때문에 부모와 동일하게 취급될 수 있다.
• 예를 들어, 고양이가 동물의 특징과 기능을 상속받았다면 ‘고양이는 동물이다’가 성립된다.

오버라이딩

• 우리는 위에서 오버라이딩을 공부하였다. 다형성을 구현하려면 메소드 오버라이딩이 필요하다.
• Car class의 run을 “전륜구동한다.”라고 두고 Bus class의 run을 “후륜구동한다.”라고 두면 출력은 둘 다 “후륜구동한다”로 출력된다
• 둘 다 bus의 인스턴스를 생성했기 떄문에 bus의 메소드가 실행된다.

  • bus는 후륜 구동으로 가도록 만들어놨기 때문에 “후륜구동한다”가 출력됨

    ** 메소드가 오버라이딩되면 무조건 자식 클래스의 메소드가 실행된다.

• 필드는 Type을 따라가고 메소드는 오버라이딩된 자식의 메소드를 따라간다.

Parent.class
public class Parent {
    int i = 5; // 필드에 대한 오버라이딩
		public void printII(){
			System.out.println(i*2);
		}
    public void printI(){
        System.out.println("Parent - printI() : " + i); // 메소드에 대한 오버라이딩
    }
}

child.class
public class child extends Parent{
    public int i = 15; // 필드에 대한 오버라이딩
    public void printI(){
        System.out.println("Child - printI() : " + i); // 메소드에 대한 오버라이딩
    }
}

exam01.class
public class exam01 {
    public static void main(String[] args) {
        Parent p1 = new Parent();
        System.out.println(p1.i); //5
        p1.printI(); //5

        child c1 = new child();
        System.out.println(c1.i); //15
        c1.printI(); //15

        Parent p2 = new child(); //child는 Parent의 자식이기 때문에 오류 안 남
        System.out.println(p2.i); //5
				p2.printII(); //10, child의 i*2가 되어 30이 나올 것이라고 예상했지만 필드는 부모 타입을
											//    따라가기 때문에 10 출력
        p2.printI(); //15
    }
}

• 메소드 오버라이딩만 기억하면 됨
• 정보 은닉은 객체 지향의 중요한 기법이다. 중요한 필드는 은닉하고, 필드는 메소드를 통해서만 접근하도록 사용한다.
  • exam01에서는 parent나 child의 필드 i에 직접 접근하면 안된다. 필드에 직접 접근하지 않고 메소드를 통해서 바꾸거나 접근해야함
  • 이러한 개념을 정보 은닉이라 하고 객체 지향 문법 중 접근 지정자를 사용하여 은닉한다.
  • 안전을 위해 만든 신호등 때문에 지각을 했다고 신호등을 없애면 안된다.
  • 앞으로 클래스를 만들 때 정보를 외부에 드러나지 않도록 하는 기법들을 사용할 것인데 이를 신호등을 세운다고 생각하면 된다.

다형성을 사용하는 이유(feat.Object)

• 부모 타입의 변수로 자식 인스턴스를 참조할 수 있다.
• 조상 타입의 변수로 후손 인스턴스를 참조할 수 있다.
• Parent c1 = new Child(); -> Parent는 Child의 자손이다.
• 아무것도 상속받지 않으면 Object를 상속받는다
• Object b1 = new Parent();
• Object b2 = new Child();
• prinrln(Object x)처럼 object를 받아들일 수 있다는 것은 Object로 참조할 수 있는 것은 무엇이든 받을 수 있다.
• Object의 자손들은 다 이 메소드에 올 수 있다.
• System.out.println(b1.toString()); == System.out.println(b1);

다형성 사용 예시

• 다형성은 어떻게하면 잘 활용할 수 있을까?
• 성별과 성별에 따른 id를 출력하는 예시를 만들어보자

  class Gender {
      int id ;
      public Gender(int id){
          this.id = id;
      }
  }
  
  class Male extends Gender{
      //상위 메소드의 생성자를 호출하고 인자로 1을 넣어줌
      public Male() {
          super(1);
      }
      @Override
      public String toString() {
          return "Male{" +
                  "id=" + id +
                  '}';
      }
  }
  
  class Female extends Gender{
      //상위 메소드의 생성자를 호출하고 인자로 1을 넣어줌
      public Female() {
          super(2);
      }
  
      @Override
      public String toString() {
          return "Female{" +
                  "id=" + id +
                  '}';
      }
  }
  
  public class GenderInfo {
      void genderInfo(Gender gender){
          System.out.println(gender);
          System.out.println("id만 출력 : " + gender.id);
      }
  }
  
  class Main {
      public static void main(String[] args){
          GenderInfo gender = new GenderInfo();
          gender.genderInfo(new Male());
          gender.genderInfo(new Female());
      }
  }
  ->Male{id=1}
  	id만 출력 : 1
  	Female{id=2}
  	id만 출력 : 2

  • 위와 같이 사용할 수 있다.
  • 우선 Gender클래스를 만들어 id값을 매개변수로 받아 필드에 저장하는 생성자를 만들어준다.
  • 그 다음 Male과 Female 클래스를 만들어 Gender를 상속한 뒤 생성자를 만들어 super키워드를 통해 부모의 생성자에 인자를 넣어 반환하여 준다.
  • 그 다음 GenderInfo 클래스를 만들어 Gender클래스의 객체를 매개변수로 받는 메소드를 만들어주고 원하는 값을 출력해준다.
    • 여기서 다형성이 활용되는데 따로 Male,Female 메소드를 구현하지 않아도 기능을 사용할 수 있다는 장점이 있다.
  • main 메소드에서 GenderInfo 객체를 생성하고 genderInfo에 Male,Female 객체를 생성하여 매개변수로 넘겨주어 사용한다.