java中的多态（学习笔记）

什么是多态

面向对象的三大特征：封装、继承、多态。
从一定角度看，封装和继承几乎都是为多态做准备的。这是最重要的知识点。
多态的定义：指允许不同类的对象对同一个消息作出响应。即同一消息可以根据调用不同对象而采用不同的行为方式。
实现多态的技术被称为：动态绑定，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态的作用：消除类型之间的耦合关系。

重点注意：
多态存在的三个必要条件：

1. 要有继承；
2. 要有重写；
3. 父类引用指向子类对象。

java中多态实现的方式：

• 接口实现
• 继承父类进行方法重写
• 同一个类中进行方法重载

一个简单例子：

package com.flz.polymorphic;

public class Quadrangle
{
    //实例化保存四边形对象的数组
    Quadrangle qtest[]= new Quadrangle[6];
    private int nextindex=0;
    public void draw(Quadrangle q)
    {
        if(nextindex<qtest.length)
        {
            qtest[nextindex]=q;
            System.out.println(nextindex);
            nextindex++;
        }
    }
    public static void main(String[] args)
    {
        Quadrangle quadrangle=new Quadrangle();
        quadrangle.draw(new Square());//Square向上转型为Quadrangle
        quadrangle.draw(new Parallelogramgle());//Parallelogramgle向上转型为Quadrangle
    }
}

class Square extends Quadrangle
{

    public Square()
    {
        System.out.println("正方形");
    }

}

class Parallelogramgle extends Quadrangle
{

    public Parallelogramgle()
    {
        System.out.println("平行四边形");
    }

}

运行结果：

正方形
0
平行四边形
1

（备注：以上只是结合网上信息的初步理解，有待完善……）

重要发现：
一个小题目：
（一）相关类

class A ...{  
         public String show(D obj)...{  
                return ("A and D");  
         }   
         public String show(A obj)...{  
                return ("A and A");  
         }   
}   
class B extends A...{  
         public String show(B obj)...{  
                return ("B and B");  
         }  
         public String show(A obj)...{  
                return ("B and A");  
         }   
}  
class C extends B...{}   
class D extends B...{}  

（二）问题：以下输出结果是什么？

A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();   
        System.out.println(a1.show(b));   ①  
        System.out.println(a1.show(c));   ②  
        System.out.println(a1.show(d));   ③  
        System.out.println(a2.show(b));   ④  
        System.out.println(a2.show(c));   ⑤  
        System.out.println(a2.show(d));   ⑥  
        System.out.println(b.show(b));    ⑦  
        System.out.println(b.show(c));    ⑧  
        System.out.println(b.show(d));    ⑨     

（三）答案

①   A and A
②   A and A
③   A and D
④   B and A
⑤   B and A
⑥   A and D
⑦   B and B
⑧   B and B
⑨   A and D

解释：

1.实例对象为A，参数为对象B，B为A的子类。执行A.class中show(A obj)
2.同上
3.实例对象为A，参数为对象D，执行A.class中show(D obj)
4.实例对象依然为A，参数为B，本应执行A.class中show(A obj)，但是，B.class重写了show(A obj),所以执行B.class show(A obj)
5.同上
6.执行A.class show(D obj) B中并没有重写。
7，8.实例对象为B，参数为B或者B的子类，执行show(B obj)
9.实例对象为B，参数为D，因为B继承自A，也可以执行A中的show(D obj)

（上面的题目引自其他博客，这段解释能很好的帮助理解多态o(≧v≦)o~~好棒）