Question

java的多态怎么理解啊，多态有什么用途。

package string;
class Animal
{
public void roar()//roar英文意思‘叫声’
{
System.out.println("动物:...");
}
}

class Cat extends Animal
{
public void roar()
{
System.out.println("猫:喵,喵,喵,...");
}
}

class Dog extends Animal
{
public void roar()
{
System.out.println("狗:汪,汪,汪,...");
}
}

public class AnimalTest
{
public static void main(String args[])
{
Animal am=new Animal();
am.roar();
am=new Dog();
am.roar();
am=new Cat();
am.roar();
}
}
以上代码实现了多态，到底用什么作用，或说有什么好处啊？

Answer 1

多态有编译时多态 和运行时多态。
第一个是通过方法重载实现；第二个是通过方法覆盖实现（子类覆盖父类方法）。
第一种就是我们调用方法是不用区分参数类型，程序会自动执行相应方法，如： 加法运算，可以使int相加，可以是double相加，都是同一个方法名。
第二种就是动态绑定，使用父类引用指向子类对象，再调用某一父类中的方法时，不同子类会表现出不同结果。 这样的作用就是扩展性极好，玩过网游的话应该知道 游戏中有不同的角色，它们都有一个父类，它们做相同动作时表现出来的效果就会不一样，比如跑，魔法师的跑跟战士的跑就不会一样，这就是俩者都覆盖了父类中的跑方法，各自有自己的现实，表现出来多态。 如果有一天你想再加个角色，只用再写一个类继承该父类，覆盖其中的跑方法就行了，其他代码不用怎么改，所以可维护性也很好。

这一个小的程序 或许你体会不到多态的强度作用。其实说到多态就是 面向接口编程，它不和具体类尽心挂钩了
比如 你没用多态的话 ，
你没实例化一个对象 就要new一下，那假如你那天改变了需求了呢？那是不是又要改里面的？这样不好，所以 你可以通过多态，把需要相似的给提出来，然后继承它 这样 以后需要扩展你仅仅只是继承而已。这样就很简单。

这个需要多看代码 才可以更深刻理解。

有问题在讨论。

追问

我把am=new Dog();
am.roar();改为

Dog dog=new Dog();
dog.roar();
这实现的功能不是一样吗？

追答

给你个例子吧！。。好好体会体会。
假设有一个类 叫 鸟类，它拥有属性翅膀，拥有方法鸣叫，如下
public class Bird{
private Wing wing;
public void moo(){
System.out.println("鸟叫声");
}
}
鸟类封装了 翅膀类和moo方法；另外有两个类都继承鸟类并重写了moo方法，分别是鹦鹉和麻雀如下：
鹦鹉类：
public class Parrot extends Bird{
public void moo(){
System.out.println("鹦鹉的叫声");
}
}
麻雀类：
public class Sparrow extends Bird{
public void moo(){
System.out.println("麻雀的叫声");
}
}
方法重写应该懂吧，不懂自己找书看吧；然后你有个妻子她想听鸟叫，就有个妻子类
public class Wife{
public void listen(Bird bird){
bird.moo();
}
/*这时多态就很好的体现了，你妻子想听鸟叫，无论什么鸟都可以给她，但是你想让她和鹦鹉
*说话，你就买了一只鹦鹉传给listen方法，结果你妻子听到了鹦鹉的叫声，程序输出：鹦
*鹉的叫声
*/
public static void main(String[] args) {
new Wife().listen(new Parrot());
}
}
多态实现了动态绑定，让程序有了很好的扩展性，比如你以后想买一只燕子送给你妻子，就只需要写个燕子类Swallow继承Bird方法就可以了，而不需要再在妻子类里添加一个方法listen(Swallow swallow)……上面编码没用编译器，可能有错误，请谅解
说得够详细了吧，感谢世界上有我这么好的人吧 ^_^

Answer 2

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

JAVA引用变量有两个类型：一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态（Polymorphism）。这和C++里的类似。

class BaseClass                   //父类 
{ 
      public int book =6;   
      public void base()    { 
          System.out.println("父类的普通方法");   
      }   
      public void test()    { 
          System.out.println("父类的被覆盖的方法");         
      }
} 
public class SubClass extends BaseClass { 
        //重新定义一个book实例属性覆盖父类的book实例属性         
        public String book = "Hello！";   
        public void test()   { 
            //也叫方法的重写或方法的覆盖
            System.out.println("子类覆盖父类的方法")         
        }   
        public void sub()    { 
            System.out.println("子类的普通方法");   
        }   
        //下面给出主方法的入口 
        public static void main(String[ ] args)   { 
            //下面编译时类型和运行时类型完全一样，因此不存在多态                   
            BaseClass   bc = new BaseClass();       
            //创建父类对象                   
            //输出6 
            System.out.println(bc.book);   
            //下面两次调用将执行BaseClass（父类）的方法                    
            bc.base();                    bc.test();   
            //下面编译时类型和运行时类型完全一样，因此不存在多态                    
            SubClass sc = new SubClass();        
            //创建子类对象                     
            //输出"Hello！" 
            System.out.println(sc.book);   
            //下面调用将执行从父类继承到的base方法                    
            sc.base();   
            //下面调用将执行从当前类的test方法                     
            sc.test();   
            //下面编译时类型和运行时类型不一样，多态发生                    
            BaseClass ploymophicBc = new SubClass();                    
            //输出6----表明访问的是父类属性 
            System.out.println(ploymophicBc.book);   
            //下面调用将执行从父类继承到的base方法                     
            ploymophicBc.base();   
            //下面调用将执行从当前类的test方法                     
            ploymophicBc.test();  
            //因为ploymophicBc的编译类型是BaseClass,BaseClass 类没有提供资金SUBYYIF 
            //所以下面代码编译时会出现错误                    
            //ploymophicBc.sub();             
            } 
}

Answer 3

多态你可以从字面上去理解，一个类表现出多种形态。它是一种编码的技巧而不是写代码的格式或者方式。 要想理解多态你需要从需求入手。伪代码例子：void method（Father instance）: instance.callmethod();现在有两个子类 girl 和 boy . 如果我传入给method的对象是girl，那么instance.callmethod()是否就等同于girl.callmethod(),如果传入的是boy，就等同于boy.callmethod().但是对于程序而言，表达式一直都是 void method（Father instance）: instance.callmethod();没有改变过只不过通过传入不同的子类对象使这样一个表达式表现出了多种“类的形态”。这样的现象就叫做多态。 多态在软件结构设计上是非常重要的一个抽象意识1：多态用于解决if,else 现代的编程技巧要求对于某一个函数专注于解决一类型的事情。这就要求一个函数中要尽量的避免出现>1个if，那么如果程序出现了分支而又要避免使用if应该怎么办呢。那就是多态最经常出现的场景。看下面的一个2：多态用于隐藏函数的具体内容在面向对象高度结构化的开发中，软件根据功能的不同需要分为各种模块分别交给不同的人开发。那么如果同一个接口描述一类情况显然是非常高明的。最明显的例子就是大家最常用的System,out.println(Object).初学者可能每天都在使用这样一个多态，但是却不知道这个是多态。System,out.println();无论你输入的是一个string,object,int,array,float都可以正常输出内容。为什么，因为所有的你string,Intege,array,Float都是Object的子类，根据填入参数的类型，System,out,println()就表现出了各种输出功能的形态。 说了这么多希望你能够理解。 多态可以通过接口和继承来实现。 一个接口可以对应多个实现 （1vN : 多态的数学描述，1个形态代表多个形态）继承：一个父类可以有多个子类 （1vN : 多态的数学描述，1个形态代表多个形态）

Answer 4

多态,就是重载和重写.重载发生在一个类中.重写发生在子类,意思就是子类重写父类相同名称的方法.刚学语言有的东西,不必搞得那么清楚,只有知道怎么用就行了,有的问题你要想真正把它搞得很懂,短时间是不可能的,比如说接口,没有几年工作经验你根本不可能真正理解什么是接口,甚至有的人工作四,五年也没搞明白什么是接口,不要花太多时间去搞这些不容易搞懂的问题.
重载的特性,方法名相同.返回类型,传入方法的参数不同(包括个数和类型).
重写的特性,方法名相同,返回类型,参数均相同,必须发生在子类.

Answer 5

　　多态（Polymorphism）按字面的意思就是“多种状态”。
　　在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。
　　简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。