多态

——父类或者接口的引用指向自己的子类对象。

优点：提高代码的扩展性

弊端：前期建立父类的引用，虽然可以接受后期所有该类的子类的对象。但是只能使用父类中的功能，不能使用子类特有的功能，因为前期的程序无法知道后期的子类的特有内容的。但是前期的程序可以使用子类覆盖了父类的方法的内容。

前提：

1. 必须存在着继承关系。

2. 通常使用覆盖操作

例子：

package com.dragon.src;

/**

* 抽象类

* @author DRAGON

*

*/

abstract class Animal

{

abstract void eat();

}

class Dog extends Animal

{

@Override

void eat() {

System.out.println("小狗在吃饭");

}

public void Home(){

System.out.println("小狗在看门");

}

}

class Cat extends Animal{

@Override

void eat() {

System.out.println("小猫在吃鱼");

}

public void catchMouse(){

System.out.println("小猫在捉老鼠");

}

}

class Pig extends Animal{

@Override

void eat() {

System.out.println("猪在吃饲料");

}

public void gongDi() {

System.out.println("猪拱地");

}

}

public class DuotaiDemo {

/**

* @param args

*/

public static void main(String[] args) {

Dog dog = new Dog();

//dog.eat();

Cat cat = new Cat();

//cat.eat();

Pig pig = new Pig();

//使用多态性，都属于animal

eatmethod(dog);

eatmethod(cat);

eatmethod(pig);

/***********向上转型*************/

//父类应用指向子类的对象

//animal引用可以指向任意的子类型的对象

//但animal引用只能调用Animal中的方法

Animal animal = new Dog();//

//好处：提高了扩展性

//局限：只能使用父类中的方法

//这种提升可以限制对子类对象的操作

/***********向上转型*************/

Dog dog2 = (Dog)animal;//变成子类

//优点：可以使用子类的特有方法

//弊端：如果类型转换错误，会出现运行异常

//应用情景：

//当需要对程序进行扩展，或者限定对对象的方法时，可以使用向上转型，操作其父类型

//当要使用子类的特有的内容是，就需要向下转型，转型前一定要判断，否则内容容易出现异常

//注意：在整个转型过程中，自始至终都是一个子类对象在做类型的变化而已，千万别把父类对象转成子类型，这是不可能的

}

//共性功能

public static void eatmethod(Animal animal){

animal.eat();

}

//转型判断

public static void method(Animal animal) {

//向下转型前的健壮性进行类型判断

if(animal instanceof Cat){

Cat cat = (Cat)animal;

cat.catchMouse();

}else if(animal instanceof Dog){

Dog dog = (Dog)animal;

dog.Home();

}else if(animal instanceof Pig){

Pig pig = (Pig)animal;

pig.gongDi();

}

}

}

应用情景：

//当需要对程序进行扩展，或者限定对对象的方法时，可以使用向上转型，操作其父类型

//当要使用子类的特有的内容是，就需要向下转型，转型前一定要判断，否则内容容易出现异常

//注意：在整个转型过程中，自始至终都是一个子类对象在做类型的变化而已，千万别把父类对象转成子类型，这是不可能的

原理：在同一块堆内存块中，不同的引用对方法产生了不同的作用。

多态的出现在成员调用上的特点：

1．成员变量

编译时期：参考的是引用型变量所属的类中是否有调用的成员变量，如果有，编译通过，如果没有编译失败。

运行时期：调用的也是引用型变量所属类中的成员变量。

简单说：编译和运行都看等号的左边。

2．成员函数。

编译时期：参考的是引用型变量所属的类中是否有调用的方法。有，编译通过，没有编译失败。

运行时期：参考的是对象所属的类中是否有调用的方法，如果有运行子类自己的方法，如果没有就父类的方法。

简答说：编译时期看左边，运行时期看右边。因为函数有一个覆盖的特性。

非静态方法需要和当期运行的对象进行动态绑定，哪个对象调用了这个方法，这个方法就所属于哪个对象。就会运行哪个对象的中的方法。

3，静态函数。

编译时期：参考的是引用型变量所属的类中是否该方法。

运行时期：参考的也是引用型变量所属的类中的方法。

简单说：编译和运行都看左边。

因为静态方法是不所属于对象的，是所属于类的，

它会类加载的时候，静态的绑定到所属的类上。