java语言基础--多态

多态：

• 有继承
• 有方法重写
• 有父类引用指向子类对象

 

举个栗子：

Animal.java

public class Animal {
    
    public int num=10;
    
    public void eat() {
        System.out.println("动物在吃");
    }
}

Dog.java

public class Dog extends Animal{

    public void eat() {
        System.out.println("狗在吃");
    }
}

Cat.java

public class Cat extends Animal{

    public int num = 20;
    
    public void eat() {
        System.out.println("猫在吃");
    }
    public void move() {
        System.out.println("走路很轻盈");
    }
}

Test.java

public class Test {

    public static void main(String[] args) {
        Cat c1 = new Cat();
        c1.eat();
        Animal a1 = new Cat();        //父类引用指向子类对象，自动类型转换，也叫作向上转型
        a1.eat(); 　　// 动态绑定和静态绑定 a1指向的是Cat这个对象
        System.out.println(a1.num); 　　// 成员变量不存在重写
        Cat c = (Cat) a1;        //强制类型转换，也叫作向下转型；将父类引用转为子类引用
        c.move();
    }
}

打印结果：

猫在吃
猫在吃
10

instanceof

判断是否属于某个类型

举个栗子

        Animal a2= new Dog();
        if (a2 instanceof Cat) {
            Cat c2 = (Cat)a2;
        }else {
            System.out.println("a2不是Cat类型的");
        }

多态的优点

• 提高代码的扩展性；

来个栗子：

Car.java

public class Car {

    public void run() {
        System.out.println("被开走了");
    }
}

Benz.java

public class Benz  extends Car{

    public void run() {
        System.out.println("奔驰车在跑");
    }
}

BWM.java

public class BWM {

    public void run() {
        System.out.println("宝马车在跑");
    }
}

Person.java

public class Person {

    public void drive(Car car) {
        car.run();
    }
}

Test01.java

public class Test01 {

    public static void main(String[] args) {
        Person james = new Person();
        Benz bz =new Benz();
        james.drive(bz);
    }
}

打印结果：

奔驰车在跑

在这个栗子中，使用了多态的内容，减少了代码的冗余，设想，如果我不用多态，那我添加一辆车，岂不是要在Person类中填一个方法，一直填？肯定不行。这样我就只有一个Car的对象，就不用添加宝马奔驰奥迪了。