Java--多态

在理解多态前要先知道什么时向上转型，方法重写

向上转型：

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

例如：

已经创建了狗类和动物类，狗类继承了动物类

Animal animal = new Dog();

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

 也可以作为方法传参的接受值

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

也可以作为方法的返回值 

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

向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。 

方法重写：

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

【方法重写的规则】
子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
被重写的方法返回值类型可以不同，但是必须是具有父子关系的
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能用protected修饰
父类被static、private修饰的方法、构造方法都不能被重写。
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写. 

 

class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Bird extends Animal{
    //重写eat
    @Override
    public void eat() {
        System.out.println(this.name + "正在吃虫子");
    }
}
class Dog extends Animal{
    //重写eat
    @Override
    public void eat() {
        System.out.println(this.name + "正在吃骨头");
    }
}

Bird类和Dog类重写了父类Animal中的eat方法

以上都是为多态来做准备的

多态：

什么是多态？

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

比如鸟和狗吃饭，鸟吃的是虫子，狗吃的是骨头

Java中怎么实多态呢? 这里就要用到上述的两种方法，向上转型和方法重写

在java中要实现多态，必须要满足如下几个条件，缺一不可：
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(this.name + "正在吃东西");
    }
}
class Bird extends Animal{
    //重写eat
    @Override
    public void eat() {
        System.out.println(this.name + "正在吃虫子");
    }
}
class Dog extends Animal{
    //重写eat
    @Override
    public void eat() {
        System.out.println(this.name + "正在吃骨头");
    }
}
public class Test {
    public static void func(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "二哈";
        Bird bird = new Bird();
        bird.name = "叽叽";
        func(dog);
        func(bird);
    }
}

 

多态体现：在代码运行时，当传递不同类对象给func时，animal会调用对应类中的方法。

这里还有一个疑问明明是animal调用的eat为啥不执行父类的eat呢？

之里面其实发生了动态绑定在编译的时候确实是调用的animal的eat但是在运行时animal这个引用的地址被改为了dog或cat这个引用的地址，发生了动态绑定，所以就执行了cat或dog的eat

再来看一个多态的实例：

画图形

class Shape{
    public void draw(){
        System.out.println("画一个图形");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个原圆");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}
class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个三角形");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Triangle triangle = new Triangle();
        Shape[] shapes = {cycle, cycle, rect,rect,triangle,triangle};
        for(Shape shape : shapes){
            shape.draw();
        }
    }
}

那多态的优点是什么呢？

拿上面代码举例

如果不用多态完成又能写成什么样子呢？

class Shape{
    public void draw(){
        System.out.println("画一个图形");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个原圆");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}
class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个三角形");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Triangle triangle = new Triangle();
        String[] strings = {"cycle","cycle", "react", "react","triangle","triangle"};
        for(String s : strings){
            if(s.equals(cycle)){
                cycle.draw();
            }else if(s.equals(rect)){
                rect.draw();
            }else{
                triangle.draw();
            }
        }
    }
}

在main函数中存在着大量的if else语句复杂度很高

所以多态的优点：

1. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else
什么叫 "圈复杂度" ?
圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.
因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度".如果一个方法的圈复杂度太高, 就需要考虑重构.

2. 可扩展能力更强
如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.（这里就不做展示了)

缺点：

多态缺陷：代码的运行效率降低。
1. 属性没有多态性
当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
2. 构造方法没有多态性

对于第二点缺点 看下面代码的输出结果是什么 num的值是多少

class A{
    public void func(){
        System.out.println("调用了A");
    }
    public A() {
        func();
    }
}
class B extends A{
    private int num = 1;

    @Override
    public void func() {
        System.out.println("调用了B  " + num);
    }
}
public class Test3 {
    public static void main(String[] args) {
        B b = new B();
    }
}

结果↓

结果为0 明明初始化为1了 为何输出的时0

其实：

构造 B 对象的同时, 会调用 A 的构造方法.
A 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 B 中的 func
此时 B 对象自身还没有构造, 此时 num 处在未初始化的状态，

所以：

尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触
发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.