(Java) 자바의 정석 3판 012일차 - 다형성(클래스, 매개변수, 인터페이스), 참조타입의 형변환, 추상 클래스, 인터페이스, 단일 상속과 다중 상속

public class TV2 {
    boolean power;
    int channel;
    
    void power(){}
    void channelUp(){}
    void channelDown(){}
}

class CaptionTV extends TV2 {
    String text;
    void caption(){}
}

class Test4 {
    public static void main(String[] args) {
        TV2 t = new TV2();
        CaptionTV c = new CaptionTV();
        TV2 t2 = new CaptionTV();
        
        System.out.println(c.text);
        // System.out.println(t2.text); TV2에 생성된 것만 참조 가능.
        // CaptionTV c2 = new TV2(); CaptionTV보다 TV2가 가진 멤버가 더 적어서 생성 불가능.
    }
}

public class TV2 {
    boolean power;
    int channel;

    void power(){}
    void channelUp(){}
    void channelDown(){}
}

class CaptionTV extends TV2 {
    String text;
    void caption(){}
}

class Test4 {
    public static void main(String[] args) {
        TV2 t = new TV2();
        TV2 t2 = new CaptionTV();
        // t는 TV2 인스턴스여서 TV2의 멤버만 가지고 있으므로 CaptionTV 타입을 커버할 수가 없다.
        // 컴파일 시에는 올바른 형변환으로 보지만 런타임에서 체크 해보면 부모가 자식을 커버할 수 없는 원리와 같다.
        // CaptionTV c = (CaptionTV)t;
        // System.out.println(c.text);
        // t2는 CaptionTV 인스턴스를 강제로 TV2로 업캐스팅 해서 일단 CaptionTV 멤버를 들고는 있는데
        // 접근만 못할 뿐이라 CaptionTV 타입을 커버할 수 있다.
        CaptionTV c2 = (CaptionTV)t2;
        System.out.println(c2.text); // null
    }
}

public class TV2 {
    boolean power;
    int channel;

    void power(){}
    void channelUp(){}
    void channelDown(){}
}

class CaptionTV extends TV2 {
    String text;
    void caption(){}
}

class Test4 {
    public static void main(String[] args) {
        CaptionTV c2 = new CaptionTV();
        System.out.println(c2 instanceof CaptionTV); // true
        System.out.println(c2 instanceof TV2); // true
        System.out.println(c2 instanceof Object); // true
    }
}

class Parent {
    int x = 10;
    static int y = 20;
    void method() {
        System.out.println("asdf");
    }
    static void method2() {
        System.out.println("qwer");
    }
}

class Child extends Parent {
    int x = 20;
    static int y = 30;
    void method() {
        System.out.println("x="+x); // 20
        System.out.println("this.x="+this.x); // 20
        System.out.println("super.x="+super.x); // 10
    }
    static void method2() {
        System.out.println("zxcv");
    }
}

class Test {
    public static void main(String[] args) {
        Parent p = new Child(); // (Parent)new Child();
        // 인스턴스 변수인 x는 참조타입인 Parent를 따른다.
        System.out.println(p.x); // 10
        // static 변수인 y는 참조타입인 Parent를 따른다.
        System.out.println(p.y); // 10
        // static 메소드인 method2는 참조타입인 Parent를 따른다.
        p.method2();
        // 인스턴스 메소드인 method는 인스턴스 타입인 Child를 따른다.
        p.method();
        
        Child c = new Child();
        // 인스턴스 변수인 x는 참조타입인 Child를 따른다.
        System.out.println(c.x); // 20
        // static 변수인 y는 참조타입인 Child를 따른다.
        System.out.println(c.y); // 30
        // static 메소드인 method2는 참조타입인 Child를 따른다.
        c.method2(); // zxcv
        // 인스턴스 메소드인 method는 인스턴스 타입인 Child를 따른다.
        c.method(); 
    }
}

public class Product {
    int price;
    int bonusPoint;
}

class Computer extends Product {}
class Radio extends Product {}

class Buyer {
    int money = 1000;
    int bonusPoint = 0;
    void buy(Computer c) {
        money -= c.price;
        bonusPoint += c.bonusPoint;
    }
    void buy(Radio r) {
        money -= r.price;
        bonusPoint += r.bonusPoint;
    }
}

class Buyer {
    int money = 1000;
    int bonusPoint = 0;
    void buy(Product p) {
        money -= p.price;
        bonusPoint += p.bonusPoint;
    }
    void buy(Radio r) { // 따로 처리하고 싶은 녀석만 따로 빼면 된다.
        money -= r.price;
        bonusPoint += r.bonusPoint;
        System.out.println("asdf");
    }
}

class Test5 {
    public static void main(String[] args) {
        Buyer b = new Buyer();
        b.buy(new Radio()); // "asdf"까지 무사 출력된다.  
        System.out.println(b.money); // 900으로 까였다.
        b.buy(new Computer());
        System.out.println(b.money); // 800으로 까였다.
    }
}

class Test5 {
    public static void main(String[] args) {
        // Product의 instanceof에 걸리므로 이렇게도 할 수 있다.
        // 물론 배열 내부에 있는 애들은 부모 타입으로 업캐스팅 된다. (형변환 연산자는 생략된 것임)
        Product[] p = {new Computer(), new Radio(), new Radio()};
        // 배열은 길이가 고정적인데 반해 벡터는 10개는 기본이고, 그 이후에는 계속해서 추가된다.
        // 이러한 단점을 극복한 게 Vector이다. Vector는 객체 배열이다.
        // 따라서 클래스의 인스턴스 멤버들을 사용하려면 다운캐스팅 해줘야한다.  
        // System.out.println(((Audio)p[3]).volume);
        Vector<Product> v = new Vector<>();
        v.add(new Computer());
        v.add(new Radio());
    }
}

interface TT {
    // public abstract void a();
    void a();
}

class T implements TT {
    // 구현부는 원본보다 접근 지정자가 넓어야한다.
    public void a() {}
}

// Fightable 인터페이스에 존재하는 멤버들만 사용이 가능한다.
Fightable f = new Fighter(); // (Fightable)new Fighter();와 동일.

public interface Parseable {
    void parse(String fileName);
}

class XMLParser implements Parseable {
    public void parse(String fileName) {
        System.out.println(fileName + " - XML parsing completed.");
    }
}

class HTMLParser implements Parseable {
    public void parse(String fileName) {
        System.out.println(fileName + " - HTML parsing completed.");
    }
}

class ParserManager {
    public static Parseable getParser(String type) {
        if(type.equals("XML")) return new XMLParser();
        return new HTMLParser();
    }
}

class ParserTest {
    public static void main(String[] args) {
        Parseable parser = ParserManager.getParser("XML");
        parser.parse("document.xml"); // document.xml - XML parsing completed.
        parser = ParserManager.getParser("HTML");
        parser.parse("document.html"); // document.html - HTML parsing completed.
    }
}

default void newMethod(){} // public default void newMethod(){}