java 다형성

package Pack01;
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.SynchronousQueue;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
//자바책을 독파하고 무엇을 해봐야될지 모르겠다
//웹도 괜찮지만 자바를 직접 써보려면 안드로이드도 괜찮다.
//디자인 패턴책
//다형성
//알고 쓰는것이 중요하다
class Apple{
    void func01(){
 
    }
    void func03(){
 
    }
}
class Orange extends Apple{
    void func02(){
 
    }
    void func03(){
 
    }
}
public class Hello {
    public static void main(String[] args) {
        //상속했다는 전제 하에
        //왼쪽 부모 = 오른쪽 자식의 문법  - 대입연산자
        //무조건 업캐스팅이다
        //ex) 
        Apple a1 = new Orange();//쌍방간의 타입이 다를때 부 자 관계이면 업캐스팅이다.
        //new 메모리가 자식 메모리까지 포함되었다.
        //부A = A부            
        //업캐스팅//부A = B부자         메모리는 다있지만 쓸 수 있는것은 부모꺼만
        //java에서는 지원하지 않는 다운캐스팅 문법//부자B = A부        메모리는 부보만있지만 다 쓸 수 있다.
        //부자B = B부자         메모리도 부자가 주어지고 쓸 수 있는것도 부자
 
        a1.func01();
        //a1.func02();    안된다. 부모문법만 사용가능하다.
        //함수2번의 메모리는 존재하나 사용할 수는 없다.
        a1.func03();
        //Apple에서 3번을 찾고 3번실행하기 직전에 자식에 3번이 있는지 검색해본다.
        //함수가 오버라이딩 되어 있는지 확인해본다.
        
        //오버로딩    한 클래스 내에서 같은 함수명이 있을시 , type이 다르거나 받는 변수의 갯수가 다르면 같은 함수명을 쓸 수 있다.
        //오버라이딩    부모와 자식 중에 같은 함수가 있을시 , 
        
        Orange o1 = new Orange();
        o1.func01();
        o1.func02();
        o1.func03();
        
        
        
        
        
        
        
    }
}

package Pack01;
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.SynchronousQueue;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
//오버라이딩 상속시에 부모클래스와 자식 클래스에 같은 함수가 있을때 자식의 함수를 먼저 쓴다.
 
class Animal{
    void cry() {
 
    }
}
class Dog extends Animal{
    void cry() {
        System.out.println("멍멍");
    }
}
class Cat extends Animal{
    void cry() {
        System.out.println("야옹");
    }
}
class Tiger extends Animal{
    void cry() {
        System.out.println("어흥");
    }
}
class Lion extends Animal{
    void cry() {
        System.out.println("사자!");
    }
}
class Zoo{
    //동물이 늘어날때마다 오버로딩이 계속일어나야한다.는 단점
    void sound(Dog dog) {
        dog.cry();
    }
    void sound(Cat cat) {
        cat.cry();
    }
    void sound(Tiger tiger) {
        tiger.cry();
    }
    void sound(Lion lion) {
        lion.cry();
    }
}
class Zookeeper{//업캐스팅   ,위의 방식보다 이 방식을 쓴다.
    void sound(Animal animal) {
        animal.cry();//animal의 cry를 울린다. main에서 자식 객체를 인수로 던지면 자식객체의 cry를 울린다.  
    }
}
public class Hello {
    public static void main(String[] args) {
        Cat c2 = new Cat();
        c2.cry();
        Zoo z1 = new Zoo();
        z1.sound(new Dog());//sound 객채에 new dog를 넣는다.
        z1.sound(new Cat());
        z1.sound(new Tiger());
        z1.sound(new Lion());
        System.out.println();
        System.out.println();
        Zookeeper z2 = new Zookeeper();
        z2.sound(new Dog());
        z2.sound(new Cat());
        z2.sound(new Tiger());
        z2.sound(new Lion());
        //프로그램이 실행이 되기전까지는 
        //뭐가 나올지 모르는 것을 다형성이라고한다.
        //객체지향의 마지막은 다형성이다!
        System.out.println();
        System.out.println("다른예제이다");
        System.out.println();
        Dog d1 = new Dog();
        Cat c1 = new Cat();
        Tiger t1 = new Tiger();
        Lion l1 = new Lion();
        int n=2; 
        switch (n) {
        case 0:
            d1.cry();
            break;
        case 1:
            c1.cry();
            break;
        case 2:
            t1.cry();
            break;
        case 3:
            l1.cry();
            break;
        }
        
        /*Animal animal0 = new Animal();
        Animal animal1 = new Animal();
        Animal animal2 = new Animal();
        Animal animal3 = new Animal();*/
        
        Animal []animal = new Animal[4];
        //int []ar = new int[10];
        animal[0]= new Dog();
        animal[1]= new Cat();
        animal[2]= new Tiger();
        animal[3]= new Lion();
        
        animal[n].cry();//위의 switch문장이 한문장으로 정리가 된다.
        //다형성과 업캐스팅
    }
}

package Pack01;
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.SynchronousQueue;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
class Fruit{//부모
    void showcolor() {//업캐스팅
        //비어있는게 유일한 단점
    }
}
class Apple extends Fruit{
    void showcolor() {//함수명은 소글자
        System.out.println("나는 빨강색");
    }
}
class Orange extends Fruit{
    void showcolor() {//함수명은 소글자
        System.out.println("나는 주황색");
    }
}
class Kiwi extends Fruit{
    void showcolor() {//함수명은 소글자
        System.out.println("나는 초록색");
    }
}
 
public class Hello {
    public static void main(String[] args) {
        LinkedList<Fruit> ll = new LinkedList<>();
        //LinkedList<Apple> ll = new LinkedList<>();
        ll.add(new Apple());//아주머니는 객체 애플하나 가지고있다.
        ll.get(0).showcolor();
        ll.add(new Orange());//Apple일떄는 안된다. 컨테이너의 특성상 자기자신의 type만 넣을 수 있다.
        ll.add(new Kiwi());
        //업캐스팅 이용
        for (int i = 0; i < ll.size(); i++) {
            ll.get(i).showcolor();
        }
        
    }
}

package Pack01;
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.SynchronousQueue;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
class A0{
    void f1() {
        
    }
    void f2() {
        
    }
}
 
//부모  자식 관계 만들어주기
//생성자 변수 초기화 
//서브클래스가 슈퍼클래스의 타입으로 형 변환되는 것
 
class A1 extends A0{
    void f1() {
        System.out.println("A1 콜됨");
    }
    void f2() {
        System.out.println("호랑이");
    }
}
 
class A2 extends A0{
    void f1() {
        System.out.println("A2 콜됨");
    }
    void f2() {
        System.out.println("코끼리");
    }
}
 
class A3 extends A0{
    void f1() {
        System.out.println("A3 콜됨");
    }
    void f2() {
        System.out.println("독수리");
    }
}
 
class B{
    A0 name;
    //1
    /*B(A0 a){//업캐스팅으로  A0만 있어도 각각의 자식들의 f1을 콜할수 있다. 뭐가 나올지 모르고 밑에서 쓰는대로 나온다.
    a.f1();
    }*/
    
    //2
    /*B(A0 a){//업캐스팅으로  A0만 있어도 각각의 자식들의 f1을 콜할수 있다. 뭐가 나올지 모르고 밑에서 쓰는대로 나온다.
        //a.f1();
        name = a;//생성자에서 받은 객체를 참조시킴
    }*/
    
    //3
    B(A0 name){//업캐스팅으로  A0만 있어도 각각의 자식들의 f1을 콜할수 있다. 뭐가 나올지 모르고 밑에서 쓰는대로 나온다.
        //a.f1();
        this.name = name;//생성자에서 받은 객체를 참조시킴
        
    }
    void yourname() {//부모타입 인수 만들어주고
        name.f2();//각 오버라이딩 된 함수를 넣어줘서 메인에서 원하는대로 콜
    }
    
}
 
public class Hello {
    public static void main(String[] args) {
        B b = new B(new A1());
        B b2 = new B(new A2());//생성자는 오버로딩이 된다. B에 생성자에 인수로 받을 수 있는 값이 있어야된다.
        B b3 = new B(new A3());
        
        //b.yourname(new A1());//뒤에 넣는 인수에 다르게 값이 다르게 나온다.
        b.yourname();//name =a; 를 함으로써 넣지 않아도 값이 바로 나온다. 
        b2.yourname();
        b3.yourname();
        //다형성 활용
        
        
    }
}