编辑

前言

大家好，我是程序猿爱打拳，今天给大家带来的是面向对象之封装继承多态中的多态。文章从多态的概念、多态的条件、重写、向上向下转型、多态的优缺点等来详细讲解多态，让我们继续学习面向对象的过程吧。

编辑

1.多态的概念

多态以我们通俗的话来说，就是一种事物用多种形态来实现。在Java当中就是完成某个行为时用不同的对象去完成会出现不同情况。

编辑

一台打印机，当黑白打印机去实现打印图片功能时打印出来的是黑白图片。而彩色打印机实现打印图片功能时打印出来的是彩色图片。这就是一个功能，不同的实现，也是多态的思想。

2.多态的实现条件

在Java当中要实现多态，必须要满足以下几个条件:

必须在继承的体现下实现
子类必须要对父类中的方法进行重写
通过父类的引用调用重写的方法

多态的体现，在代码的运行时，由于传递的参数不同，会调用不同的类。

class Animal {
    public void eat() {
        System.out.println("吃饭啦!");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃狗粮啦!");
    }
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃猫粮啦!");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal an1 = new Dog();
        Animal an2 = new Cat();
        Animal an3 = new Animal();
        an1.eat();
        an2.eat();
        an3.eat();
    }
}

运行后输出:

编辑

以上程序满足，多态的几个基本条件。实现的就是一个简单的重写，也就是父类和子类有相同的方法。下面我就来具体讲解重写的用法。

3.重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

重写的满足条件:

参数列表相同
方法名相同
返回类型相同

【重写与重载的区别】

区别	重写(oberride)	重载()
参数列表	一定不能被修改	必须修改
返回类型	一定不能修改除非可以构成父子类关系	可以修改
访问限定修饰符	一定不能修改更严格的限制	可以修改

早期的QQ只能发信息，而今天的QQ在发信息的过程中可以看到对方的状态如正在输入信息、正在听歌等等，这是一个动态绑定的思想。

编辑

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。典型代表函数重写。

4.向上转型和向下转型

4.1向上转型

向上转型实际上就是创建一个子类对象，将其当作父类来使用。语法格式为:父类类型对象名 = new 子类类型();

class Animal {
    public String name;
    public void eat() {
        System.out.println(name+"吃饭啦!");
    }
}
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println(name+"吃狗粮啦!");
    }
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println(name+"吃猫粮啦!");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal an1 = new Dog();
        Animal an2 = new Cat();
}

在上述代码中的main方法中，an1和an2就是一个子类对象当作父类类型来使用，也就是向上转型的一个体现，因此

编辑

当我们的编译器中出现上图左侧这样的标志时表示着我们的代码向上转型了，是重写的体现标志。向上转型的使用场景为:直接赋值、方法传参、方法返回。

(1)直接赋值

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+"吃狗粮啦!");
    }
}
class Cat extends Animal {
    public Cat(String name,int age) {
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println(name+"吃猫粮啦!");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal an1 = new Dog("旺财",3);
        Animal an2 = new Cat("小眯",2);
        an1.eat();
        an2.eat();
    }
}

运行后输出:

编辑以上代码展示了直接赋值的效果，在main方法中直接在实例化Dog和Cat时，把参数传给各个子类，达到了向上转型的效果。

(2)方法传参

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+"吃狗粮啦!");
    }
}
class Cat extends Animal {
    public Cat(String name,int age) {
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println(name+"吃猫粮啦!");
    }
}
public class Test {
    //通过方法传参
    public static void eatFood(Animal str) {
        str.eat();
    }
    public static void main(String[] args) {
        //直接赋值
        Animal an1 = new Dog("旺财",3);
        Animal an2 = new Cat("小眯",2);
        eatFood(an1);
        eatFood(an2);
    }
}

运行后输出:

编辑

以上代码中的main方法，我添加了一个eatFood方法。在程序运行前这个方法是里面的str只是一个引用，程序运行后会一次把main方法中的an1和an2传给str，因此达到了一个引用实现两个对象的效果。这样也可以达到个向上转型。

因此，当父类引用的对象不一样时表现出的行为是不一样的，这就是多态的思想。

4.2向下转型

当我们将一个子类经过向上转型后当成父类的方法使用时，再无法调用子类方法了。当时当我们需要调用子类方法中的特性时，就会形成一个向下转型的效果。

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+"吃狗粮啦!");
    }
}
class Cat extends Animal {
    public Cat(String name,int age) {
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println(name+"吃猫粮啦!");
    }
}
public class Test {
    public static void main(String[] args) {
        //直接赋值
        Animal an1 = new Dog("旺财",3);
        Animal an2 = new Cat("小眯",2);
        Animal an3 = new Animal("阿虎",4);
        //向下转型，输出了子类的特性
        an1.eat();
        //向下转型，输出了子类的特性
        an2.eat();
        //输出了父类自己的特性
        an3.eat();
    }
}

运行后输出:

编辑以上代码main方法中，所有的引用都是父类中的eat()方法。但是Dog和Cat有自己的特性，因此父类根据子类特有的特性输出了Dog和Cat这两个子类中的eat()方法，这就是向下转型的体现。

重写的注意项:

private修饰的方法不能重写

static修饰的方法不能重写

子类的访问修饰限定权限要大于等于父类的权限

final修饰的方法不能被重写，我们称之密封方法

5.多态的优缺点

假设有以下代码，画图形:

class Shape {
    public void draw() {
        System.out.println("画图型");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("画菱形");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("画圆形");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("画花儿");
    }
}
public class Test {
    public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] sharpes = {"cycle","rect","flower"};
        for (String shape: sharpes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            }else if(shape.equals("rect")) {
                rect.draw();
            }else if(shape.equals("flower")) {
                flower.draw();
            }
        }
    }
}

运行后输出:

编辑

我们发现这样去编写代码，非常的繁琐，要不停的用法if elseif等等，当我们使用多态后，就能避免这样繁琐的操作。

5.1避免繁琐的操作

class Shape {
    public void draw() {
        System.out.println("画图型");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("画菱形");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("画圆形");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("画花儿");
    }
}
public class Test {
    public static void main(String[] args) {
        Shape[] shapes = {new Rect(),new Cycle(),new Flower()};
        for (Shape shape: shapes) {
            shape.draw();
        }
    }
}

运行后输出：

编辑我们发现，使用多态后能够降低代码的 "圈复杂度", 避免使用大量的 if - else分支语句。

5.2可扩展能力强

如果我们要新增一种新的形状，使用多态的方式代码的改动成本也比较低，如增加一个三角形：

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("画三角形");
    }
}
public class Test {
    public static void main(String[] args) {
        Shape[] shapes = {new Rect(),new Cycle(),new Flower(),new Triangle()};
        for (Shape shape: shapes) {
            shape.draw();
        }
    }
}

我们只需要新增一个类和增加一个对象即可。

5.3多态缺点

代码的运行效率降低
属性没有多态性，当父类和子类都有同名属性的时候，通过父类的引用只能引用父类自己的成员属性
构造方法没有多态性，见下方讲解

6.避免在构造方法中调用重写的方法

class A {
    public A() {
        func();
    }
    public void func() {
        System.out.println("A的func");
    }
}
class B extends A {
    private int num = 10;
    @Override
    public void func() {
        System.out.println("B的func"+num);
    }
}
public class Test {
    public static void main(String[] args) {
        B b = new B();
    }
}

运行后输出:

编辑

构造方法B对象的同时，会调用A的构造方法。A的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到B中的func此时 B 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0. 如果具备多态性，num的值应该是1.所以在构造函数内，尽量避免使用实例方法，除了final和private方法。

那么本期博客都这里就结束了，感谢各位的耐心阅读。

编辑

下期预告:抽象类与接口

【JavaSE】多态

编辑

1.多态的概念

2.多态的实现条件

3.重写

4.向上转型和向下转型

4.1向上转型

4.2向下转型

5.多态的优缺点

5.1避免繁琐的操作

5.2可扩展能力强

5.3多态缺点

6.避免在构造方法中调用重写的方法

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【JavaSE】多态

编辑

1.多态的概念

2.多态的实现条件

3.重写

4.向上转型和向下转型

4.1向上转型

4.2向下转型

5.多态的优缺点

5.1避免繁琐的操作

5.2可扩展能力强

5.3多态缺点

6.避免在构造方法中调用重写的方法

热门文章

最新文章

相关电子书

相关实验场景