💡 목표 : 자바의 상속에 대해 학습해보자.

⚡️ 목차

• 자바 상속의 특징
• super 키워드
• 메소드 오버라이딩
• 다이나믹 메소드 디스패치 (Dynamic Method Dispatch)
• 추상 클래스
• final 키워드
• Object 클래스

상속의 개념

상속(inheritance)이란 기존의 클래스에 기능을 추가하거나 재정의하여 새로운 클래스를 정의하는것을 의미한다. 이러한 상속은 캡슐화, 추상화와 더불어 객체 지향 프로그래밍을 구성하는 중요한 특징 중 하나이다. 상속을 이용하면 기존에 정의되어 있는 클래스의 모든 필드와 메서드를 물려받아, 새로운 클래스를 생성할 수 있다.

상속의 장점

1. 기존에 작성된 코드를 재활용 할 수 있어 개발시간이 단축된다.
2. 먼저 작성한 검증된 프로그램을 재사용하기 때문에 신뢰성 있는 프로그램 개발 가능.
3. 클래스 간 계층적 분류 및 관리가 가능하여 유지보수가 용이하다.

상속 선언

• 부모 클래스를 슈퍼 클래스(super class), 상속 받는 자식 클래스를 서브 클래스(sub class)라고 한다.
• 상속을 선언할 때는 extends 키워드를 사용한다.

public class Phone {
	
    public void call() {
    	System.out.println("전화를 겁니다...");
	}
    
    public void send() {
    	System.out.println("전화를 받습니다...");
	}
}

public class SmartPhone extends Phone { 
//상속 선언 (스마트폰은 전화기를 상속받는다.)

	public void wifi()	{
    	System.out.println("와이파이를 연결합니다...");
	}
}

• 스마트폰 클래스는 전화기 클래스의 call(), send() 기능을 물려받으므로 스마트폰 클래스에서 메서드를 다시 반복하여 작성할 필요가 없다.
• 스마트폰의 추가 기능인 wifi() 메서드만 작성하면 된다.

서브 클래스 객체

public class Ex01 {
	public static void main(String[]args) {
    	Phone p1 = new Phone(); // 전화기 객체 생성
        
        p1.call();
        p1.send();
        
        SmartPhone p2 = new SmartPhone(); // 스마트폰 객체 생성
        
        p2.call(); 	 // 스마트폰 클래스에서 전화기 클래스의 메서드에 접근
        p2.send();
        p2.wifi();   // 기능 확장
	}
}

• 생성된 객체는 p1, p2이다.
• p1 객체는 Phone 클래스의 기능만 가지고 p2는 Phone 클래스와 SmartPhone 클래스의 기능 모두 가질 수 있다.

상속의 특징

• 자바에서는 다중 상속을 지원하지 않는다.
  • extends 키워드 뒤에는 하나의 클래스만 올 수 있다.
• 자바에서는 상속의 횟수를 제한하지 않는다.
• 자바에서 계층구조의 최상위에 java.lang.Object 클래스가 있다.
  자바에서 모든 클래스는 Object 클래스를 자동으로 상속 받도록 되어있다.
  toString(), equals()와 같은 메서드를 바로 사용할 수 있다.
  

super 키워드

super 키워드는 부모 클래스로부터 상속받은 필드나 메서드를 자식 클래스에서 참조하는데 사용하는 참조 변수이다. 인스턴스 변수의 이름과 지역 변수의 이름이 같을 경우 인스턴스 변수 앞에 this 키워드를 사용하여 구분하는 것처럼, 부모 클래스의 멤버와 자식 클래스의 멤버가 동일할 경우 super 키워드를 사용하여 구별할 수 있고, super를 사용하여 부모 클래스의 멤버에 접근 할 수 있다. this와 마찬가지로 super 참조 변수를 사용할 수 있는 대상도 인스턴스 메서드 뿐이며, 클래스 메서드(static)에서는 사용할 수 없다.

class Parent {
	int x = 10;
}

class Child extends Parent {
	int x = 20;
    
    void method() {
    	System.out.println("x = " + x);
        System.out.println("this.x = " + this.x);
        System.out.println("super.x = " + super.x);
	}
}

public class SuperTest {
	public static void main(String[]args) {
    	Child c = new Child();
        c.method();
	}
}

Output
x = 20
this. x = 20
super.x = 10

this 키워드는 현재 자기 자신의 멤버인 x = 20을 반환했고 super 키워드는 부모 클래스에서 상속 받은 x = 10을 반환했다.

super() 메서드

super()는 자식 클래스의 생성자에서 부모 클래스의 생성자를 호출하기 위해 사용한다. 자식 클래스가 인스턴스를 생성하면 인스턴스 안에는 자식 클래스의 고유 멤버 뿐만 아니라 부모 클래스의 모든 멤버까지 포함되어 있다. 하지만 상속에서의 생성자는 상속되지 않는 유일한 멤버 함수이다. 따라서 부모 클래스의 멤버를 초기화 하기 위해선, 당연히 부모 클래스의 생성자를 호출해야 할 것이다. 즉, 자식 클래스의 모든 생성자는 부모 클래스의 생성자를 포함하고 있어야 한다. 그런데 만약 자식 클래스의 생성자에 부모 클래스의 생성자가 정의되어 있지 않다면, 컴파일러가 자동으로 부모 클래스의 기본 생성자를 호출해준다. (이러한 경우, 부모 클래스에 매개변수가 있는 생성자만 있고 기본 생성자가 없어 기본 생성자를 호출 할 수 없다면 ? ➡️ 에러 발생)[

public class Book { // 부모 클래스
	
    String title = "미입력";
    int price = -1;
    int code = 100;
    
    public Book() {} // 기본 생성자
    
    public Book (String title, int price) { //매개변수가 2개인 생성자
    	this.title = title;
        this.price = price;
	}
    
    public void showPrice() {
    	System.out.println(title + " 의 가격은 " + price + "원 입니다.");
	}
}

public class EnglishBook extends Book { // 자식 클래스

	int code = 200;
    
    public EnglishBook() {} // 기본 생성자
    
    public EnglishBook(String title, int price) { //매개변수가 2개인 생성자
    	super(title, price);
	}
    
    public void showPrice() {
    	super.showPrice();
        
		System.out.println("code : " + code);
		System.out.println("this.code : " + this.code);
		System.out.println("super.code : " + super.code); // 부모 클래스의 code

		System.out.println("price : " + price);
		System.out.println("this.price : " + this.price);
		System.out.println("super.price : " + super.price); // 부모 클래스의 price

public class HelloWorld { // 객체 생성 및 실행
	public static void main(String[]args) {
    	EnglishBook b1 = new EnglishBook("영어책", 10000);
        b1.showPrice();
	}
}

Output
code : 200
this.code : 200
super.code : 100
price : 10000
this.price : 10000
super.price : 10000

메서드 오버라이딩

오버라이딩(overriding)이란 부모 클래스로부터 상속받은 메서드를 자식 클래스에서 재정의 하는 것이다. 상속받은 메서드를 그대로 사용할 수도 있지만, 자식 클래스에서 상황에 맞게 변경해야 하는 경우 오버라이딩 할 필요가 생긴다.

오버라이딩 조건

오버라이딩은 부모 클래스의 메서드를 재정의 하는것이므로, 자식 클래스에서는 오버라이딩 하고자 하는 메서드의 이름, 매개변수, 리턴 값이 모두 같아야한다.

public class OverridingTest {
	public static void main(String[]args) {
    	Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();
        
        animal.cry();
        dog.cry();
        cat.cry();
	}
}

class Animal {
	void cry() {
    	System.out.println("동물의 울음소리");
	}
}

class Dog extends Animal {
	@Override
    public void cry() {
    	System.out.println("멍멍");
	}
}

class Cat extends Animal {
	@Override
    public void cry() {
    	System.out.println("야옹");
	}
}

Output
동물의 울음소리
멍멍
야옹

오버로딩과 오버라이딩 차이

오버로딩과 오버라이딩은 이름이 비슷할 뿐 전혀 다른 역할을 한다.

• 오버로딩 : 기존에 없는 새로운 메서드를 추가하는 것.
• 오버라이딩 : 상속받은 메서드를 재정의 하는 것.

구분	Overriding	Overloading
접근제어자	부모 클래스의 메서드의 접근 제어자보다 더 넓은 범위의 접근 제어자를 자식 클래스의 메서드에서 설정할 수 있다.	모든 접근제어자를 사용 할 수 있다.
리턴형	동일해야 한다	달라도 된다
메서드명	동일해야 한다	동일해야 한다
매개변수	동일해야 한다	달라야만 한다
적용범위	상속관계에서 적용된다	같은 클래스 내에서 적용된다

다이나믹 메서드 디스패치 (Dynamic Method Dispatch)

다이나믹 메서드 디스패치는 오버라이드 된 메서드에 대한 호출이 컴파일 타임이 아닌, 런타임에 결정되는 매커니즘 이다. 오버라이드 된 메서드가 부모 클래스 참조 객체에 의해 호출 될 때, 자바는 참조 변수의 유형이 아닌 호출 시 참조되는 객체에 따라 실행되는 메서드의 버전(슈퍼 / 서브 클래스)을 결정한다. 따라서, 이 결정은 런타임에 이루어진다. 슈퍼 클래스 참조 변수는 서브 클래스 객체를 참조할 수 있으며 이를 업캐스팅 이라고 한다. 슈퍼 클래스가 서브 클래스에 의해 재정의되는 메서드를 포함하는 경우, 슈퍼 클래스 참조 변수를 통해 서로 다른 유형의 개체를 참조할 때 서로 다른 버전의 메서드가 실행된다.

코드를 보면 overriding을 통해 메서드를 재정의 해두고, 메인 함수에서 동일한 이름의 메서드를 호출하고 있다. 결과는?

static class Super {
	void print() {
    	System.out.println("super's print");
	}
}

static class Sub1 extends Super {
	@Override
    void print() {
    	System.out.println("sub1's print");
	}
}

static class Sub2 extends Super {
	@Override
    void print() {
    	System.out.println("sub2's print");
	}
}

public static void main(String[]args) {
	Super reference = new Super(); // 1)
    reference.print();
    reference = new Sub1(); // 2)
    reference.print();
    reference = new Sub2(); // 3)
    reference.print();
}

Super 타입의 객체인 reference에 자식 객체인 Sub1과 Sub2를 대입하면 upcasting이 이루어지고, reference는 대입될 때 마다 자식 객체의 주소를 가르키게 된다. 혼란이 있을까 언급하자면, reference가 3개의 객체를 모두 가르키는 것이 아니라 대입될 때 마다 순서대로 가르키게 된다.

Output
super's print
sub1's print
sub2's print

출력에서 알 수 있듯이, 실행되는 메서드의 버전은 호출 시 참조되는 객체의 유형에 따라 결정된다. 이처럼 Super 타입의 reference 참조 변수가 컴파일 시 타입(Super)이 아닌, 런타임 시 참조되는 객체의 타입에 따라 오버라이드 된 메서드의 버전을 결정하는 것이 다이나믹 메서드 디스패치 라고 부른다. 단 주의할 점이 있다! 자바에서 변수가 아닌 메서드만 오버라이드가 가능한 것처럼, 런타임 다형성은 데이터 멤버 변수에서는 보장되지 않는다.

class A {
	int x = 10;
}

class B extends A {
	int x = 20;
}

public class Test {
	public static void main(String[]args) {
    	A a = new B();
        System.out.println(a.x);
	}
}

Output
10

A 타입의 참조변수 a에, B 객체를 할당한 후 a 변수의 x 값을 출력하는 프로그램이다. B 객체를 할당 하였기 때문에 20이 출력될 것으로 예상했지만, 10이 출력되었다 왜일까 ? 이는 앞서 말한 런타임 다형성은 데이터 멤버 변수에는 보장되지 않기 때문이다. 따라서 a.x는 항상 슈퍼 클래스의 데이터 변수를 참조하게 된다.

추상 클래스

추상 클래스란 무엇일까 ? 쉽게 설명하자면 여러 클래스들에서 공통적으로 사용되는 메서드의 모음집이라고 생각 할 수 있겠다. 예를 들어보자 사람 얼굴은 모두 다르지만 눈 두개, 코 하나, 입 하나를 공통적으로 가지고 있다. 여기서 A라는 사람은 눈, 코, 입을 가지고있고, 마찬가지로 B라는 사람도 눈, 코, 입을 가지고 있을 것이다. 이제 A와 B라는 사람을 클래스로 보고 눈, 코, 입을 변수로 보자. A와 B는 둘다 웃는 행동을 할 수 있다. A라는 사람은 하하 웃지만, B라는 사람은 헤헤 하고 웃는다 둘은 각자의 웃음 소리대로 웃지만, 공통적으로 웃는다 라는 액션을 취하고있다. 이는 공통적인 메서드가 된다. 따라서 추상 클래스에 해당 메서드를 넣을 수 있다. 정리를 해보면 추상 클래스는 실체 클래스의 공통적인 부분을 추출해 어느정도 규격만 잡아놓는 추상적인 클래스이다. 추상 클래스는 메서드와 내용이 추상적이기 때문에 객체를 생성할 수 없다 그럼 어떻게 사용할까 ? 실체 클래스에서 추상 클래스를 상속받아 추상적이었던 클래스를 구체화 시키며(웃음 소리 = 하하, 헤헤..) 사용한다! 서론이 길었다,, 예시를 코드로 보자!

abstract class Person { //추상 클래스
	abstract void smile();  //추상 메서드 -> 내용을 정의 하지 않는다.
}

public class A extends Person { // 추상 클래스를 상속받아 실체 클래스를 만듦
	
    @Override
    public void smile() {
    	System.out.println("하하"); // 추상 메서드를 구체화 시킨다. -> 다형성
	}
}

public class B extends Person { // 추상 클래스를 상속받아 실체 클래스를 만듦
	
    @Override
    public void smile() {
    	System.out.println("헤헤"); // 추상 메서드를 구체화 시킨다. -> 다형성
	}
}

public class Main {
	public static void main(String[]args) {
    	
        A personA = new A();
        personA.smile();
        
        B personB = new B();
        personB.smile();
	}
}

Output
하하
헤헤

이해가 조금 되었길 바라며 추상 클래스에 대해 다시 한번 정리를 해보자.
자바에서는 하나 이상의 추상 메서드를 포함하는 클래스를 추상 클래스라고 한다. 이러한 추상 클래스는 객체 지향 프로그래밍에서 중요한 특징인 다형성을 가지는 메서드의 집합을 정의할 수 있도록 해준다. 즉, 반드시 사용되어야 하는 메서드를 추상 클래스에 추상 메서드로 선언해 놓으면, 추상 클래스를 상속받는 모든 클래스에서는 추상 메서드를 반드시 재정의 해야한다. 추상 클래스는 동작이 정의되어 있지 않은 추상 메서드를 포함 하고 있으므로, 인스턴스를 생성할 수 없다. 추상 클래스는 먼저 상속을 통해 자식 클래스를 만들고, 만든 자식 클래스에서 추상 클래스의 모든 추상 메서드를 오버라이딩하고 나서야 비로소 자식 클래스의 인스턴스를 생성할 수 있다.

final 키워드

final 키워드는 변수(variable), 메서드(Method), 또는 클래스(class)에 사용될 수 있다. 이 final 키워드는 어떤 곳에 사용되느냐에 따라 다른 의미를 가진다. 하지만 final 키워드를 붙이면 무언가 제한한다는 의미를 가지는 것은 공통적인 성격이다.

1. final 변수

1.1 원시타입

로컬 원시 변수에 final로 선언하면 한번 초기화된 변수는 변경할 수 없는 상수값이 된다.

public void primitiveVariables() {
	final int x = 1;
    x = 3; // 한번 assign되면 변경할 수 없다.
}

1.2 객체타입

객체 변수에 final로 선언하면 그 변수에 다른 참조 값을 지정할 수 없다. 원시 타입과 동일하게 한번 쓰여진 변수는 재변경이 불가하다. 단 객체 자체가 immutable하다는 의미는 아니다. 객체의 속성은 변경 가능하다.

public void referenceVariables() {
	final Pet pet = new Pet();
    pet = new Pet(); // 다른 객체로 변경할 수 없음.
    per.setWeight(3); // 객체 필드는 변경 가능.
}

1.3 메서드 인자

메서드 인자에 final 키워드를 붙이면, 메서드 안에서 변수 값을 변경 할 수 없다.

public class Pet {
	int weight;
    public void setWeight(final int weight) {
    	weight = 1; //final 인자는 메서드 안에서 변경할 수 없다.
	}
}

1.4 필드

클래스의 필드에 final로 선언하면 상수값이 되거나 write-once 필드로 한번만 쓰이게 된다. final로 선언하면 초기화 되는 시점은 생성자 메서드가 끝나기 전에 초기화 된다. 하지만 static이냐 아니냐에 따라서도 초기화 시점이 달라진다.

• static final 필드 (static final int x = 1)
  • 값과 함께 선언 시
  • 정적 초기화 블럭에서 (static initialization block)
• instance final 필드 (final int x = 1)
  • 값과 함께 선언 시
  • 인스턴스 초기화 블럭에서 (instance initialization block)
  • 생성자 메서드에서

1.4.1 인스턴스 초기화 블럭 vs 정적 초기화 블럭

인스턴스 초기화 블럭	정적 초기화 블럭
객체 생성할 때마다 블럭이 실행된다
부모 생성자 이후에 실행된다	클래스 로드시 한번만 블럭이 생성된다
생성자보다 먼저 실행된다

2. final 메서드

메서드를 final로 선언하면 상속받은 클래스에서 오버라이드가 불가능 하게 된다. 예를들어, Dog라는 객체는 Pet 클래스 안의 final로 선언된 makeSound() 메서드를 재정의 할 수 없다. 그렇다면 final 메서드는 언제 사용하면 좋을까 ? 구현한 코드의 변경을 원치 않을 때 사용한다. side-effect가 있으면 안되는 자바 코어 라이브러리에서 final로 선언된 부분을 많이 찾을 수 있다.

public class Pet {
	public final void makeSound() {  //final 사용
    	System.out.println("ahaha");
	}
}

public class Dog extends Pet {
	//final로 선언된 메서드는 Override 할 수 없다.
    public void makeSound() { }
}

3. final 클래스

클래스에 final을 선언하면 상속 자체가 안된다. 그냥 클래스 그대로만 사용해야 한다. Util 형식의 클래스나 여러 상수 값을 모아둔 Constants 클래스를 final로 선언한다.

public final class Constants {
	public static final SIZE = 0;
}

public class SubConstants extends Constants {
	// 상수 값을 모아놓은 클래스를 굳이 상속해서 쓸 이유는 없다
}

Object 클래스

자바에서는 상속이란 필수적이다. 우리가 상속을 하건 하지 않았건 기본적으로 상속을 하게된다. 무슨말일까 ?

class Obj { }
// 위 코드는 아래 코드와 동일하다.
class Obj extends Object { }

자바에서 모든 클래스는 사실 Object를 암시적으로 상속받고 있는 것이다. 그런 점에서 Object는 모든 클래스의 조상이라고 할 수 있다. 그 이유는 모든 클래스가 공통으로 포함하고 있어야 하는 기능을 제공하기 위해서다 API 문서에 메서드의 목록을 살펴보자.

위 그림은 Object 클래스가 가지고 있는 메서드를 보여준다. 다시 말해서 자바의 객체는 위의 메서드들을 반드시 가지고 있다고 할 수 있다. 이 중에서 몇가지 중요한 API 들을 살펴보자.

toString()

class Calculator {
	int right;
    int left;
    
    public void setOprands(int left, int right) {
    	this.left = left;
        this.right = right;
	}
    
	public void sum() {
		System.out.println(this.left + this.right;
	}

public class CalculatorDemo {
	public static void main(String[]args) {
				
		Calculator c1 = new Calculator();
		c1.setOprands(10, 20);
		System.out.println(c1);
	}
}

Output
Calculator@6d06d69c
(@ 뒤에 내용은 각자 다를 것이다.)

실행결과는 c1이 클래스 Calculator의 인스턴스라는 의미다. @ 뒤에 내용은 인스턴스에 대한 고유한 식별값 정도로 생각하자. 하지만 이 실행결과는 우리가 원하던 결과가 아닐것이다. 그럼 toString을 사용해 유용한 결과를 만들어보자.

class Calculator {
	int right;
	int left;

	public void setOprands (int left, int right) {
		this.left = left;
		this.right = right;
	}

	public void sum() {
		System.out.println(this.left + this.right;
	}

	public String toString() {
		return "left : " + this.left + ", right : "+ this.right;
	}


public class CalculatorDemo {
	public static void main(String[]args) {
				
	Calculator c1 = new Calculator();
	c1.setOprands(10, 20);
    
	System.out.println(c1);
	System.out.println(c1.toString());
    
	}
}	

Output
left : 10, right : 20
left : 10, right : 20

클래스 Calculator에 toString()을 재정의(overriding)했다. 그리고 System.out.println의 인자로 전달하니까 toString()을 명시적으로 호출하지 않았음에도 동일한 효과가 나고 있다. toString() 메서드는 자바에서 특별히 취급하는 메서드다. toString()을 직접 호출하지 않아도 어떤 객체를 System.out.println로 호출하면 자동으로toString()이 호출되도록 약속되어 있다. 이를 통해 인스턴스 c1의 상태를 쉽게 파악할 수 있게 되었다.

equals()

equals는 객체와 객체가 같은 것인지 비교하는 API이다. 객체 간의 같고 다름은 필요에 따라 달라질 수 있기 때문이다.

class Student {
	String name;

	Student(String name) {
		this.name = name;
	}

	public boolean equals(Object obj) {
		Student _obj = (Student)obj;
		return name == _obj.name;
	}
}

class ObjectDemo {
	public static void main(String[]args) {
		Student s1 = new Student("pie");
		Student s2 = new Student("pie");

		1.	System.out.println(s1==s2);
		2.	System.out.println(s1.equals(s2));
	}
}

Output
false
true

여기서 주목해야 할 점은 1.System.out.println(s1==s2)이다. 결과는 false. 그 이유는 s1과 s2가 서로 다른 객체이기 때문이다. 하지만 두 객체는 논리적으로는 pie 라는 값을 가지고 있기 때문에 객체를 만든 개발자는 저 두개의 객체가 같은 객체로 간주 되었음 좋겠다. 이럴 때 클래스 Object의 메서드 equals()를 overriding 하면 되지만, equals를 제대로 사용하기 위해선 hashCode라는 클래스도 함께 구현해야 하는데 너무 복잡하고 무거운 내용이니 다음 내용만 잘 기억하자.
1. 논리적(저장하고 있는 데이터)으로 동등한지 확인하고 싶으면 equals()를 사용하자.
2. 물리적(같은 객체를 참조하고 있는지)으로 동등한지 확인하고 싶으면 ==를 사용하자.

Object 메서드

메서드	설 명
protected Object clone()	해당 객체의 복제본을 생성하여 반환함.
boolean equals(Object obj)	해당 객체와 전달받은 객체가 같은지 여부를 반환함.
protected void finalize()	해당 객체를 더는 아무도 참조하지 않아 가비지 컬렉터가 객체의 리소스를 정리하기 위해 호출함.
Class getClass()	해당 객체의 클래스 타입을 반환함.
int hashCode()	해당 객체의 해시 코드값을 반환함.
void notify()	해당 객체의 대기(wait)하고 있는 하나의 스레드를 다시 실행할 때 호출함.
void notifyAll()	해당 객체의 대기(wait)하고 있는 모든 스레드를 다시 실행할 때 호출함.
String toString()	해당 객체의 정보를 문자열로 반환함.
void wait()	해당 객체의 다른 스레드가 notify()나 notifyAll() 메소드를 실행할 때까지 현재 스레드를 일시적으로 대기(wait)시킬 때 호출함.
void wait(long timeout)	해당 객체의 다른 스레드가 notify()나 notifyAll() 메소드를 실행하거나 전달받은 시간이 지날 때까지 현재 스레드를 일시적으로 대기(wait)시킬 때 호출함.
void wait(long timeout, int nanos)	해당 객체의 다른 스레드가 notify()나 notifyAll() 메소드를 실행하거나 전달받은 시간이 지나거나 다른 스레드가 현재 스레드를 인터럽트(interrupt) 할 때까지 현재 스레드를 일시적으로 대기(wait)시킬 때 호출함.

끝!

이번주도 열심히 한 나,, 결과는 체력 고갈,,,

[출처]
https://hyoje420.tistory.com/14
https://velog.io/@sewonkim/Java-자바의-상속-다이나믹-메소드-디스패치-Dynamic-Method-Dispatch
http://www.tcpschool.com/java/java_api_object
https://opentutorials.org/module/516/6241
https://kephilab.tistory.com/92