本人多java的多态不理解希望详细的解释下

多态性：有继续之后才出现的特性。多态中。始终变化的是子类。。这一点是要特别注意的。
其通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，
但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

毕老师视频里的笔记，给你参考下。
一。表现：
父类或者接口的引用指向了或者接收了自己的子类对象。

二。前提：
1，类与类之间要有关系。继承，实现。
2，通常都会有覆盖。

三。好处：
预先定义的程序可以运行后期程序的内容。
增强了程序的扩展性。

四。弊端：
虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
不能预先使用子类中定义的特有功能。

五。多态的注意事项：
在代码中。
对于成员函数：Fu f = new Zi(); f.method();
编译时期：看左边。
运行时期：看右边。

基本概念

多态性：发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。

2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。

谢谢啊多态在实际 应用中有什么好处

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

为什么会出现多态？
Java中的引用变量有两个类型，一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时的类型与运行时的类型不一致就会出现所谓的多态。（Polymorphism)
例题如下：
现实生活中也有多态的原型：例如一个父亲F有两个孩子S1和S2，而父亲又可以代表孩子做一些事情，即F即可以代表S1也可以代表S2，因此F具有一定的多态性。在Java中多态大多是指对象变量的多态，即一个F类型的变量既可以指向F类型的对象也可以指向S1、S2类型的对象。（F与S1、S2之间需要存在继承关系）

一、多态
                 同一个对象，在不同时刻的多种运行状态。
           1、举例：
                                动物，狗   狗是狗，狗是动物。
                                水(气体，液态，固定)
            2、前提
                (1) 存在着继承或者实现关系
                (2) 有方法的重写
                (3) 父类(接口)引用指向子类(实现)对象
            3、不同形式形式模拟多态
                (1) 普通类
                (2) 抽象类
                (3) 接口
            4、多态中对象调用成员的特点
                  Fu f = new Zi();
                 (1) 成员变量：编译看左边，运行看左边
                 (2) 成员方法：编译看左边，运行看右边
                 (3) 静态方法：编译看左边，运行看左边
            5、多态的思想
                        指挥同一批对象做事情。

                举例：带兵打仗，下课等。
            6、向上转型和向下转型
                        Animal a = new Dog();  //向上转型
                  //使用Dog中特有的方法
                        Dog d = (Dog) a;  //向下转型

           //注意：不能转换成不同类型的
                        Cat c = (Cat)a;
            7、instanceof关键字
                 (1) 用于判断某个对象是否是某种引用类型的。
                 (2) 格式
                             对象名 instanceof 子类(实现)名

潘天功 发表于 2012-11-25 17:29
一、多态
                 同一个对象，在不同时刻的多种运行状态。
           1、举例：

你何不把代码写出来那

罗忠文 发表于 2012-11-25 17:46
你何不把代码写出来那

用普通的类继承模拟多态。
*/
class Animal
{
        public void eat()
        {
                System.out.println("动物吃");
        }
}

class Dog extends Animal
{
        public void eat()
        {
                System.out.println("狗吃肉");
        }
}

class Cat extends Animal
{
        public void eat()
        {
                System.out.println("猫吃鱼");
        }
}

class DuoTaiDemo
{
        public static void main(String[] args)
        {

                Animal a = new Animal();
                a.eat();

                //多态
                a = new Dog();
                a.eat();

                //多态
                a = new Cat();
                a.eat();
        }
}

潘天功 发表于 2012-11-25 18:09
用普通的类继承模拟多态。
*/
class Animal

/*
用抽象类模拟多态
*/

abstract class Animal
{
        public abstract void eat();
}

class Dog extends Animal
{
        public void eat()
        {
                System.out.println("狗吃肉");
        }
}

class Cat extends Animal
{
        public void eat()
        {
                System.out.println("猫吃鱼");
        }
}

class DuoTaiDemo2
{
        public static void main(String[] args)
        {
                Animal a  = new Dog();
                a.eat();

                a = new Cat();
                a.eat();

        }
}

潘天功 发表于 2012-11-25 18:11
/*
用抽象类模拟多态
*/

/*
用接口模拟多态
*/
interface Animal
{
        public abstract void eat();
}

class Dog implements Animal
{
        public void eat()
        {
                System.out.println("狗吃肉");
        }
}

class Cat implements Animal
{
        public void eat()
        {
                System.out.println("猫吃鱼");
        }
}

class DuoTaiDemo3
{
        public static void main(String[] args)
        {
                Animal a  = new Dog();
                a.eat();

                a = new Cat();
                a.eat();

        }
}
这是我上课时老师讲的，不知道满意否？

多态  某一类事物的多种存在形态。
                          同一种行为表现出不同的状态

               
               

                多态可以存在的前提:  
                       
                        子类与父类  继承   
                                父类 引用 = new 子类    父类引用指向子类对象
                        接口与实现类  实现
                                接口  引用= new 实现类   接口回调
                       
                        需要进行重写                               
               
               

                多态的作用与好处
                        提高了代码复用性与扩展性，增加了后期代码的可维护性
                        前期可能不知道具体的子类(实现类)是怎样实现的，但是我们可以在父类，接口中
                        定义这些行为，让子类与实现类去实现。使用时使用的是父类的引用或者接口的引用，
                        这样它的扩展性与可维护性增强

                存在的弊端

                        存在问题:在子类或实现类中独有的行为不可能通过父类引用或者接口的引用去调用。


        多态的细节

                1.实例方法
                        编译时：查看父类（父接口）中是否存在调用的方法
                        运行时: 调用的是子类(实现类)中重写的方法



               
                2.实例属性
                        编译时:查看父类(接口)中是否存在这样的属性
                        运行时: 得到的是父类(接口)中的实例属性.

                3.类方法
                        编译时：查看父类（父接口）中是否存在调用的方法
                        运行时: 调用的是父类中的类方法
                       
               
                怎样记忆:
                        1.实例方法单独记忆，编译时看等号左边，执行时看等号的右边

                        2.其它情况，编译等号左边，执行也看左边。

     多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时
并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引
用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在
程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同
的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运
行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
   实现java的多态是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序
调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里
正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。