多态，意味着一个对象有着多重特征，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。从程序设计的角度而言，多态可以这样来实现
　public interface Parent {
　　public void simpleCall();
　　}
　　public class Child_A implements Parent{
　　public void simpleCall(){
　　//具体的实现细节；
　　}
　　}
　　public class Child_B implements Parent{
　　public void simpleCall(){
　　//具体的实现细节；
　　}
　　}
　
      Parent pa = new Child_A();
　　pa.simpleCall()则显然是调用Child_A的方法；
　　Parent pa = new Child_B();
　　pa.simpleCall()则是在调用Child_B的方法。所以，我们对于抽象的父类或者接口给出了我们的具体实现后，pa 可以完全不用管实现的细节，只访问我们定义的方法，就可以了。

多态都表现形式有几种？我只知道重载和重写，还有什么情况是多态呢？能不能举例子说下 多谢了！

可以看看视频！！

根据我对视频的研究与学习，只有这么两种，重写跟重载。

java语言中好像只提供了两种多态机制：重载和重写，在API文档中有很多重载的方法

对，方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写
Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性
的一种表现。

什么是多态
多态字面上的意思就是多种形态。在面向对象语言中，我们可以将函数的形参定义为一个父类类型，而在真正调用该函数时这个父类类型的所有子类对象都可以传入，根据传入的子类对象不同函数可以运行处多种形态。
多态的特点
应用程序不必为每一个子类编写功能调用，只需要对父类进行处理即可。这一招叫“以不变应万变”，可以大大提高程序的可复用性。
子类的功能可以被父类的变量调用，这叫向后兼容，可以提高程序的可扩充性和可维护性。现在写的程序可以调用将来写的程序不足为奇 。
多态：可以理解为事物存在的多种体现形态。

1，多态的体现:
  父类的引用指向了自己的子类对象。
  父类的引用也可以接收自己的子类对象。
2，多态的前提:
  必须是类与类之间有关系。要么继承，要么实现。
  通常还有一个前提：存在覆盖。
3，多态的好处:
  多态的出现大大的提高程序的扩展性。
4，多态的弊端:
  虽然提高了扩展性，
  但是只能使用父类的引用访问父类中的成员。
5，多态的应用
6，多态的出现代码中的特点(多态使用的注意事项)

/*
多态：可以理解为事物存在的多种体现形态。

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

1，多态的体现
        父类的引用指向了自己的子类对象。
        父类的引用也可以接收自己的子类对象。
2，多态的前提
        必须是类与类之间有关系。要么继承，要么实现。
        通常还有一个前提：存在覆盖。

3，多态的好处
        多态的出现大大的提高程序的扩展性。

4，多态的弊端：
        虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)




第二个问题：如何使用子类特有方法。
*/

/*
动物，
猫，狗。
*/

class Cat extends Animal
{
        public void eat()
        {
                System.out.println("吃鱼");
        }
        public void catchMouse()
        {
                System.out.println("抓老鼠");
        }
}


class Dog extends Animal
{
        public void eat()
        {
                System.out.println("吃骨头");
        }
        public void kanJia()
        {
                System.out.println("看家");
        }
}


class Pig extends Animal
{
        public void eat()
        {
                System.out.println("饲料");
        }
        public void gongDi()
        {
                System.out.println("拱地");
        }
}

//-----------------------------------------


class DuoTaiDemo2
{
        public static void main(String[] args)
        {
                //Animal a = new Cat();//类型提升。 向上转型。
                //a.eat();

                //如果想要调用猫的特有方法时，如何操作？
                //强制将父类的引用。转成子类类型。向下转型。
                ///Cat c = (Cat)a;
                //c.catchMouse();
                //千万不要出现这样的操作，就是将父类对象转成子类类型。
                //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。
                //多态自始至终都是子类对象在做着变化。
//                Animal a = new Animal();
//                Cat c = (Cat)a;
               

                /*
                毕姥爷 x = new 毕老师();

                x.讲课();

                毕老师 y = (毕老师)x;


                y.看电影();
                */
                function(new Dog());
                function(new Cat());


        }
        public static void function(Animal a)//Animal a = new Cat();
        {
                a.eat();
                /*
                if(a instanceof Animal)
                {
                        System.out.println("haha");
                }
                else
                */
                if(a instanceof Cat)
                {
                        Cat c = (Cat)a;
                        c.catchMouse();
                }
                else if(a instanceof Dog)
                {
                        Dog c = (Dog)a;
                        c.kanJia();
                }


                /*
                instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)  
                */
       
        }