public class Poly_ {
    public static void main(String[] args) {
        Master tom = new Master("Tom");
        Dog jack = new Dog("jack");
        Cat jerry = new Cat("jerry");
        Bone bone = new Bone("大骨头");
        Fish fish = new Fish("小鱼");
        tom.feed(jack,bone);
        tom.feed(jerry,fish);
    }
}
class Master {
    private String name;
    public Master(String name) {
        this.name = name;
    }
    //主人给小狗喂食骨头
    public void feed(Dog dog, Bone bone) {
        System.out.println("主人" + name + " 给" + dog.getName() + " 吃" + bone.getName());
    }
    //主人给小猫喂黄花鱼
    public void feed(Cat cat, Fish fish) {
        System.out.println("主人" + name + " 给" + cat.getName() + " 吃" + fish.getName());
    }
}
class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
}
class Food {
    private String name;
    public Food(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class Bone extends Food {
    public Bone(String name) {
        super(name);
    }
}
class Fish extends Food {
    public Fish(String name) {
        super(name);
    }
}

public class Poly_ {
    public static void main(String[] args) {
        Master tom = new Master("Tom");
        Dog jack = new Dog("jack");
        Cat jerry = new Cat("jerry");
        Bone bone = new Bone("大骨头");
        Fish fish = new Fish("小鱼");
        tom.feed(jack,bone);
        tom.feed(jerry,fish);
    }
}
class Master {
    private String name;
    public Master(String name) {
        this.name = name;
    }
    //使用多态机制，可以统一的管理主人喂食的问题
    //animal 编译类型是Animal,可以指向(接收) Animal 子类的对象
    //food 编译类型是Food ,可以指向(接收) Food 子类的对象
    public void feed(Animal animal, Food food) {
        System.out.println("主人" + name + " 给" + animal.getName() + " 吃" + food.getName());
    }
}
class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
}
class Food {
    private String name;
    public Food(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class Bone extends Food {
    public Bone(String name) {
        super(name);
    }
}
class Fish extends Food {
    public Fish(String name) {
        super(name);
    }
}

public class PolyDetail {
    public static void main(String[] args) {
        //向上转型: 父类的引用指向了子类的对象
        Animal animal = new Cat(); 
        //可以调用父类中的所有成员(需遵守访问权限)
        animal.eat();//吃
        animal.sleep();//睡

        //不能调用子类中特有成员(属性/方法)
        animal.catchMouse();//错误写法
    }
}
class Animal_ {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void eat(){
        System.out.println("吃");
    }
}
class Cat extends Animal {
    @Override public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){//Cat 特有方法
        System.out.println("猫抓老鼠");
    }
}

public class PolyDetail {
    public static void main(String[] args) {
        Animal animal = new Cat();
        //向下转型：希望可以调用Cat的catchMouse 方法
        Cat cat = (Cat) anima;
        cat.eat();//吃
        cat.sleep();//睡
        cat.catchMouse();//特有方法也可调用 
        //要求父类的引用必须指向的是当前目标类型的对象
        Dog dog = (Dog) animal; //错误写法
    }
}
class Animal_ {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡");
    }
    public void eat(){
        System.out.println("吃");
    }
}
class Cat extends Animal {
    @Override  
    public void eat(){//方法重写
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){//Cat 特有方法
        System.out.println("猫抓老鼠");
    }
}
class Dog extends Animal {//Dog 是Animal 的子类
}

public class PolyDetail02 {
    public static void main(String[] args) {
        //属性没有重写之说！属性的值看编译类型
        Base base = new Sub();//向上转型
        System.out.println(base.count);//看编译类型10
        Sub sub = new Sub();
        System.out.println(sub.count);//20
    }
}
class Base { //父类
    int count = 10;//属性
}
class Sub extends Base {//子类
    int count = 20;//属性
}

public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);//true
        System.out.println(bb instanceof AA);//true

        //BB 是AA 子类
        AA aa = new BB(); //aa 编译类型AA, 运行类型是BB
        System.out.println(aa instanceof AA);//true
        System.out.println(aa instanceof BB);//true

        Object obj = new Object();
        System.out.println(obj instanceof AA);//false

        String str = "hello";
        System.out.println(str instanceof Object);//true
    }
}
class AA {} //父类
class BB extends AA {}//子类

public class DynamicBinding {
    public static void main(String[] args) {
        //a 的编译类型A, 运行类型B
        A a = new B();//向上转型
        //运行类型是B，先找B类里是否有sum，有就直接运行
        System.out.println(a.sum());//40 调用子类sum
        System.out.println(a.sum1());//30 调用子类sum1
    }
}
class A {//父类
    public int i = 10;
    public int sum() {//父类sum()
        return getI() + 10;
    }
    public int sum1() {//父类sum1()
        return i + 10;
    }
    public int getI() {//父类getI
        return i;
    }
}
class B extends A {//子类
    public int i = 20;
    @Override  
    public int sum() {
        return i + 20;
    }
    @Override  
    public int getI() {//子类getI()
        return i;
    }
    @Override  
    public int sum1() {
        return i + 10;
    }
}
public class DynamicBinding {
    public static void main(String[] args) {
        //a 的编译类型A, 运行类型B
        A a = new B();//向上转型
        //运行类型是B，先找B类里是否有sum，没有就去父类找
        System.out.println(a.sum());//30 调用父类sum 和子类getI
        System.out.println(a.sum1());//20 调用父类sum 和父类i
    }
}
class A {//父类
    public int i = 10;
    //动态绑定机制
    public int sum() {//父类sum()
        return getI() + 10;//20 + 10
    }
    public int sum1() {//父类sum1()
        return i + 10;//10 + 10
    }
    public int getI() {//父类getI
        return i;
    }
}
class B extends A {//子类
    public int i = 20;
    @Override  
    public int getI() {//子类getI()
        return i;
    }
}

public class PolyArray {
    public static void main(String[] args) {
        //应用实例:现有一个继承结构如下：要求创建1 个Person 对象、
        // 2 个Student 对象和2 个Teacher 对象, 统一放在数组中，并调用每个对象say 方法
        Person[] persons = new Person[5];
        persons[0] = new Person("jack", 20);
        persons[1] = new Student("mary", 18, 100);
        persons[2] = new Student("smith", 19, 30.1);
        persons[3] = new Teacher("scott", 30, 20000);
        persons[4] = new Teacher("king", 50, 25000);
        //循环遍历多态数组，调用say
        for (int i = 0; i < persons.length; i++) {
            //person[i] 编译类型是Person ,运行类型是是根据实际情况有JVM 来判断
            System.out.println(persons[i].say());//动态绑定机制
            // 使用类型判断+ 向下转型
            if(persons[i] instanceof Student) {//判断person[i] 的运行类型是不是Student
                Student student = (Student)persons[i];//向下转型
                student.study();
                //也可以使用一条语句((Student)persons[i]).study();
            } else if(persons[i] instanceof Teacher) {
                Teacher teacher = (Teacher)persons[i];
                teacher.teach();
            } else if(persons[i] instanceof Person){
                System.out.println("不做处理...");
            } else {
                System.out.println("你的类型有误, 请自己检查...");
            }
        }
    }
}
class Person {//父类
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public String say() {//返回名字和年龄
        return name + "\t" + age;
    }
}
class Student extends Person {
    private double score;
    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
    //重写父类say
    @Override
    public String say() {
        return "学生" + super.say() + " score=" + score;
    }
    //特有的方法
    public void study() {
        System.out.println("学生" + getName() + " 正在学java...");
    }
}
class Teacher extends Person {
    private double salary;
    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }
    //写重写父类的say 方法
    @Override
    public String say() {
        return "老师" + super.say() + " salary=" + salary;
    }
    //特有方法
    public void teach() {
        System.out.println("老师" + getName() + " 正在讲java 课程...");
    }
}

public class PolyParameter {
    public static void main(String[] args) {
        Worker tom = new Worker("tom", 2500);
        Manager milan = new Manager("milan", 5000, 200000);
        PolyParameter.showEmpAnnual(tom);
        PolyParameter.showEmpAnnual(milan);
        PolyParameter.testWork(tom);
        PolyParameter.testWork(milan);
    }
    public static void showEmpAnnual(Employee e) {
        System.out.println(e.getAnnual());
    }
    public static void testWork(Employee e) {
        if (e instanceof Worker) {
            ((Worker) e).work();//有向下转型操作
        } else if (e instanceof Manager) {
            ((Manager) e).manage();//有向下转型操作
        } else {
            System.out.println("不做处理...");
        }
    }
}
class Employee {
    private String name;
    private double salary;
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public double getSalary() {
        return salary;
    }
    public double getAnnual() {
        return 12 * salary;
    }
}
class Worker extends Employee {
    public Worker(String name, double salary) {
        super(name, salary);
    }
    public void work() {
        System.out.println("普通员工" + getName() + " is working");
    }
    @Override
    public double getAnnual() {
        return super.getAnnual();
    }
}
class Manager extends Employee {
    private double bonus;
    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }
    public void manage() {
        System.out.println("经理" + getName() + " is managing");
    }
    @Override
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}

public class EqualsExercise01 {
    public static void main(String[] args) {
        Person person1 = new Person("jack", 10, '男');
        Person person2 = new Person("jack", 20, '男');
        System.out.println(person1.equals(person2));//假
    }
}
//判断两个Person 对象的内容是否相等，
//如果两个Person 对象的各个属性值都一样，则返回true，反之false
class Person{ //extends Object
    private String name;
    private int age;
    private char gender;
    //重写Object 的equals 方法
    public boolean equals(Object obj) {
        //判断如果比较的两个对象是同一个对象，则直接返回true
        if(this == obj) {
            return true;
        }
        //类型判断
        if(obj instanceof Person) {//是Person，我们才比较
            //进行向下转型, 因为我需要得到obj 的各个属性
            Person p = (Person)obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        //如果不是Person ，则直接返回false
        return false;
    }
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

public class Finalize_ {
    //如果程序员不重写finalize,那么就会调用Object类的finalize, 即默认处理
    //如果程序员重写了finalize, 就可以实现自己的逻辑
    public static void main(String[] args) {
        Car bmw = new Car("宝马");
        //这时car对象就是一个垃圾
        //垃圾回收器就会回收(销毁)对象, 
        //在销毁对象前，会调用该对象的finalize 方法
        bmw = null;
        System.gc();//主动调用垃圾回收器
        System.out.println("程序退出了....");
    }
}
class Car {
    private String name;
    public Car(String name) {
        this.name = name;
    }
    //重写finalize
    @Override
    protected void finalize() throws Throwable {
        System.out.println("我们销毁汽车" + name );
        System.out.println("释放了某些资源...");
    }
}

public class ChildGame {
    public static void main(String[] args) {
        //普通方法需定义一个变量 count, 统计有多少小孩加入了游戏
        //int count = 0;
        Child child1 = new Child("白骨精");
        child1.join();
        //count++;
        child1.count++;
        Child child2 = new Child("狐狸精");
        child2.join();
        //count++;
        child2.count++;
        Child child3 = new Child("老鼠精");
        child3.join();
        //count++;
        child3.count++;
        //类变量，可以通过类名来访问,也可通过对象名访问
        System.out.println("共有" + Child.count + " 小孩加入了游戏...");
        System.out.println("child1.count=" + child1.count);//3
        System.out.println("child2.count=" + child2.count);//3
        System.out.println("child3.count=" + child3.count);//3
    }
}
class Child {
    private String name;
    public static int count = 0;  //该变量最大的特点就是会被 Child 类的所有的对象实例共享
    public Child(String name) {
        this.name = name;
    }
    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("你好，李焕英");
        System.out.println("===============");
        Movie movie2 = new Movie("唐探3", 100, "陈思诚");
    }
}
class Movie {
    private String name;
    private double price;
    private String director;
    //3个构造器-》重载
    public Movie(String name) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正是开始...");
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
    }
    public Movie(String name, double price) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正是开始...");
        this.name = name;
        this.price = price;
    }
    public Movie(String name, double price, String director) {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正是开始...");
        System.out.println("Movie(String name, double price, String director) 被调用...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("你好，李焕英");
        System.out.println("===============");
        Movie movie2 = new Movie("唐探3", 100, "陈思诚");
    }
}
class Movie {
    private String name;
    private double price;
    private String director;

    //代码块
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正是开始...");
    };
    //3个构造器-》重载
    public Movie(String name) {
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
    }
    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director) 被调用...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

public final double TAX RATE = 0.08;//定义时赋值

public AA() {//构造器中赋值

    TAX_RATE2 = 1.1;
}

public class AbstractDetail01 {
    public static void main(String[] args) {
        //1、抽象类，不能被实例化
        new A();//错误写法
    }
}
//2、抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
abstract class A {
    public void hi() {
        System.out.println("hi");
    }
}
//3、一旦类包含了abstract 方法,则这个类必须声明为abstract
abstract class B {
    public abstract void hi();
}
//4、abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
    public abstract int n1 = 1; //错误写法
}
//5、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，
除非它自己也声明为 abstract 类。
class D extens B {
    @Override  
    public void hi() {
        //这里相等于D子类实现了父类B的抽象方法，所谓实现方法，就是有方法体
    }
}
//6、抽象方法不能使用 private, final 和 static 来修饰，因为这些关键字都是和重写相违背的。
abstract class E {
    private abstract void hi();//错误写法
    public final abstract void hi();//错误写法
    public static abstract void hi();//错误写法
}
//7、抽象类的本质还是类，所以可以有类的各种成员
abstract class F {
    public int n1 = 10;
    public static String name = "测试";
    public void hi() {
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
        System.out.println("ok");
    }
}
//8、抽象方法不能有主体，即不能实现
abstract class G {
    public abstract void hello(){//错误写法 
    }

}

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //1.接口不能被实例化
        new IA();//错误写法
    }
}
//2.接口中所有的方法是public 方法, 接口中抽象方法，可以不用abstract 修饰
interface IA {
    void say();//修饰符默认 public
    void hi();//实际就是 public abstract void hi();
}
//3.一个普通类实现接口,就必须将该接口的所有方法都实现,可以使用alt+enter 来解决
class Cat implements IA{
    @Override  
    public void say() {
    }
    @Override  
    public void hi() {
    }
}
//4.抽象类去实现接口时，可以不实现接口的抽象方法
abstract class Tiger implements IA {
} 
●  5、一个类同时可以实现多 个接口 
●  6、接口中的属性，只能是 final 的，而且是 public static final 修饰符。 
○ 比如：int a= 1；实际上是 public static final int a=1; (必须初始化)
●  7、接口中属性的访问形式：接口名.属性名 
●  8、接口不能继承其它的类，但是可以继承多个别的接口 
○ interface A extends B,C{}
●  9、接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的。
public class InterfaceDetail02 {
    public static void main(String[] args) {
        //接口中的属性,是public static final
        System.out.println(IB.n1);//说明n1 就是static
        //IB.n1 = 30; 说明n1 是final
    }
}
interface IB {
    //接口中的属性,只能是final 的，而且是public static final 修饰符
    int n1 = 10; //等价public static final int n1 = 10;
    void hi();
}
//接口的修饰符只能是public 和默认，这点和类的修饰符是一样的
interface IC {
    void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
    @Override  
    public void hi() {
    }
    @Override  
    public void say() {
    }
}

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}
//猴子
class Monkey {
    private String name;
    public Monkey(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void climbing() {
        System.out.println(name + " 会爬树...");
    }
}
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}
class LittleMonkey extends Monkey implements Fishable,Birdable {
    public LittleMonkey(String name) {
        super(name);
    }
    @Override  
    public void swimming() {
        System.out.println(getName() + " 通过学习，可以像鱼儿一样游泳...");
    }
    @Override  
    public void flying() {
        System.out.println(getName() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}
/*
悟空 会爬树...
悟空 通过学习，可以像鱼儿一样游泳...
悟空 通过学习，可以像鸟儿一样飞翔...
*/

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量usb可以指向实现了USB接口类的对象实例
        USB usb = new Phone();
        usb = new Camera();
        //继承体现的多态
        //父类类型的变量father可以指向继承Farher的子类的对象实例
        Farher father = new Son();
        father = new Daughter();
    }
}
interface USB {}
class Phone implements USB{}
class Camera implements USB{}
class Farher {}
class Son extends Farher {}
class Daughter extends Farher {}

public class InterfacePolyArr {
    public static void main(String[] args) {
        USB[] usb = new USB[2];
        usb[0] = new Phone();
        usb[1] = new Camera();
        for(int i = 0; i < usb.length; i++) {
            usb[i].work();//动态绑定..
            //需要进行类型的向下转型
            if(usb[i] instanceof Phone) {//判断他的运行类型是Phone_
                ((Phone) usb[i]).call();
            }
        }
    }
}
interface USB {
    void work();
}
class Phone implements USB{
    public void call() {
        System.out.println("手机可以打电话...");
    }
    @Override
    public void work() {
        System.out.println("手机工作中...");
    }
}
class Camera implements USB{
    @Override
    public void work() {
        System.out.println("相机工作中...");
    }
}

public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了IH 接口，而Teacher 类实现了IG 接口
        //那么，实际上就相当于Teacher 类也实现了IH 接口.
        //这就是所谓的接口多态传递现象.
        IH ih = new Teacher();
    }
}
interface IH {
    void hi();
}
interface IG extends IH{}
class Teacher implements IG {
    @Override
    public void hi() {
    }
}

public class InterfaceExercise02 {
    public static void main(String[] args) {
        new C().pX();
    }
}
interface A { 
    int x = 0;//等价public static final int x = 0;
} 
class B {
    int x = 1;//普通属性
} 
class C extends B implements A {
    public void pX() {
        System.out.println(x); //错误，原因不明确x
        //改进
        //访问接口的x就使用A.x
        //访问父类的x就使用super.x
        System.out.println(A.x + " " + super.x);   
    }
}

public class Inner{
    ...
    public Inner getInnerInstance(){
        return new Inner();
    }
}
Outer outer = new Outer()
outer.getInnerInstance()

public Inner getInnerInstance(){
    return new Inner();
}
}
Outer outer = new Outer()
outer.getInnerInstance()
//或者
Outer.getInnerInstance()