Java面向对象：初识多态

1、多态

多态是面向对象编程的三大基本特性之一。多态指的是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态实现条件：

1、继承关系的存在

2、方法的重写

3、父类引用调用重写的方法

例子：

class Animal {
    public void eat() {
        System.out.println("Animal在吃饭");
    }
}

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

public class Test {
    public static void eat(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        eat(dog);
        eat(cat);
    }
}

输出：

Dog在吃狗粮
Cat在吃猫粮

2、向上转型

向上转型是子类对象赋值给父类引用变量，实际就是创建一个子类对象，将其当作父类对象来使用。

格式：

父类类型 对象名 = new 子类类型

Animal animal = new Dog();

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name + "在吃狗粮");
    }
}

public static void main(String[] args) {
    // 显式创建子类对象，然后隐式地赋值给父类引用：
    Dog dog = new Dog("小白",5);
    Animal an;
    an = dog;
    dog.eat();

    // 直接在声明和初始化时隐式地赋值给父类引用
    Animal animal = new Dog("小黄",5);
    animal.eat();
}

输出：

小白在吃狗粮
小黄在吃狗粮

3、向下转型

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name + "在吃狗粮");
    }
    public void bark(){
        System.out.println(name + "在叫");
    }
}

public static void main(String[] args) {
    Animal animal = new Dog("小黄",5); // 隐式向上转型

    // 向下转型：检查animal是否是Dog的实例，然后显式转换
    if (animal instanceof Dog) {
        Dog dog = (Dog) animal; // 显式向下转型
        dog.bark(); // 调用Dog类特有的方法
    }
}

输出：

小黄在叫

4、重写

重写（Override）是指子类重新定义或实现了父类中已有的方法。当子类继承一个父类时，它可以通过重写父类的方法来改变该方法的实现方式，以适应子类自己的需求。

4.1、子类需维持父类方法原型

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println(name + "在吃狗粮");
    }
}

4.2、子类重写应维持或提升访问权限

访问权限大小：public > protected > default(默认) > private

例子：

class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "在吃饭");
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    } 
    @Override
    protected void eat(){ // 此处的访问权限比父类低，程序无法执行
        System.out.println(name + "在吃狗粮");
    }
}

4.3、父类静态、私有方法及构造方法的非重写特性

例子：

class Animal {
    String name;
    int age;
    // 静态方法
    public static void staticMethod() {
        System.out.println("Animal的静态方法");
    }
    // 私有方法
    private void privateMethod() {
        System.out.println("Animal的私有方法");
    }
}

class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    // 静态方法不能在实例方法中直接重写，但可以在子类中定义同名静态方法  
    // 这只是隐藏了父类的静态方法，而不是重写  
    public static void staticMethod() {
        System.out.println("Dog的静态方法");
    }
}