Java—多态

多态：同一个符号在不同语义环境下具有不同的解释

一、多态是通过

      1、接口和实现接口并覆盖接口中同一个方法的几种不同的类体现的。

    2、父类和继承父类并覆盖父类中同一方法的几个不同子类实现的。

二、基本概念

       多态性：发送消息给某个对象，让该对象自己决定响应何种行为。通过将子类对象引用赋值给超类对象引用变                       量来实现动态方法调用。

        java的这种机制遵循一个原则：当超类对象引用子类对象时，被引用对象的类型而不是引用变量的类型决定了                      调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

      1、如果a是类A的一个引用，那么a可以指向类A的一个实例，或者说指向类A的一个子类。

      2、如果a是接口A的一个引用，那么a必须指向实现了接口A的一个类的实例。

例如：父亲person有行为这个方法，里面包括几个动作：吃饭，睡觉，走路 父亲有三个儿子，三个儿子都继承了               父亲的行为方法，所以三个儿子都有吃饭，睡觉，走路这些动作，但是三个儿子又分别有自己的动作--大               儿子A会弹吉他，二儿子B会唱歌，三儿子C会打鼓 ...

1、Person person = new A(); 不是父类对象指向子类引用而是父类引用指向子类对象

2、这个对象不能调用子类A特有的弹吉他方法--person.guitar(); X

3、如果仅是这么写程序，还不是多态，记住实现多态的三要素：继承 重写 父类引用指向子类对象

4、之后，如果你调用persion.guitar()，此时在代码的编译阶段，persion调用的仍然是自己的guitar()，不是儿子         的。而当程序运行时，就是java XXX, persion调用的却是儿子的guitar()。这个动态的过程才是多态

1. Person person;  
2.            //父类的引用指向子类的方法；  
3.            person = new Student();  
4.            //person类型引用做一个判断  
5.            //(1)if（person.eat().size==2 )  
6.           {  
7.            if(person instanceof Person)  
8.            {          
9.        person.eat();  
10.            }else if(person instanceof Student)             {  
11.                Student stu = (Student)person;  
12.                stu.eat();  
13.            }             
14.            person.eat();//从代码角度看，此时是父类的引用调用的是父类中的eat方法  
15.            //(2)子类若覆盖了父类的方法，eat动态绑定到父类的引用Person上，换个名字叫动态绑定  
16.            //父类的引用可以调用子类的方法，我们把这一现象成为多态  
17.            //从字面意思来理解person这个父类的引用一会是person一会是student  
18.            //person有多种状态；  
19.            //也叫方法的动态绑定  
20.            //继承是通向多态的入口  
21.            person.f2();  
22.            person.gotobed();  
23.            person.eat();  
24.            Student stu = new Student();  
25.            stu.eat();  
26.            stu.gotobed();  
27.            //父类的引用能够调用子类的方法  
28.     

三、多态的分类

    1、向上转型

               子类自有的方法不可见

             1）、代码检查不允许。

             2）、从实际意义上

1. A a = new B();  
2. a.f();     //调用子类的f()方法  
3. a.f(new Two());    //编译错误(定义一个A类引用，JVM解释a.f(new Two())方法时，A类没有这个方法)

    2、向下转型

    存在于继承中，父类引用指向的对象实际是要转型的子类引用的类型。

1. 1)  Animal a = new Dog();  
2.   
3.       Dog d = (Dog) a;    //正确  
4.   
5. 2) Animal a = new Cat();  
6.   
7.       Dog d = (Dog) a;    //异常    

Java中，父类的引用既可以指向父类的对象，也可以指向子类的对象。但子类的引用不能指向父类的对象。

引用类型也可以进行类型转换。

但转换的类型一定具有继承关系，即仅允许父子类之间进行转换。

如果尝试将毫无关联的两个类型进行转换，将会引发编译错误。可以使用instanceof来判断引用是否为指定的类型。

四、对象的多态性：动物 x = new 猫(); 

        函数的多态性：函数重载、重写 

    1、多态的体现 

        父类的引用指向了自己的子类对象 

        父类的引用也可以接收自己的对象 

    2、多态的前提 

        必须是类与类之间只有关系，要么继承或实现 

        通常还有一个前提，存在覆盖 

    3、多态的好处 

         多态的出现大大的提高了程序的扩展性 

    4、多态的弊端 

         只能使用父类的引用访问父类的成员