JavaSE：继承和多态（下篇）

目录

一、前言

二、多态

（一）多态的概念

（二）多态实现条件

（三）多态的优缺点

三、重写

（一）重写的概念

（二）重写的规则

 （三）重写和重载的区别

四、向上转型和向下转型

（一）向上转型

（二）向下转型 

 五、总结

---

一、前言

大家好，前几天蜡笔小欣带大家了解并学习了Java中的继承，子类通过extends关键字来继承父类。通过继承，子类可以重写父类的方法，从而实现多态性。今天我们就一起去认识Java中的多态，了解多态的概念，掌握多态的用法，使我们在写程序时更加方便。

二、多态

（一）多态的概念

简单来说就是同一件事情，发生在不同对象身上，会产生不同的结果 。

（二）多态实现条件

多态实现的条件：

1. 必须在继承体系下，

2. 子类必须要对父类中方法进行重写，

3. 通过父类的引用调用重写的方法。

下面举个例子让大家更好地理解：

我们先定义一个父类Animal，这个类里面有两个成员变量，一个方法。

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

 接着我们定义两个子类，分别是Dog和Cat，都继承父类Animal，在这两个类中重写eat()方法。

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
 
    public void eat() {
        System.out.println(name + "正在吃狗粮");
    }
 
    public void bark() {
        System.out.println(name + "汪汪汪");
    }
}
 
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
 
    public void eat() {
        System.out.println(name + "正在吃猫粮");
    }
 
    public void mew() {
        System.out.println(name + "喵喵喵");
    }
}

然后我们在Test里面定义一个静态方法func()，父类Animal作为参数引用，再调用eat()方法。

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

最后实例化对象，进行初始化赋值。

public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Cat cat = new Cat("汤姆", 5);
        eat(dog);
        eat(cat);
}

（三）多态的优缺点

多态的优点：

1. 能够降低代码的 " 圈复杂度 ", 避免使用大量的 if - else，

2. 可扩展能力更强。

多态缺陷：代码的运行效率降低 。

三、重写

（一）重写的概念

（二）重写的规则

2.被重写的方法返回值类型可以不同，但是必须是具有父子关系的。我们可以理解为将eat()方法定义为父子关系。

3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为protected。

4.父类被static、private修饰的方法、构造方法都不能被重写。 

 5.重写的方法，可以使用 @Override 注解来显式指定。 有了这个注解能帮我们进行一些合法性校验。 例如不小心将方法名字拼写错了 (比如写成 aet)，那么此时编译器就会发现父类中没有 aet 方法，就会编译报错，提示无法构成重写。

 操作步骤：1.点击鼠标右键，点击generate。

2.选择红色箭头所指向的部分。

3.点击我们要重写的方法。 

 4.最后就可以对父类的方法进行重写，如果我们不小心把重写的方法名写错了，@Override就可以帮我们检测出来，使我们在重写方法时更加方便。

 

 （三）重写和重载的区别

方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

四、向上转型和向下转型

（一）向上转型

语法格式：父类类型 对象名 = new 子类类型()

Animal animal = new Cat ( " 汤姆 " , 5 );

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

下面我们举个例子看看：

class Animal {
    public String name;
    public 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 class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }
 
    public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Animal animal =dog;//animal这个引用指向了Dog对象
        animal.eat();
    }
}

运行结果如下：

 

当我们把Dog类中eat()方法注释后，运行结果为：

我们会发现它执行了父类Animal中的eat()方法。那如果这时候我们在Dog类中加入一个color成员变量。

然后我们用对象animal去调用它试试看能否运行。

 我们发现结果报错，这是因为color这个属性是Dog类中的，而animal无法访问到。

Tips：

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

（二）向下转型 

 

class Animal {
    public String name;
    public 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 String color;
 
    public Dog(String name, int age) {
        super(name, age);
        this.color = color;
    }
 
    /*@Override
    public void eat() {
        System.out.println(name +"正在吃狗粮");
    }*/
 
    public void bark() {
        System.out.println(name + "汪汪汪");
    }
}
 
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
 
    public void eat() {
        System.out.println(name + "正在吃猫粮");
    }
 
    public void mew() {
        System.out.println(name + "喵喵喵");
    }
}
 
public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }
 
    public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Animal animal = dog;//animal这个引用指向了Dog对象
        Cat cat = new Cat("汤姆", 5);
        cat = (Cat) animal;
        cat.mew();
    }
}

Animal向下转型为Cat，Cat本来就是猫，转换为猫，安全；Animal向下转型为Dog，Cat本来是猫，转换为狗，则不安全。 

运行结果：

 因为animal实际指向的是狗，但现在要强制还原为猫，无法正常还原，所以运行时抛出类型转换异常。

解决方法：

Java 中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为 true ，则可以安全转换。

public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }
 
    public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Animal animal = dog;//animal这个引用指向了Dog对象
        Cat cat = new Cat("汤姆", 5);
        if (animal instanceof Cat) {
            cat = (Cat) animal;
            cat.mew();
        }
        if (animal instanceof Dog) {
            dog = (Dog) animal;
            dog.bark();
        }
    }
}

 运行结果：

 五、总结

多态是面向对象的一个关键概念，它允许对象以不同的方式表现，具体取决于它们的类型。在 Java中，多态通过继承和方法重写来实现，让我们能够编写灵活、可扩展且可维护的代码。我们这期多态的内容就分享到这里，希望能够对大家有所帮助，感谢各位对蜡笔小欣的鼓励支持，我们下次再见！！！