多态的思想 : 一个引用, 引用的对象不一样,那么所表现的行为不一样,这种思想称为多态.

 换句话说 : 当父类引用 引用的对象不一样的时候 表现出的行为是不一样的!!!!

通过一个例子,我们先来感受一下 :  定义两个类 Animal 和 Cat ,   在Cat类中重写了Animal的fun()方法, 在main方法中 new 了一个 Cat 对象,并用Animal类的引用接收.

class Animal {
    public int age;
    public String name;

    public void fun () {
        System.out.println("Animal 的 fun()方法");
    }
}

class Cat extends Animal{
    @Override
    public void fun() {
        System.out.println("Cat 的 fun() 方法");
    }
    public void eat () {
        System.out.println("吃猫粮!!");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.fun();
    }
}

运行结果 : 

可以看到 : 最后输出的是Cat的fun方法. 这就是多态.

多态的实现条件 :  

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

1.必须在继承的关系下.

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

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

现在我们回头再看一下下面这句代码 :  

Animal animal = new Cat();

在这句代码中发生了向上转型.

向上转型 : new 子类 给到 父类引用

那它为什么会调用子类重写后的方法呢 ?

在发生向上转型之后 : 在运行阶段会发生动态绑定.(运行的时候,帮我们调用了重写的方法)

大家可以这样理解 : 当发生向上转型之后,并且去通过引用去调用方法时,如果子类中重写了这个方法,那么编译器就会去调用子类重写后的方法.这就是动态绑定.

总结 : 要发生动态绑定的要求 : 

1.向上转型

2.重写

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

强调 : 发生向上转型之后,父类的引用只能访问父类自己的成员/方法.不能访问到子类特有的成员和方法.例如 :

 

在父类中并没有这个eat方法,所以就会报错.

在这里在重申一下重写需要注意的点 : 

1.private修饰的方法不能重写.

 

2.static修饰的方法时不能重写的.

 

 

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

修饰权限符 : private < default (默认) < protected < public

4.被final修饰的方法 是不能重写的 此时这个方法 被称做 密封方法.

总结 : 重写是子类对父类的非静态,非private修饰,非final修饰,非构造方法的方法的实现.

既然有向上转型 那么就有 向下转型.

向上转型之后,我们就不能通过父类引用去调用子类特有的成员跟方法了.故我们就要实现向下转型

public class Test {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.fun();
        Cat cat = (Cat)animal;
        cat.eat();
    }
}

运行结果 : 

 但是向下转型这样写的话,它是有缺点的. 我们再定义一个Dog类 .更改一下main方法:

class Animal {
    public int age;
    public String name;
    public void fun () {
        System.out.println("Animal 的 fun()方法");
    }
}

class Cat extends Animal{
    @Override
     public void fun() {
        System.out.println("Cat 的 fun() 方法");
    }
    public void eat () {
        System.out.println("吃猫粮!!");
    }
}
class Dog extends Animal{
    @Override
    public void fun() {
        System.out.println("Dog 的 fun() 方法");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.fun();
        Cat cat = (Cat)animal;
        cat.eat();
    }
}

 运行结果 : 

 结果就会报错了,类型转换错误!!

为了避免这种错误!我们需要再加一个判断语句. animal instanceof  Dog  可以翻译成 : animal是不是引用了Dog对象 或者是 animal是不是Dog类的子类.

class Animal {
    public int age;
    public String name;
    public void fun () {
        System.out.println("Animal 的 fun()方法");
    }
}

class Cat extends Animal{
    @Override
     public void fun() {
        System.out.println("Cat 的 fun() 方法");
    }
    public void eat () {
        System.out.println("吃猫粮!!");
    }
}
class Dog extends Animal{
    @Override
    public void fun() {
        System.out.println("Dog 的 fun() 方法");
    }
    public void swing () {
        System.out.println("小狗在游泳 !!");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.fun();
        if (animal instanceof Cat) {
            Cat cat = (Cat)animal;
            cat.eat();
        } else if (animal instanceof Dog) {
            ((Dog) animal).swing();
        }
    }
}

希望能帮到大家~~~~~~~~~~~~