Java_51_인터페이스_다형성_다형성 멤버 필드 법칙, 업 캐스팅, 다운 캐스팅, 다형성 멤버 메소드 법칙

- 다형성
    - 객체의 연산자
         - Java에서 객체의 연산은 대입연산자 뿐
         - 대입 연산자
               - 같은 클래스
               - 상속 관계(클래스)
    - 한 타입의 참조 변수로 여러 타입의 객체를 참조할 수 있도록 하는 것
    - 기본 사용 형식
        A ap = new A();
        A bp = new B();
    - 다형성에서의 형식
        - 상위 클래스 = 하위 클래스
            A ap = new B();
        - 하위 클래스는 상위 클래스로 객체를 생성할 수 없습니다.
            B bp = new A();
            runtime error : 논리는 맞으나 상황에 맞지 않아 오류가 발생합니다.
    - 다형성으로 받아들였을 때 달라지는 것
        class A{ 
            x=5;
            a();
            b();
        }

        class B{
            x=10;
            a();
            c();
        }

        - 멤버 호출 시 상위 클래스의 x를 호출합니다.
        - 메소드 호출 시 하위 클래스의 a()를 호출합니다.
            A ap = new B()
                - B 클래스의 오버라이딩 된 a()를 호출합니다.
                - A 클래스의 b()를 사용할 수 있습니다.
                - B 클래스의 c()를 사용할 수 없습니다.
                - ap의 자료형은 A 입니다.
=====

class Point2d {
    int x;
    int y;
    public Point2d(){
        x = 100;
        y = 125;
    }
    public void disp() {
        System.out.printf("Location : [ %d , %d ]\n", x, y);
    }
}
 
class Point3d extends Point2d {
    // Point2d를 상속받은 Point3d
    int z;
    public Point3d() {
        z = 150;
    }
    public void disp() {
        System.out.printf("Location : [ %d, %d, %d ] \n", x, y, z);
    }
}
 
public class same {
    public static void main(String[] args) {
        Point2d ap = new Point2d();
        Point2d bp = ap;
        // 같은 클래스 이므로 대입연산이 가능
        // bp 는 ap의 주소값을 받은 것 = C_포인터
        ap.disp();    // Location : [ 100 , 125 ]
        bp.disp();    // Location : [ 100 , 125 ]
        ap.x = 1000;
        // ap의 x값 갱신
        ap.disp();    // Location : [ 1000 , 125 ]
        bp.disp();    // Location : [ 1000 , 125 ]
        // bp는 ap와 같은 클래스이므로 같이 변경된다.
    }
}

       - 다형성 멤버 필드 법칙
          - 업 캐스팅
                     - 자동 형 변환
                  - 하위 클래스의 생성자로 상위 클래스의 객체를 생성할 수 있음
                  - 상위 클래스는 하위 클래스의 변수에 접근할 수 없음
                  - 상위 클래스가 하위 클래스의 객체를 생성할 수 없음
=====

class Point2d {
    int x;
    int y;
 
    public Point2d() {
        x = 100;
        y = 125;
    }
 
    public void disp() {
        System.out.printf("Location : [ %d , %d ]\n", x, y);
    }
}
 
class Point3d extends Point2d {
    // Point2d를 상속받은 Point3d
    int z;
 
    public Point3d() {
        z = 150;
    }
 
    public void disp() {
        System.out.printf("Location : [ %d, %d, %d ] \n", x, y, z);
    }
}
 
public class same {
    public static void main(String[] args) {
        Point3d p3 = new Point3d();
        Point2d p2 = p3;
        // 하위 클래스의 생성자로 상위 클래스의 객체를 생성할 수 있음
        // 업 캐스팅 : 자동 형 변환
 
        p3.disp();    // Location : [ 100, 125, 150 ] 
        p2.disp();    // Location : [ 100, 125, 150 ] 
 
        System.out.println("p2.x = " + p2.x);    // 
        System.out.println("p2.y = " + p2.y);    // 
        // System.out.println("p2.z = " + p2.z);
        // p2는 상위 클래스이므로 p3에 접근할 수 없음
        System.out.println("p3.x = " + p3.x);    // 
        System.out.println("p3.y = " + p3.y);    // 
        System.out.println("p3.z = " + p3.z);    // 
    }
}

            - 다운 캐스팅
               - 업 캐스팅 된 상위클래스의 객체를 하위 클래스의 객체로 만들 수 있다.
=====

class Point2d {
    int x;
    int y;
    public Point2d() {
        x = 100;
        y = 125;
    }
    public void disp() {
        System.out.printf("Location : [ %d , %d ]\n", x, y);
    }
}
 
class Point3d extends Point2d {
    // Point2d를 상속받은 Point3d
    int z;
    public Point3d() {
        z = 150;
    }
    public void disp() {
        System.out.printf("Location : [ %d, %d, %d ] \n", x, y, z);
    }
}
public class same {
    public static void main(String[] args) {
        /*
        Point2d p2 = new Point2d();
        (1) 
        Point3d p3 = p2;
        // 오류 : Type mismatch: cannot convert from Point2d to Point3d.
               
        (2)
        Point3d p3 = (Point3d)p2;
        // 강제 형 변환  >> 오류 : Point2d cannot be cast to Point3d.
        // 변수 z값을 불러올 수 없으므로 오류가 나는 것
        */
 
        //(3)
        Point2d p2 = new Point3d();
        // 하위 클래스 객체를 상위 클래스로 생성
        Point3d p3 = (Point3d)p2;
 
        p3.disp();    // Location : [ 100, 125, 150 ] 
        p2.disp();     // Location : [ 100, 125, 150 ] 
    }
}

         - 다형성 멤버 메소드 법칙
            - 하위 클래스가 상위 클래스의 메소드를 오버라이드 시,
                업 캐스팅 상태의 상위 클래스의 객체에서 해당 메소드를 실행하는 경우
                하위 클래스의 메소드가 실행됨
=====

import java.util.Scanner;
 
class Animal{
    public void run() {
        System.out.println("run function");
    }
    public void move() {
        System.out.println("Move function");
    }
}
 
class Rabbit extends Animal{
    public void run() {
        System.out.println("Rabbit run");
    }
    public void move() {
        System.out.println("Rabbit Move");
    }
}
 
class Dog extends Animal{
    public void run() {
        System.out.println("Dog run");
    }
    public void move() {
        System.out.println("Dog Move");
    }
}
public class same {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        Animal ani;
        System.out.print("1.Rabbit 2.Dog : ");
        int select1 = in.nextInt();
        System.out.print("1.Run 2.Move : ");
        int select2 = in.nextInt();
        
        if (select1 == 1 ) {
            ani = new Rabbit();
        }else {
            ani = new Dog();
        }
        if (select2 == 1) {
            ani.run();
        }else {
            ani.move();
        }
    }
}