Java之旅_面向对象_多态

参考并摘自：http://www.runoob.com/java/java-polymorphism.html

多态

多态是一个行为具有多个不同表现形式的能力。

多态就是同一个接口，使用不同的实例而执行不同的操作。

多态存在的三个必要条件：

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

如Parent a = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

多态实例：

abstract class Animal{
    abstract void eat();
}
class Cat extends Animal{
    public void eat(){
        System.out.println("eat fish");
    }
    public void work(){
        System.out.println("catch mouse");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("eat bone");
    }
    public void work(){
        System.out.println("watch home");
    }
}
public class Test{
    public static void main(String[] args){
        show(new Cat());  //以cat对象调用show方法
        show(new Dog());  //以dog对象调用show方法
        Animal a = new Cat(); //向上转型
        a.eat();
        Cat c = (Cat)a; //向下转型
        c.work();
    }
    public static void show(Animal a){
        a.eat();
　　　　//类型判断
        if(a instanceof Cat){
            Cat c = (Cat)a;
            c.work();
        }else if(a instanceof Dog){
            Dog c = (Dog)a;
            c.work();
        }
    }
}

//运行结果
eat fish
catch mouse
eat bone
watch home
eat fish
catch mouse

 虚方法：

class Animal{
    public Animal(int a){
        System.out.println("superclass...");
    }
    public void eat(){
        System.out.println("superclass test....");
    }
    public void eat2(){
        System.out.println("superclass eat2...");
    }
    public void doeat(){
        //空方法，实际运行子类方法
    }
}
class Cat extends Animal{
    public Cat(){
        super(100);//父类构造器带参数时，子类构造器中必须通过super调用父类构造器并配参数。
        System.out.println("subclass..");
    }
    public void eat2(){
        System.out.println("subclass eat2...");
    }
    public void doeat(){
        eat(); //父类有，子类没有，子类直接调用
        eat2(); //父类有，子类重写，调用子类方法直接调用
        this.eat2();//同上
        super.eat2();//父类有，子类重写，调用父类方法用super
    }    
}
public class Test{
    public static void main(String[] args){
        Animal a = new Cat(); //父类引用指向子类对象
        a.doeat();
    }
}

//运行结果：
superclass...

subclass..
superclass test....
subclass eat2...
subclass eat2...
superclass eat2...

编译的时候，编译器使用父类中的方法验证，运行时使用子类方法执行，该过程称为虚拟方法调用，该方法称为虚拟方法。

java中所有方法都能以这种方式表现，因此重写的方法能在运行时调用，不管编译时源代码中引用变量是什么数据类型。

多态的实现方式：

方式一：重写

方式二：接口

方式三：抽象类和抽象方法