多态的概述
/*
class 动物
class 猫 extends 动物
class 狗 extends 动物
猫 x=new 猫();
动物 x=new 猫();一个对象，两种形态。
猫这类动物即具备这猫的形态，又具备着动物的形态。这就是对象的多态性。
简单说，就是一个对象对应着不同类型，
多态在代码中的体现，父类或者接口的引用指向其子类的对象。多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。
多态的弊端，前期定义的内容不能调用后期子类的特有内容。
多态的前提，必须有继承，实现关系；必须有覆盖方法
*/
abstract class Animal
{
        abstract void eat();
}
class Dogs extends Animal
{
        void eat(){
                System.out.println("啃骨头");
        }
        void lookHome(){
                System.out.println("看家");
        }
}
class Cat extends Animal
{
        void eat(){
                System.out.println("吃鱼");
        }
        void catchMouse(){
                System.out.println("抓老鼠");
        }
}
class DuotaiDemo
{
        public static void main(String[] args){
                Cat c=new Cat();
                c.eat();
                c.catchMouse();
                Animal a=new Cat();
                //自动类型提升，猫对象提升了动物类型，但是特有功能无法访问。多态自动类型提升作用就是限制对特有功能的访问。专业讲，向上转型，将子类型隐藏。就不用使用子类的特有方法。
                a.eat();
                //如果还想用具体动物猫的特有功能，你可以将该对象进行向下转型。
                Cat c=(Cat)a;
                c.eat();
                c.catchMouse();
                //注意，对于转型，自始自终都是子类对象在做着类型的变化。
        }
        //！这个方法是多态的应用，当类之间出现的继承,实现关系，在调用其子类方法时应该使用这种多态的方法。通过instanceof来判断子类，然后使用向下转型使用子类特有方法。
        public static void method(Animal a){
                a.eat();
                if (a instanceof Cat){
                //instanceof用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性的判断。
                        Cat c=(Car)a;
                        c.catchMouse();
                }else if (a instanceof Dog){
                        Dog d=(Dog)a;
                        d.lookHome();
                }
        }
}
接口的概述
/*
笔记本电脑的使用，为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规则就可以了。规则在java中就是接口。
*/
interface USB//暴露的规则
{
        public void open();
        public void close();
}
class BookPC
{
        public static void main(String[] args){
                useUSB(new Upan());//功能扩展了
                useUSB(new UsbMouse());
        }
        public static void useUSB(USB u){
        //接口类型的引用，用于接收(指向)接口的子类对象
                if (u!=null){
                        u.open();
                        u.close();
                }
        }
}
/*
一年后，实现设备，这些设备和电脑的耦合性降低了。
*/
class Upan implements Usn
{
        public void open(){
                System.out.println("upan open");
        }
        public void close(){
                System.out.println("upan close");
        }
}
class UsbMouse implements USB
{
        public void open(){
                System.out.println("Usbmouse open");
        }
        public void close(){
                System.out.println("UsbMouse close");
        }
}
/*
多态时，多态成员的特点：
成员变量，编译时，参考引用类型变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时，参考引用型变量所属的类中哪个是否有调用的成员变量，并运行该所属类中的成员变量。
简单说，编译和运行都参考等号的左边。成员变量只运行父类。
成员函数(非静态)
编译时，参考引用型变量所属的类中是否有调用的函数。有，编译通过，没有编译失败。
运行时，参考的是对象所属的类中是否有调用的函数。
简单说，编译看左边，运行看右边。因为多态是需要方法覆盖的。所以方法在编译时看父类中的方法是否可以覆盖，运行时，运行子类中的方法。因为成员函数存在覆盖特性。
静态函数
编译时，参考引用型变量所属的类中是否有调用的静态方法。
运行时，参考引用型变量所属的类中是否有调用的静态方法。
简单说，编译和运行都看左边。
其实对于静态方法，是不需要对象的，直接类名调用即可。
静态函数运行父类的。直接随着类的加载而加载，父类优先于子类加载。
*/
class Fu
{
        int num=3;
        void show(){
                System.out.println("fu show");
        }
        static void method(){
                System.out.println("fu static method");
        }
}
class Zi extends Fu
{
        int num=4;
        void show(){
                System.out.println("zi show");
        }
        static void method(){
                System.out.println("zi static method");
        }
}
class DuotaiDemo
{
        public static void main(String[] args){
                Fu.method();//静态直接用类名调用fu static method
                Zi.method();//zi static method
                Fu f=new Zi();
                f.method(); //fu static method
                f.show(); //zi show
                System.out.println(f.num); //5
                Zi z=new Zi();
                System.out.println(z.num); //4
        }
}

总结的相当不错啊

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。多态有两种表现形式：重载和覆盖。首先说重载（overload），是发生在同一类中。与什么父类子类、继承毫无关系。 标识一个函数除了函数名外，还有函数的参数（个数和类型）。也就是说，一个类中可以有两个或更多的函数，叫同一个名字而他们的参数不同。 他们之间毫无关系，是不同的函数，只是可能他们的功能类似，所以才命名一样，增加可读性，仅此而已！ 再说覆盖(override),是发生在子类中！也就是说必须有继承的情况下才有覆盖发生。我们知道继承一个类，也就有了父类了全部方法，如果你感到哪个方法不爽，功能要变，那就把那个函数在子类中重新实现一遍。  这样再调用这个方法的时候，就是执行子类中的过程了。父类中的函数就被覆盖了。（当然，覆盖的时候函数名和参数要和父类中完全一样,不然你的方法对父类中的方法就不起任何作用，因为两者是两个函数，毫不关系）

这个太长了。。总结不应该是通俗易懂吗，。。