Java面向对象多态

多态

1.1 面向对象三大特征 ?

• 封装 , 继承 , 多态

1.2 什么是多态 ?

• 一个对象在不同时刻体现出来的不同形态

• 举例 : 一只猫对象

  • 我们可以说猫就是猫 : Cat cat = new Cat();
  • 我们也可以说猫是动物 : Animal cat = new Cat();
  • 这里对象在不同时刻,体现出来的不同形态 , 我们就可以理解为多态

1.3 多态的前提

• 有继承/实现关系
• 有方法重写
• 父类的引用指向子类的对象

public class Animal {
    public void eat(){
        System.out.println("吃东西");
    }
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼。。。。");
    }
}
public class Dog  extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头。。。");
    }
}
public class AnimalTest {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        Animal b = new Dog();
        b.eat();
    }
}

运行程序后结果如下：

D:\jdk17\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2021.3.3\lib\idea_rt.jar=58814:D:\IntelliJ IDEA 2021.3.3\bin" -Dfile.encoding=UTF-8 -classpath E:\Linuxshare\StartJava\out\production\StartJava;E:\Linuxshare\StartJava\lib\jl-1.0.1.jar com.itheima.polymorphism_demo.AnimalTest
猫吃鱼。。。。
狗吃骨头。。。

Process finished with exit code 0

1.4 多态的成员访问特点

• 构造方法 : 和继承一样 , 子类通过super()访问父类的构造方法
• 成员变量 : 编译看左边(父类) , 执行看左边(父类)
• 成员方法 : 编译看左边(父类) , 执行看右边(子类)

public class Fruit {
    int num=100;
    public void show(){
        System.out.println("父类的show方法");
    }
}
public class Apple extends Fruit{
    int num=10;
    @Override
    public void show() {
        System.out.println("子类的show方法");
    }

    public void showNum(){
        System.out.println(this.num);
    }
}

D:\jdk17\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2021.3.3\lib\idea_rt.jar=59076:D:\IntelliJ IDEA 2021.3.3\bin" -Dfile.encoding=UTF-8 -classpath E:\Linuxshare\StartJava\out\production\StartJava;E:\Linuxshare\StartJava\lib\jl-1.0.1.jar com.itheima.polymorphism_demo.FruitTest
100

Process finished with exit code 0

1.5 多态的优缺点

• 优点 : 提高代码的扩展性
• 缺点 : 不能调用子类特有的功能

public abstract class Animal {
    private String breed;
    private String color;

    public Animal() {
    }

    public Animal(String breed, String color) {
        this.breed = breed;
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public abstract void eat();
}
public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String breed, String color) {
        super(breed, color);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
    }

    public void catchMouse() {
        System.out.println("抓老鼠...");
    }
}
public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String breed, String color) {
        super(breed, color);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头!");
    }

    public void lookDoor(){
        System.out.println("狗看门...");
    }
}
public class Pig extends Animal{
    public Pig() {
    }

    public Pig(String breed, String color) {
        super(breed, color);
    }

    @Override
    public void eat() {
        System.out.println("猪拱白菜...");
    }

    public void sleep() {
        System.out.println("一直再睡...");
    }
}

/*
    如果方法的参数是一个类的话 , 那么调用此方法需要传入此类的对象 , 或者子类对象

    多态的好处 :
        提高代码的扩展性 , 灵活性
    多态的缺点:
        不能调用子类的特有功能
 */
public class AnimalTest {
    public static void main(String[] args) {
        userAnimal(new Cat());
        System.out.println("-------------");
    }

    public static void userAnimal(Animal a){
        a.eat();
        // 向下转型，使用子类的方法
        if(a instanceof Cat){
            Cat cat = (Cat) a;
            cat.catchMouse();
        }
        if(a instanceof Dog){
            Dog dog=(Dog)a;
            dog.lookDoor();
        }
        if(a instanceof Pig) {
            ((Pig) a).sleep();
        }
    }
}

1.6 多态的转型

• 向上转型 : 把子类类型数据转成父类类型数据 Animal a = new Dog();
• 向下转型 : 把父类类型数据转成子类类型数据 Dog dog = (Dog)a;

1.7 多态的转型注意

• 如果被转的对象 , 对应的实际类型和目标类型不是同一种数据类型 , 那么转换时会出现ClassCastException异常

异常代码如下
public static void main(String[] args) {
    Animal a = new Cat();
    useAnimal(a);
}
public static void useAnimal(Animal a) {
    Dog d = (Dog) a;
    d.eat();
}

1.8 解决转型安全隐患

• 使用关键字 instanceof
• 作用 : 判断一个对象是否属于一种引用数据类型
• 格式 : 对象名 instanceof 引用数据类型
  • 通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果