day30

📖상속- 강제형변환

public class Inheritance008 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
        PP t1 = new PP(); //자기자신
        t1.m1();
        t1.m2();
        //t1.m3(); //m3은 CC꺼! X
        
        CC t2 = new CC(); //자기자신
        t2.m1();
        t2.m2();
        t2.m3(); //m3은 CC꺼! O
       
        PP t3 = new CC(); //PP:m1,m2 = CC: (PP)m1,m2 (CC)m2,m3 -> CC객체생성해서 PP에 담는다
        t3.m1();
        t3.m2(); //CC의 m2를 가지고 온다
        //t3.m3(); //PP가 가지고 있는 메소드만 사용가능!
        
        //CC t4 = t3; //PP에 담겨져있는 CC객체 t3를 자식 CC에 담지 못한다!
        
        PP t4 = t3; //PP에 담겨져있는 CC객체 t3를 부모 PP에 담을 수 있지
        t4.m1();
        t4.m2(); //CC의 m2를 가져온다
        //t4.m3(); //PP가 가지고 있는 메소드만 사용 가능!        
        
        PP t5 = t2; //CC에 담겨져 있는 CC객체 t2를 PP에 담을 수 있다
        t5.m1();
        t5.m2(); //CC의 m2를 가져온다
        //t5.m3(); //PP가 가지고 있는 메소드만 사용 가능!
        
        CC t6 = (CC)t3; //PP에 담겨져있는 CC객체 t3를 CC에 담을 수 없지 부모->자식 X
        //근데!!! 이때 몸통만 같다면 강제형변환을 해서 넣을 수 있다!!!
        //CC에 담겨져 있는 CC객체 t3
        // -> CC : (PP)m1,m2 , (CC)m2,m3 = CC : (PP)m1,m2 , (CC)m2,m3
        t6.m1();
        t6.m2(); //CC의 m2를 가져온다
        t6.m3(); //CC의 m3 사용 가능!
        
       	//CC t7 = (CC)t1; //PP에 담겨져 있는 PP객체 t1을 CC에 담을 수 없어 부모->자식 X
        // 여기서 강제 형변환을 하면 되야하는데 안됨..
        // t1의 몸통은 PP이기 때문에 CC로 강제형변환을 하려면 몸통이 CC여야하는데 아니기 때문에!
        
}




class PP {	
	void m1() {}	
	void m2() {}
}

class CC extends PP {	
	void m2() {}		
	void m3() {}
}

class DD extends PP {
	void m4() {}
}

🖐PP t4 = t3;
-> PP에 담겨져있는 CC객체 t3는 PP에 들어가있으니까 PP에 담길 수 있다. (PP -> PP OOOO)

🖐CC t6 = (CC)t3;
-> PP에 담겨져있는 CC객체 t3는 CC에 담길 수 없다. (pp -> CC XXXX)
-> 그래서 강제 형변환을 해서 CC에 담길 수 있도록 한다.
-> 이때 CC에 담기게 하려면 몸통이 CC여야 한다!

=================================================

import java.util.ArrayList;

public class Inheritance008 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		CC w1 = new CC(1);
		DD w2 = new DD(2);
		//m1 m2
		//CC -> m3
		//DD -> m4
		
		ArrayList<PP> pList = new ArrayList<PP>();
		pList.add(w1);				//CC 1
		pList.add(w2);				//DD 2
		pList.add( new PP(3) );		//PP 3
		pList.add( new CC(4) );		//CC 4
		pList.add( new DD(5) );		//DD 5
		
		for (PP p : pList) {
			System.out.println(p.id);
			p.m1();
			p.m2();
			
			//이때는 불가능!
//			( (CC)p ).m3(); //강제형변환 해서 CC에 있는 m3 사용 O 
//			( (DD)p ).m4(); //강제형변환 해서 DD에 있는 m4 사용 X -> 위에 코드로 몸통이 CC인 상태
			
			//instanceof 로 각각 따로봐서 이땐 가능!
			if ( p instanceof CC) { //if절 각각따로본다! -> CC출신이냐?
				( (CC)p ).m3();
			}
			
			if ( p instanceof DD) { //if절 각각따로본다! -> DD출신이냐?
				( (DD)p ).m4();
			}
//			p.m3(); // CC DD가 몸통이지만 PP에 있는거만 사용가능 

		}
	}

}

class PP {
	//필드
	int id;
	
	//생성자
	public PP(int id) {
		this.id = id;
	}
	
	//메소드
	void m1() {
		System.out.println(id + " m1");
	}	
	void m2() {
		System.out.println(id + " m2");
	}
}

class CC extends PP {
	//생성자
	public CC(int id) {
		super(id);
	}
	void m2() {
		System.out.println(id + " new m2");
	}		
	void m3() {
		System.out.println(id + " m3");
	}
}

class DD extends PP {
	//생성자
	public DD(int id) {
		super(id);
	}
	void m4() {
		System.out.println(id + " m4");
	}
}

💻

1. w1 생성 (id : 1)
   w2 생성 (id : 2)

2. pList 생성
   w1 (CC 1)
   w2 (DD 2)
   PP 3
   CC 4
   DD 5

3. for문으로 pList에 있는 것들 차례대로 다 돌림
   w1 (CC 1) -> 1 / 1 m1 / 1 new m2 / 1 m3
   w2 (DD 2) -> 2 / 2 m1 / 2 m2 / 2 m4
   PP 3 -> 3 / 3 m1 / 3 m2
   CC 4 -> 4 / 4 m1 / 4 new m2 / 4 m3
   DD 5 -> 5 / 5 m1 / 5 m2 / 5 m4