【多态-动态绑定-向上转型-抽象类】

//多态
class Animal{
    public String name;
    public int age;
    //无参构造方法
    public Animal() {
    }
    //有参构造方法
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    //成员方法
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
}
class Dog extends Animal {
    //子类构造完成之前要帮助父类构造完成
    public Dog(String name, int age) {
        super(name, age);
    }
    //重写eat方法
    public void eat() {
        System.out.println(this.name + "正在吃狗粮");
    }
}
class Cat extends Animal {
    //子类构造完成之前要帮助父类构造完成
    public Cat(String name, int age) {
        super(name, age);
    }
    //重写eat方法
    public void eat() {
        System.out.println(this.name + "正在吃猫粮");
    }
}
public class Test {
    //多态的第一种
    public static void func(Animal animal){
        animal.eat();//向上转型中的方法传参
    }
    public static void main(String[] args) {
        Dog dog = new Dog("红红",12);
        func(dog);
         Cat cat = new Cat("青青",13);
        func(cat);
    }
    //多态的第二种
    public static void main2(String[] args) {
        Animal animal = new Dog("红红",12);//向上转型中的直接赋值
        animal.eat();
        Animal animal2 = new Cat("青青",13);
        animal2.eat();
    }
}

Animal animal = new Dog("红红",12);

public static void func(Animal animal){
        animal.eat();
    }

//  作返回值：返回任意子类对象
public static Animal buyAnimal(String var){
if("狗".equals(var) ){
return new Dog("狗狗",1);
}else if("猫" .equals(var)){
return new Cat("猫猫", 1);
}else{
return null;
}
}

abstract class Shape{
    public abstract void draw();
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("⚪");
    }
}

abstract class C{
    public abstract void draw();
}
abstract class A extends C {
   abstract public void run();
}
class B extends A{
    @Override
    public void draw() {
    }
    @Override
    public void run() {
    }
}

abstract class Shape{
    public abstract void draw();
}
class Cycle extends Shape{
    //重写抽象类的抽象方法
    @Override
    public void draw() {
        System.out.println("⚪");
    }
}class Rect extends Shape{
    //重写抽象类的抽象方法
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}
public class Test {
    public static void func(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape =new Cycle();
        Shape shape2 =new Rect();
        shape.draw();
        shape2.draw();
    }
}