多态–概念
所谓多态。就是指一个引用(类型)在不同情况下的多种状态。

也能够理解成：多态是指通过指向父类的指针，来调用在不同子类中实现的方法。

实现多态有两种方式：1、继承。2、接口

这一次我们先来演示一下：
继承、方法覆盖、多态以及向上转型的内容

package polimorphic;

public class Polimorphic {
    public static void main(String[] args) {
        //非多态演示
        System.out.println("非多态演示:");
        Cat cat=new Cat();
        cat.cry();
        //cat=new Dog();                //类型不匹配
        Dog dog=new Dog();
        dog.cry();
        dog.bite();
        System.out.println();       
        //多态演示
        System.out.println("多态演示:");
        Animal an=new Cat();
        an.cry();
        an=new Dog();
        an.cry();
        //an.bite();                    // an虽指向子类对象，但此时丢失bite()方法
        System.out.println();   
        //多重多态演示
        System.out.println("多重多态演示:");
        Master master=new Master();
        master.feed(new Dog(),new Bone());
        master.feed(new Cat(),new Fish());
    }
}
//主人类
class Master{
    //给动物喂食物，使用多态，仅仅要写一个方法
    public void feed(Animal an,Food f){
        an.eat();
        f.showName();
    }
}
//食物父类
class Food{
    String name;
    public void showName(){
        System.out.println("食物");
    }
}
//食物鱼子类
class Fish extends Food{
    public void showName(){                     //覆盖父类方法
        System.out.println("鱼");
    }
}
//食物骨头子类
class Bone extends Food{
    public void showName(){                     //覆盖父类方法
        System.out.println("骨头");
    }
}
//动物类Animal父类
class Animal{
    String name;
    int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //动物会叫
    public void cry(){
        System.out.println("不知道怎么叫");
    }
    //动物吃东西
    public void eat(){
        System.out.println("不知道吃什么");
    }
}
//创建Dog子类并extends继承Animal父类及覆盖cry方法
class Dog extends Animal{
    //狗叫
    public void cry(){                         //覆盖父类方法
        System.out.println("汪汪叫");
    }
    //狗吃东西
    public void eat(){                          //覆盖父类方法
        System.out.println("狗爱吃骨头");        
    }
    public void bite(){

        System.out.println("狗会咬人...");
    }
}
class Cat extends Animal{
    //猫自己叫
    public void cry(){                           //覆盖父类方法
        System.out.println("猫猫叫");
    }
    //猫吃东西
    public void eat(){                           //覆盖父类方法
        System.out.println("猫爱吃鱼");
    }
}

结果截图

多态–注意事项：
1、java同意父类的引用变量引用它的子类的实例(对象)
Animal an=new Cat();//这样的转换时自己主动完毕的.

转型是在继承的基础上而言的，继承是面向对象语言中，代码复用的一种机制，通过继承，子类能够复用父类的功能，假设父类不能满足当前子类的需求，则子类能够重写父类中的方法来加以扩展。

向上转型：子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象能够是接口

Animal dog 引用指向new Dog();子类对象当成父类对象，仅仅能调用父类的成员。假设子类重写了父类的方法就依据这个引用指向调用子类重写的这种方法（这种方法就是覆盖override）。这个调用过程就称为“动态绑定”。

转型须要注意的问题：

向上转型时，父类指向子类引用对象会遗失除与父类对象共同拥有的其它方法，也就是在转型过程中，子类的新有的方法都会遗失掉。在编译时，系统会提供找不到方法的错误。
比方：上述代码的

//an.bite();                    // an虽指向子类对象。但此时丢失bite()方法

关于类型转换另一些详细的细节要求，我们在后面还要提，比方子类能不能转换成父类，有什么要求等等…
向下转型的问题我们下一节探讨。