day29

📖상속

🚨상속관계에서 자식생성자에는 무조건 부모생성자 호출을 해줘야 한다!

🚨자식생성자를 타라고 했을때 부모생성자에 매개변수가 없을때 자식생성자 안에 super();가 생략 되어 있다!
매개변수없는 부모생성자 super();부터 타야한당

class SuperClass {
	public SuperClass() { // 부모 생성자
		System.out.println("부모 생성자 호출");
	}
}

class SubClass extends SuperClass{
	public SubClass() { // 자식 생성자
		System.out.println("자식 생성자 호출");
	}
}

public class InheritanceConstructorEx01 {
	public static void main(String[] args) {
		SubClass sc = new SubClass(); // 자식 인스턴스 생성
	}
}

💻
부모 생성자 호출
자식 생성자 호출

=>

class SubClass extends SuperClass{
	public SubClass() { // 자식 생성자
		System.out.println("자식 생성자 호출");
	}
}

=> 자식 생성자 안에 super();가 생략 되어있는 상태! 그래서 부모 생성자 부터 탄다!

🚨자식 클래스로 인스턴스를 생성할 때 자동적으로 부모 클래스의 기본 생성자가 호출된다.
다르게 말하면 매개변수를 갖는 부모 클래스의 생성자는 자동으로 호출되지 않는다.
이때는 자식생성자에 super(); 라고 호출하면 에러뜬다 부모생성자에 매개변수가 있기 때문에!
따라서 이때는 생략하지말고 super(매개변수); 라고 호출을 꼭 해줘야 한다

class SuperClass {
	public SuperClass(String str){
		System.out.println(str + "호출");
	}
}

class SubClass extends SuperClass{
	public SubClass() { // 자식 생성자
		System.out.println("자식 생성자 호출");
	}
}

public class InheritanceConstructorEx01 {
	public static void main(String[] args) {
		SubClass sc = new SubClass(); // 자식 인스턴스 생성
	}
}

=> 이때는 에러가 뜬다! 자식생성자에 super();가 생략이 되어있는건데.. 부모클래스에 매개변수가 없는 생성자가 없기 때문에

class SubClass extends SuperClass{
	public SubClass() { // 자식 생성자
		super("부모 생성자 "); // 부모 생성자 호출
		System.out.println("자식 생성자 호출");
	}
}

=> 이런식으로 super("부모 생성자 "); // 부모 생성자 호출 을 해줘야 에러도 안뜨고 부모생성자에 매개변수가 있을때는 자식 생성자에서 명시적으로 부모 생성자를 호출해야 한다

📖상속 - 타입 변환, 다형성

public class Inheritance004 {
	
	public static void main(String[] args) {
		
		Parent p1 = new Parent(); //부모생성
		
		Child c1 = new Child(); //자식생성
		
		Parent p2 = new Child(); //자식객체를 만들어서 Parent에 담겠다 OOO
		//부모타입		자식객체
		Parent p3 = c1; //자식객체를 Parent에 담겠다 OOO
		//부모타입    자식객체
		
//		Child c2 = new Parent(); //부모객체를 만들어서 Child에 담겠다 XXX
		
		GrandParent gp1 = new GrandParent();
		GrandParent gp2 = new Parent(); //부모객체를 만들어서 GrandParent에 담겠다 OOO
		GrandParent gp3 = new Child(); //자식객체를 만들어서 GrandParent에 담겠다 OOO
	
	}
}

class GrandParent {
	
}

class Parent extends GrandParent {
	
}

class Child extends Parent {
	
}

🖐
Parent p2 = new Child(); 나눠서 보자!
Child객체를 생성해서 Parent에 담겠다는 뜻! OOO

🖐
Child c2 = new Parent();
부모객체를 생성해서 자식에 담겠다는건데.. 말이 안되잖아!?

🖐
GrandParent gp2 = new Parent();
GrandParent gp3 = new Child();
부모,자식객체를 생성해서 할아버지에 담겠다 OOO

public class Inheritance005 {
	
	public static void main(String[] args) {
		
		Parent2 p1 = new Parent2();
		p1.method1();
		p1.method2(); //메인이 있는쪽은 다른클래스니까 Parent2 클래스의 private 못써
//		p1.method3(); // X Parent에는 method3이 없다 / 자식꺼를 가지고 부모에서 못써!
		
		Child2 c1 = new Child2(); 
		c1.method1(); // 부모꺼를 가지고 자식에서 쓸 수 있어
		c1.method2(); // 부모꺼를 가지고 자식에서 쓸 수 있어
		c1.method3();
		
		Parent2 p2 = new Child2(); //자식객체를 생성시켜서 부모에 담겠다 // method1,2 / method부모1,2 method자식2,3
		p2.method1();
		p2.method2(); //최신 222(자식메소드) /자동으로 재정의된 자식method2로 연결!   
//		p2.method3(); // 부모에 담겨져 있는 객체!!! 부모메소드에 있는 것만 사용가능 // method3의 기능은 있는데 겉으로 버튼구현이 안되있어서 못쓰는거지..!
		
        Parent2 p3 = new Child3(); //method1,2 = 부모method1,2 자식method2
		p3.method1(); 
		p3.method2(); //나도 나만의 222(자식메소드) /제일 최신꺼 자식 method2로 연결
		
	}
}

class Parent2 {
	void method1() {
		System.out.println("111");
	}
	
	void method2() {
		System.out.println("222");
	}
}

class Child2 extends Parent2 { //첫번째 자식
	void method2() { //메소드 오버라이딩
//		super.method2();
		System.out.println("최신 222");
	}
	
	void method3() {
		System.out.println("333");
	}
}

class Child3 extends Parent2 { //두번째 자식
	void method2() {
		System.out.println("나도 나만의 222");
	}
}

🖐
Parent2 p2 = new Child2();
자식객체를 생성시켜서 부모에 담겠다 OOO
나눠서 생각해보면
부모 method 1,2 = 자식 method 2,3
그래서 method3은 기능은 있지만 현재 부모에 몸담궈져있는애라 버튼은 구현이 안되있어서 쓰질 못하는거고
method2는 쓸 수 있지만 제일 최신꺼 오버라이딩 된거가 나온다!

//								Vehicle vh = bike, boat 가능!
	public static void runParameter(Vehicle vh) { //static은 static만 쓸 수..
		vh.run(); //매개변수로 들어온 객체의 run 메소드를 호출
 	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Vehicle v1 = new Vehicle();
		Vehicle v12 = new Vehicle();
		Vehicle v13 = new Vehicle();
		ArrayList<Vehicle> vehicleList = new ArrayList<Vehicle>();
		vehicleList.add(v1);
		vehicleList.add(v12);
		vehicleList.add(v13);
		
		
		Bike v2 = new Bike();
		Bike v22 = new Bike();
		Bike v23 = new Bike();
		
		Boat v3 = new Boat();
		Boat v32 = new Boat();
		
		//자식객체를 부모 vehicleList에 담을 수 있다
		vehicleList.add(v2); // == vehicleList.add( new Bike() );
		vehicleList.add(v22);
		vehicleList.add(v23);
		
		vehicleList.add(v3); // == vehicleList.add( new Boat() );
		vehicleList.add(v32);
		
		for (Vehicle vh : vehicleList) {
			vh.run();
		}
		
		System.out.println("------------------------");
		runParameter(v23); //매개변수가 Vehicle이라 bike도 되고! new Bike()라서 Bike의 run()
		runParameter(v32); //매개변수가 Vehicle이라 boat도 된다! new Boat()라서 Boat의 run()
		
	}

}

class Vehicle { //탈 것!
	
	void run() {
		System.out.println("탈 것이 달린다.");
	}	
}

class Bike extends Vehicle{ //자전거
	 
	void run() { //메소드 오버라이딩 (상속일경우)
		System.out.println("페달을 굴려서 달린다.");
	}
}

class Boat extends Vehicle { //보트
	
	void run() { //메소드 오버라이딩 (상속일경우)
		System.out.println("프로펠러를 돌려서 달린다.");
	}
}

=>

//자식객체를 부모 vehicleList에 담을 수 있다
	vehicleList.add(v2); // == vehicleList.add( new Bike() );
	vehicleList.add(v22);
	vehicleList.add(v23);
		
	vehicleList.add(v3); // == vehicleList.add( new Boat() );
	vehicleList.add(v32);
		
	for (Vehicle vh : vehicleList) {
		vh.run();
	}

🖐여기서
Vehicle v1 = new Bike(); //바이크를 생성해서 vehicle에 넣어준다
Vehicle v2 = new Boat(); //보트를 생성해서 vehicle에 넣어준다
가 가능하니까!
vehicleList에도 Bike객체와 Boat객체를 담아줄 수 있는거지

=>

public static void runParameter(Vehicle vh) { //static은 static만 쓸 수..
		vh.run(); //매개변수로 들어온 객체의 run 메소드를 호출
}

=>

runParameter(v23); //매개변수가 Vehicle이라 bike도 되고! new Bike()라서 Bike의 run()
runParameter(v32); //매개변수가 Vehicle이라 boat도 된다! new Boat()라서 Boat의 run()

🖐
메인클래스에 메소드 만들어주고
어쨌든 Vehicle에는 Bike, Boat 다 들어갈 수 있기 때문에 메소드 매개변수에 Bike, Boat 다 쓸 수 있다~!

🚨결론🚨
<main클래스>
A b = new B(); -> B 객체 생성시키고 A에 넣는다 // A paint(), draw() = A paint(), draw() , B paint(), draw()
b.paint();
b.draw();

<A 클래스>
메소드
paint();
draw();

<B 클래스>
메소드
paint();
draw();

가 있다면!

1. b.paint(); => A에 있는 메소드만 쓸 수 있는데 B에도 똑같은 메소드가 있다면(오버라이딩된 메소드) 그걸 쓴다! 가장 최신꺼를 쓴다~! B클래스에 있는 paint()부터 간다~
상속관계에서 오버라이딩 : 아빠꺼 안해! 내꺼할거야

2. b.draw(); => 위와 똑같은 논리! B클래스에 있는 draw()로 간다~!