상속

: 부모 class가 가지는 내용을 확장해서 자식 class를 만드는 방식

ex) 학사 시스템
Class - Teacher, Student, Staff => 공통으로 가지고 있는 field, method가 존재한다.
코드에 중복이 발생한다. 여기에서 공통으로 추가해야 하는 것이 생기면 각자 추가해야 한다.

class Student {
	
	String name;  // 이름
	String mobile;  // 전화번호
	String dept;  // 학과
	
}

class Teacher {
	
	String name;  // 이름
	String mobile;  // 전화번호
	String subject;  // 과목
}

class Staff {
	
	String name;  // 이름
	String mobile;  // 전화번호
	int salary;  // 월급
	
}

상속으로 해결한다.

class Person {
	String name;  // 이름
	String mobile;  // 전화번호
}

// tightly coupled
class Student extends Person{
	String dept;  // 학과
	
}

class Teacher extends Person{	
	String subject;  // 과목
}

class Staff extends Person{	
	int salary;  // 월급	
}

Java 상속의 특징

• extends keyword로 상속을 구현한다.

• Java는 단일 상속만 지원한다. 다중 상속은 지원하지 않는다.
  : extends 뒤에 여러 class가 올 수 없다.

    class Human {
		String name;
    }

    class Person {
        String name;  // 이름
        String mobile;  // 전화번호
    }

    class Student extends Person, Human{  // 오류 발생
        String dept;  // 학과

    }

• class가 "tightly coupled" -> 재사용에 문제가 발생한다.

상속이 되지 않는 것

: constructor는 상속되지 않는다.
: private access modifier로 지정된 field, method도 상속되지 않는다.

상속에서 Instance 생성

instance는 무조건 Heap에 생성된다.

class Person {
	String name;  // 이름
	String mobile;  // 전화번호
}

class Student extends Person {
	String dept;
}

public class Main {
	public static void main(String[] args) {
		Student s = new Student();
        
        // is-a relationship
		// subclass is a superclass
        
        // Person s = new Student();
		// subclass 타입을 써야 할 곳에 superclass 타입을 쓸 수 있다.
        // 이때는 s가 Student를 가리키지 않고, 안의 Person을 가리킨다.
        
        // Object s = new Student();
        // 이때는 Person 안의 Object를 가리킨다.
        
        // => Polymorphism(다형성)
	}
}

위와 같은 코드를 보면 Person을 상속 받아서 name, mobile, dept가 Student 객체에 담겨서 생길 것처럼 보이지만 아니다.

=> 실제 상속에서 Instance 생성 방법
: 상위 객체를 먼저 만들고, 그를 감싸는 하위 객체를 만들어가는 방식으로 만든다.

1. class가 상속을 받는지 확인하고, 더이상 상속을 받는 class가 없을 때 까지(Object를 상속받는 class가 나올 때 까지) 상위 class로 올라간다.
2. 최상위 클래스의 constructor를 호출한다. -> Object constructor가 만들어진다.
3. Object 밑의 Person 객체를 만든다.
   : name, mobile 공간이 만들어진다.
4. Person 밑의 Student 객체를 만든다.
   : dept 공간이 만들어진다.
5. Stack의 s 변수가 해당 instance를 포인팅 하게 된다.

Java의 모든 class는 무조건 Object class를 상속하고 있다.
Java의 모든 class는 특정 package 안에 포함되어 있다.
-> Object class는 Java.lang.Object

method overriding (메소드 재정의)

: 하위 클래스에서 상위 클래스에 있는 것을 재정의 한다.

class Person {
	String name;  // 이름
	String mobile;  // 전화번호
	
	public void printAll() {
		System.out.println("모두 출력!");
	}
}

class Student extends Person {
	String name;  // 일반적이지 않다.
	String dept;
	
	public void printAll() {
		System.out.println("오버라이딩!");
	}
}

public class Main {
	public static void main(String[] args) {
		Student s = new Student();
	}
}

this

: 현재 사용하는 객체의 reference

this()

: 자신의 class가 가진 다른 생성자를 호출한다.

class Person {
	String name;  // 이름
	String mobile;  // 전화번호
	
	public void printAll() {
		System.out.println("모두 출력!");
	}
}

class Student extends Person {
	String name; // 일반적이지 않다.
	String dept;
	
	// default constructor
	public Student() {
		this("홍길동");
	}
	
	public Student(String name) {
		this.name = name;		
	}
	
	public void printAll() {
		System.out.println("오버라이딩!");
	}
}

public class Main {
	public static void main(String[] args) {
		Student s = new Student();
	}
}

super

: 현재 사용하는 객체의 reference인데 type이 상위 type인 것

super()

: 상위 class의 생성자를 호출한다.

상속 문제

• 다음 코드의 실행 결과는?

package lecture0712;

class SuperClass {
	
	// static method
	static int staticCall(String msg) {
		System.out.println(msg);
		return 100;
	}
	
	// fields
	int a = staticCall("1번입니다.");
	static int b = staticCall("2번입니다.");
	
	// constructor
	public SuperClass() {
		staticCall("3번입니다.");
	}
	
	public SuperClass(int i) {
		this();
		staticCall("4번입니다.");
	}
	
	// method
	public void myFunc() {
		System.out.println("5번입니다.");
	}
}

public class InheritanceTest extends SuperClass {
	
	// fields
	int c = staticCall("6번입니다.");
	static int d = staticCall("7번입니다.");
	
	// constructor
	public InheritanceTest() {
		super(100);
		staticCall("8번입니다.");
		super.myFunc();
	}
	
	@Override
	public void myFunc() {
		System.out.println("9번입니다.");
	}
	
	public static void main(String[] args) {
		System.out.println("10번입니다.");
		SuperClass obj = new InheritanceTest();
		obj.myFunc();  // => 동적 바인딩(dynamic binding)
	}
}

내 풀이 : 2-7-10-1-6-3-4-8-5-9
정답 : 2-7-10-1-3-4-6-8-5-9

1. Method Area에 SuperClass의 정보가 올라간다. static인 b의 공간이 생긴다.
   => 2번 출력
2. Method Area에 InheritanceTest의 정보가 올라간다. static인 d의 공간이 생긴다.
   => 7번 출력
3. main method 시작
   => 10번 출력
4. new로 instance를 만든다. InheritnaceTest()를 호출한다.
5. 상위 class의 생성자를 호출하려면 field가 초기화가 먼저 되어야 한다.
   => 1번 출력
6. super(100)이 호출된다. this()로 SuperClass()가 호출된다.
   => 3번 출력
   => 4번 출력
7. InheritanceClass의 field가 초기화된다.
   => 6번 출력
8. InheritanceTest()의 다음줄 실행
   => 8번 출력
9. super.myFunc() 실행
   => 5번 출력
10. obj.myFunc() 실행
    => 9번 출력

is-a relationship
: class로부터 파생된 instance의 data type을 상위 type으로 변환한다.
=> 다형성(Polymorphism)

동적 바인딩(dynamic binding)
: 객체에 대한 type이 상위 type이라 할지라도 만약 overriding된 method가 하위에 존재한다면 method는 overriding 된 method를 사용한다.