【Java 基础】：三大特征之多态

class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃狗粮");
    }
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃猫粮");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 父类引用指向子类对象
        Animal animal2 = new Cat(); // 父类引用指向子类对象
        animal1.eat(); // 输出：狗吃狗粮
        animal2.eat(); // 输出：猫吃猫粮
    }
}

//父类
class Person {
	public void mission() {	
		System.out.println("人要好好活着！");
	}
}

//子类
class Student extends Person {
	@Override
	public void mission() {	
		System.out.println("学生要好好学习！");
	}
}

//演示动态绑定
public class DynamicBinding {
	public static void main(String[] args) {
		//向上转型（自动类型转换）
		//程序在编译阶段只知道 p1 是 Person 类型
		//程序在运行的时候才知道堆中实际的对象是 Student 类型	
		Person p1 = new Student();  
		
		//程序在编译时 p1 被编译器看作 Person 类型
		//因此编译阶段只能调用 Person 类型中定义的方法
		//在编译阶段，p1 引用绑定的是 Person 类型中定义的 mission 方法（静态绑定）
		//程序在运行的时候，堆中的对象实际是一个 Student 类型，而 Student 类已经重写了 mission 方法
		//因此程序在运行阶段对象中绑定的方法是 Student 类中的 mission 方法（动态绑定）
		p1.mission();
	}
}


/* 结果输出
 *   学生要好好学习! 
 * */

class A1{
    public String name;
    public int age;

    public A1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(this.name + " 父类");
    }
    public void bark1(){
        System.out.println(this.name + " 不构成重写父类调用");
    }
}

class A2 extends A1 {
    private int num = 1;

    public A2(String name, int age){
        super(name,age);
    }
    public void eat(){ //和父类构成 重写
        System.out.println(this.name + " 子类");
    }
    public void bark2(){
        System.out.println(this.name + " 不构成重写子类调用");
    }
}

public class Test {
    public static void func1(A1 a) {
        a.eat();
        a.bark1();
    }
    public static A1 func2() {
        A1 a = new A2("change",18);
        return a;
    }

    public static void main(String[] args) {
        // 向上转型
        // 1. 直接赋值
        A2 a2 = new A2("change", 18);
        A1 a1 = a2; // 子类 A2 这个引用父类这个引用所指向对象
        // 上下两种相同
        A1 a = new A2("change", 18);
        a.eat(); // 调用的是 子类 中的 eat() 方法
        //a.bark2(); // 错误：无法访问 子类中独有的方法

        // 2，方法的参数，传参的时候进行向上转型
        // 传的是子类时，只能调用子类的方法
        //func1(a);
        func1(a2);

        // 3. 返回值向上转型
        func2();
    }
}

/* 结果输出
*   change 子类
*   change 子类
*   change 不构成重写父类调用
* */

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
    public void bark() {
        System.out.println("Dog is barking");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating");
    }
    public void bark() {
        System.out.println("Cat is barking");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型
        animal.eat();  // 调用的是 Dog 类中的 eat() 方法
        // animal.bark();  // 错误：无法访问 Dog 类中独有的方法

        Dog dog = (Dog) animal;  // 向下转型
        dog.bark();  // 调用 Dog 类中的 bark() 方法
    }
}

/* 结果输出
 *   Dog is eating
 *   Dog is barking
 * */

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
    public void bark() {
        System.out.println("Dog is barking");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating");
    }
    public void bark() {
        System.out.println("Cat is barking");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型

        if(animal instanceof Dog){ //判断对象 animal 是否是 Dog 类 的实例
            Dog dog = (Dog) animal;  // 向下转型
            dog.bark();  // 调用 Dog 类中的 bark() 方法
            //上面这两句也可简写为 ((Dog) animal).bark();
        }
        else if(animal instanceof  Cat){ //判断对象 animal 是否是 Cat 类 的实例
            ((Cat)animal).bark();
        }

    }
}

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating");
    }
}
public class Test{

    public static void main(String[] args) {
        Animal[] animals = {new Animal(),new Dog(),new Cat()};
        for(Animal a: animals){a.eat();};
    }
}


/* 结果输出
* Animal is eating.
* Dog is eating
* Cat is eating
* */

class B {
    public B() {
        // do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}