Java 面向对象的多态特征介绍

多态

多态的特性就是，运行期才能动态决定调用的子类方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法。这种不确定性的方法调用，作用是：允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式：

父类名称 对象名 = new 子类名称();

接口名称 对象名 = new 实现类名称();

Father 类

public class Father {
    public void method() {
        System.out.println("父类方法");
    }
    public void methodFather() {
        System.out.println("父类特有的方法");
    }
}

Son 类

public class Son extends Father {
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

调用

public class Test {
    public static void main(String[] args) {
        // 使用多态的写法：左侧是父类的引用，右侧是子类的对象
        Father obj = new Son();
        obj.method(); // 子类方法
        obj.methodFather(); // 父类特有的方法
    }
}

多态访问成员变量

多态访问成员变量的两种方式：

1. 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。

2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。

Father 类

public class Father {
    int num = 10;
    public void method() {
        System.out.println("父类方法");
    }
    public void methodFather() {
        System.out.println("父类特有的方法");
    }
    public void showNum() {
        System.out.println(num);
    }
}

Son 类

public class Son extends Father {
    int num = 20;
    int age = 16;

    @Override
    public void method() {
        System.out.println("子类方法");
    }

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

    public void methodSon() {
        System.out.println("子类特有方法");
    }
}

调用

public class Test {
    public static void main(String[] args) {
        // 使用多态的写法：左侧是父类的引用，右侧是子类的对象
        Father obj = new Son();
        // 取父值
        System.out.println(obj.num); // 10

        // 无法获取子类特有的成员变量
        // System.out.println(obj.age); // 报错

        // 子类如果没有覆盖重写，就取父值；否则取子值
        obj.showNum(); // 20
    }
}

实例

Animal 类

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Cat 类

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
}

Dog 类

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
}

调用

public class Test {
    public static void main(String[] args) {
        Animal[] animals = {
            new Animal("动物"),
            new Cat("猫"),
            new Dog("狗")
        };
        getAnimalName(animals);
    }

    /**
     * 该方法只需要与 Animal 类打交道，不需要知道 Dog 和 Cat 的存在
     * 即使我们新增 Animal 的子类，也不需要修改此方法
     * @param animals
     */
    public static void getAnimalName(Animal... animals) {
        for (Animal animal : animals) {
            System.out.println(animal.name);
        }
    }
}

结果：

动物
猫
狗