本篇会加入个人的所谓‘鱼式疯言’

❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言
而是理解过并总结出来通俗易懂的大白话,
小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.
🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人能接受我们这个概念 ！！！

前言

在前面两篇文章中,小编带着友友们详细的熟悉了我们面向对象的前两式-------- 封装, 继承

而在本篇文章中小编讲带着小伙伴具体走进咱们第三式: 多态

竟然都进入第三式了, 我们的难度也会加大哦,小伙伴们一定要认真的阅读小编的讲解哦 💖 💖 💖

还是老规矩，小伙伴们从目录开始吧 💖 💖 💖

目录

1. 重写
2. 向上转型与向下转型
3. 多态的实现
4. 多态的优缺点

当小编写出第一个小标题的时候，小爱同学就问了，

我们不是讲多态吗？ 怎么变成重写了，那重写是什么？ 向下转型和向上转型又什么呢？

浅浅和小伙伴先透露一下哦，我们要实现多态就需要两个原理：

一个是 重写

另外一个就是我们的 向上转型 。

所以让小编带着带着循序渐进，脚踏实地的走入多态的海洋哦。 💖 💖 💖

一. 重写

1. 重写的初识

重写(override)：也称为覆盖。

重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。

重写的好处在于 子类可以根据需要，定义特定于自己的行为。

也就是说子类能够根据需要实现父类的方法。

鱼式疯言

如果非要小编用9个字来概括的话，非他们莫属了 😁 😁 😁

即外壳不变，核心重写！

2. 举个栗子

class Dog {
    public void bark() {
        System.out.println("woof");
    }
}


class Hound extends Dog {
    public void sniff() {
        System.out.println("sniff");
    }

    @Override
    public void bark() {
        System.out.println("bowl");
    }
}


class Test {
    public static void main(String[] args) {
        Hound hound=new Hound();
        hound.bark();
    }
}

通过上面的栗子证明了我们方法重写的哪些规则呢

方法重写规则

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
  被重写的方法返回值类型可以不同，但是必须是具有父子关系的

• 访问权限不能比父类中被重写的方法的 访问权限更低 。

• 例如：如果父类方法被 public修饰 ，则子类中重写该方法就不能声明为 protected

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

• 重写的方法, 可以使用 @Override 注解来显式指定.

• 有了这个注解能帮我们进行一些 合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet),

• 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

鱼式疯言

给大家举个生活中的栗子就明白我们 重写的重要性 了

对于已经投入使用的类，尽量不要进行修改。

最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。

例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示的时候，不仅仅可以显示号码，还可以显示头像，地区等。

在这个过程当中，我们不应该在原来老的类上进行修改，因为原来的类，可能还在有用户使用，正确做法是：新建一个新手机的类，对来电显示这个方法重写就好了，这样就达到了我们当今的需求了。

当我们熟悉了重写之后，和我们之前学过的重载又有什么异同之处呢 💕 💕 💕

3. 重写与重载的区别

class Dog {
    public void bark() {
        System.out.println("woof");
    }

    public void bark(int num) {
        for (int i = 0; i < num; i++) {
            System.out.print("woof ");
        }
    }
}


class Hound extends Dog {
    public void sniff() {
        System.out.println("sniff");
    }

    @Override
    public void bark() {
        System.out.println("bowl");
    }
}


class Test {
    public static void main(String[] args) {
        Hound hound=new Hound();
        hound.bark();

        Dog dog=new Dog();
        dog.bark(5);
    }
}

从中我们把他们分解着来看

从什么的图解中我们就明白了，重写和重载的最本质的区别

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

鱼式疯言

有图有真相

、

二. 向上转型和向下转型

1. 向上转型

<1>. 向上转型简介

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

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

et：Animal animal = new Cat(“元宝”,2);

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

<2>. 举个栗子

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 Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }
}


class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }
}

class Test {
    public static void main(String[] args) {
        Animal animal1=new  Cat("小喵",14);
        animal1.eat();

        Animal animal2=new Dog("小汪",18);
        animal2.eat();
    }
}

鱼式疯言：

画个小图说明下：

<3>. 向上转型的实际运用

小编总结向上转型的三个使用场景

1. 直接赋值
2. 方法传参
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 Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }
}


class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }
}




class TestAnimal {

    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
        a.eat();
    }

    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗".equals(var) ){
            return new Dog("狗狗",1);
        }else if("猫" .equals(var)){
            return new Cat("猫猫", 1);
        }else{
            return null;
        }
    }
    public static void main(String[] args) {


        // 1. 直接赋值：子类对象赋值给父类对象
        Animal cat = new Cat("元宝",2);

        Dog dog = new Dog("小七", 1);
        eatFood(cat);
        eatFood(dog);

        Animal animal = buyAnimal("狗");
        animal.eat();

        animal = buyAnimal("猫");
        animal.eat();
    }
}

鱼式疯言

最后小编补充个点哦

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

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

2. 向下转型

有 向上转型 就必然有 向下转型

<1>. 向下转型的简介

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法。

但有时候可能需要调用 子类特有的方法 。

此时：将父类引用再还原为子类对象即可，即向下转换。

这是下面这张图啦 😁 😁 😁

<2>. 举个栗子

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 Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }
}


class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }
}


 class TestAnimal {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
// 向上转型
        Animal animal = cat;
        animal.eat();
        animal = dog;
        animal.eat();

        // 编译失败，编译时编译器将animal当成Animal对象处理
        // 而Animal类中没有bark方法，因此编译失败
        // animal.bark();

        // 向上转型
        // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
        // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException
        cat = (Cat)animal;
        cat.eat();

        // animal本来指向的就是狗，因此将animal还原为狗也是安全的
        dog = (Dog)animal;
        dog.eat();
    }
}

上面的结果怎么会出现这样子呢，原来啊

所以 向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。

Java中为了提高向下转型的安全性

引入了instanceof ，如果该表达式为true，则可以安全转换。

    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 Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }

    public void mew() {
        System.out.println(super.name+"正在mew~~~~");
    }
}


class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }

    public void bark() {
        System.out.println(super.name+"正在bark~~~~");
    }
}


class TestAnimal {
        public static void main(String[] args) {
            Cat cat = new Cat("元宝",2);
            Dog dog = new Dog("小七", 1);
// 向上转型
            Animal animal = cat;
            animal.eat();
            animal = dog;
            animal.eat();
            if(animal instanceof Cat){
                cat = (Cat)animal;
                cat.mew();
            }
            if(animal instanceof Dog){
                dog = (Dog)animal;
                dog.bark();
            }
        }
    }

很明显我们看到当我们用 instanceof 关键字时，代码的安全性就提高了很多

三. 多态的实现

1.多态的简介

多态的概念：通俗来说，就是多种形态

具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

好比下面这些小图 😎 😎 😎

鱼式疯言

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

2. 多态实现的条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在 继承体系 下

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

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

<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 Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃鱼~~~~~");
    }

    public void mew() {
        System.out.println(super.name+"正在mew~~~~");
    }
}


class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(super.name+"吃骨头~~~~");
    }

    public void bark() {
        System.out.println(super.name+"正在bark~~~~");
    }
}


///分割线//

 class TestAnimal {


        // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
        // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
        // 注意：此处的形参类型必须时父类类型才可以
public static void eat(Animal a){

        a.eat();
    }
public static void main(String[] args) {
    Cat cat = new Cat("元宝", 2);
    Dog dog = new Dog("小七", 1);
    eat(cat);
    eat(dog);
}

}

在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类)

此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型 (哪个子类)的实例.

此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态.

我们面向对象编程的多态只是一种 编程思维

而真正操作是我们称为： 动态绑定

2. 静态绑定与动态绑定

<1>. 静态绑定

静态绑定：也称为 前期绑定(早绑定)

class Test9 {
    public static int sum(int x,int y) {
        return x+y;
    }

    public static double sum (double x,double y,double z) {
        return x+y+z;
    }
    public static void main(String[] args) {

        System.out.println(sum(2, 6));

        System.out.println(sum(1.2, 3.5, 9.3));
    }
}

即在编译时，根据用户所传递实参类型就确定了具体 调用 那个方法。

典型代表函数重载。

<2>. 动态绑定

动态绑定：也称为 后期绑定(晚绑定)

具体的栗子我们在多态中已经充分的体现了，下编在这里就不赘述了 😊 😊 😊

即在编译时，不能确定 方法的行为 ，需要等到 程序运行 时，才能够确定具体调用那个 类的方法 。

鱼式疯言

用大白话说就是

动态绑定： 编译时确定，运行时改变

静态绑定： 编译时确定，运行时也确定

四. 多态的优缺点

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("●");
    }
}

【使用多态的好处】

什么叫 “圈复杂度” ?

圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解.

而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.

因此小伙伴们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”.

如果一个方法的圈复杂度太高, 就需要考虑重构.

不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 .

1. 圈复杂度低

<1>.普通栗子one

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("❀");
    }
}


class Test {
    public static void drawShapes() {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
        for (String shape : shapes) {
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("rect")) {
                rect.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
        }
    }

    public static void main(String[] args) {
        drawShapes();
    }
}

从这个普通栗子中是不是就能看出我们的 圈复杂度 是不是 很高

那如果是使用多态的思想来解决问题呢 🤔 🤔 🤔

<2>.多态栗子two

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("❀");
    }
}


class Test {
    public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
        Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
                new Rect(), new Flower()};
        for (Shape shape : shapes) {
            shape.draw();
        }
    }

    public static void main(String[] args) {
        drawShapes();
    }
}

2. 可扩展能力强

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

class Triangle extends Shape {
@Override
public void draw() {
System.out.println("△");
}
}

对于类的调用者来说**(drawShapes方法),** 只要创建一个新类的实例就可以了, 改动成本很低.

而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

有优点就会有缺点

3. 多态的缺陷

1. 属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

2. 构造方法没有多态性

见如下代码

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

class B {
    public B() {
// do nothing
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

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

鱼式疯言

结论:

“用尽量简单的方式使对象进入可工作状态”, 尽量不要在
构造器中调用方法

(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成)

可能会出现一些隐藏的但是又极难发现的问题.

总结

1. 重写： 理解了重写是在什么前提下进行，并与重载进行对比
2. 向上转型与向下转型： 明白了向上整型的初始化以及不同的使用场景，向下转型的 instanceof 检验运用
3. 多态的实现： 理解多态的概念，以及多态的实际运用和使用特点
4. 多态的优缺点：多态的优点的多个典型栗子说明，以及多态的缺点的不规范使用的详解

如果觉得小编写的还不错的咱可支持 三连 下 (定有回访哦) , 不妥当的咱请评论区 指正

希望我的文章能给各位宝子们带来哪怕一点点的收获就是 小编创作 的最大 动力 💖 💖 💖