面向对象程序三大特性一：多态（超详细）

（1）被重写的方法返回值类型可以不同 ， ++但是必须是具有父子关系的++
(2) ++访问权限不能比父类中被重写的方法的访问权限更低++ 。例如：如果父类方法被 public 修饰，则子类中重写该方法就不能声明为 protected
(3) ++父类被static、final和private修饰的方法、构造方法都不能被重写。++

1.3重写与重载的区别

重写和重载就体现多态

静态绑定：也称为前期绑定(早绑定)，++即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。++典型代表函数重载。
动态绑定 ：也称为后期绑定 ( 晚绑定 ) ，++即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。++
动态绑定的图解：（图1-1）

（图1-1）

2.向上转型

2.1简单介绍

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

具体代码在代码（2-1）

向上转型的形式

(1)直接赋值

Animal animal = new Cat("元宝",2);

(2)方法传参

++就是传参时进行 向上转型++

(3)方法返回

同理：++就是返回时进行 向上转型++

2.3向上转型的作用

我们按向上转型 的语法写完代码具体能做些什么？

（1）调用父类特有的方法

（2）仅调用被子类重写的方法
看代码（2-1）

java 复制代码

public 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+"吃点啥");
    }
    public void Father(){
        System.out.println("我是父类");
    }
}

java 复制代码

public class Dog extends Animal{

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

    @Override
    public void eat() {
        System.out.println(name+"吃狗粮");
    }

    public void cry(){
        System.out.println("狗叫");
    }
}

java 复制代码

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

    @Override
    public void eat() {
        System.out.println(name+"吃猫粮");
    }
    public void cry(){
        System.out.println("猫叫");
    }
}

java 复制代码

public class Text {
    public static void fun(Animal a){
        a.eat();
    }

    public static void main(String[] args) {
      Animal animal1=new Dog("圆圆",19);
      Animal animal2=new Cat("方方",17);
      animal1.Father();
      fun(animal1);
      fun(animal2);
    }
}

运行结果：

（1）调用父类特有的方法

无法调用子类特有方法

（2）仅调用被子类重写的方法

问：如果想调用子类特有方法，怎么办？

3.向下转型

3.1介绍

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
++Animal,Dog的代码请看代码（2-1）++

java 复制代码

class Text2{
    public static void main(String[] args) {
        Animal a1=new Dog("haha",8);
        if(a1 instanceof Dog){
            Dog dog=(Dog) a1;
            dog.cry();
        }
    }
}

运行结果：

3.2instanceof 基本介绍

语法为：

引用类型变量(object) instanceof 类(class)

功能：

判断前面的对象是否属于后面的类，或者属于其子类；

如果是，返回 true ，不是返回 false；

instanceof 前面的引用变量编译时的类型要么与后面的类型相同，要么与后面的类型具有父子继承关系

4.多态

4.1多态实现条件

必须在继承体系下
2 . 子类必须要对父类中方法进行重写
3 . 通过父类的引用调用重写的方法
缺一不可（上面 ++代码（2-1）++ 其实已经使用了多态）
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法
我们再看一个新例子
例子：

java 复制代码

public 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 Text2{
    public static void main(String[] args) {
        Shape shape[]={new Cycle(),new Rect(),new Flower()};
        for(Shape shape1:shape){
            shape1.draw();
        }
    }
}

运行结果：

多态缺陷：

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

构造方法没有多态性

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

我们创建两个类 , B 是父类 , D 是子类 . D 中重写 func 方法 . 并且在 B 的构造方法中调用 func

java 复制代码

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);
}
}
public class Test {
public static void main(String[] args) {
D d = new D();
}
}

执行结果
D . func () 0
解释：

（1）构造 D 对象的同时 , 会调用 B 的构造方法
（2）B 的构造方法中调用了 func 方法 , 此时会触发动态绑定 , 会调用到 D 中的 func
（3）此时 D 对象自身还没有构造 , 此时 num 处在未初始化的状态 , 值为 0
结论 : " 用尽量简单的方式使对象进入可工作状态 ", 尽量不要在构造器中调用方法 ( 如果这个方法被子类重写 , 就会触发动态绑定, 但是此时子类对象还没构造完成 ), 可能会出现一些隐藏的但是又极难发现的问题

以上为我个人的小分享，如有问题，欢迎讨论！！！

都看到这了，不如关注一下，给个免费的赞

面向对象程序三大特性一：多态（超详细）

1.重写

1.1基本语法规则

1.2规则深化

1.3重写与重载的区别

2.向上转型

2.1简单介绍

2.3向上转型的作用

3.向下转型

3.1介绍

3.2instanceof 基本介绍

4.多态

4.1****多态实现条件

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

4.1多态实现条件