关于JAVA多态的问题

Question

对多态比较迷茫，我知道运用多态对程序的扩展有很大的帮助，但我不知道如何的去用啊，我觉得不用多态和用多态感觉差不多， 大家帮忙看下两段代码，一个用多态，一个不用（直接调用），最后代码结果都是一样的，到底有什么区别呢， 用了多态的好处在哪呢？什么地方能扩展呢？不用多态 会有什么麻烦的地方呢？ 麻烦大家帮我解决这个疑惑 最好举个例子 谢谢了用多态的程序： class Animal{
private String name;
private String forcolor;
Animal(String name,String forcolor){
this.name=name;
this.forcolor=forcolor;
}
void enjoy(){
System.out.println("Animal");

}
}
class Dog extends Animal{
Dog(String name,String forcolor){
super(name,forcolor);
}
 void enjoy(){
 System.out.println("Dog");
 }
}class Cat extends Animal{
Cat(String name,String forcolor){
super(name,forcolor);
}
void enjoy(){
System.out.println("Cat");
}
}
class Lady{
private String name;
private Animal pet;
Lady(String name,Animal pet){
this.name=name;
this.pet=pet;
}
void petenjoy(){
pet.enjoy();
}
}
public class TestAnimal {
public static void main(String[] args) {
Dog d = new Dog("dogname","dogcolor");
Cat c = new Cat("catname","catcolor");
Lady l = new Lady("lname",c);
l.petenjoy();
Lady l2 = new Lady("l2name",d);
l2.petenjoy();

}}
不用多态的class Animal{
private String name;
private String forcolor;
Animal(String name,String forcolor){
this.name=name;
this.forcolor=forcolor;
}
void enjoy(){
System.out.println("Animal");

}
}
class Dog extends Animal{
Dog(String name,String forcolor){
super(name,forcolor);
}
 void enjoy(){
 System.out.println("Dog");
 }
}class Cat extends Animal{
Cat(String name,String forcolor){
super(name,forcolor);
}
void enjoy(){
System.out.println("Cat");
}
}
class Lady{
private String name;
private Animal pet;
Lady(String name,Animal pet){
this.name=name;
this.pet=pet;
}
void petenjoy(){
pet.enjoy();
}
}
public class TestAnimal {
public static void main(String[] args) {
Dog d = new Dog("dogname","dogcolor");
Cat c = new Cat("catname","catcolor");
d.enjoy();  //直接调用
c.enjoy();  ////直接调用
}}

Answer 1

你不用多态的例子还加Lady类干什么？这个例子中多态方便你以后扩展，全部通过封装好的Lady类来生成动物的enjoy方法，以后再增加别的动物也不需要对Lady类进行修改了

Answer 2

改：class Lady{
    private String name;
    private Animal pet;
    Lady(String name,Animal (Animal)cat){
        this.name=name;
        this.pet= new Cat();
    }
    void petenjoy(){
        pet.enjoy();
    }
}
主方法使用Lady类得到具体动物的enjoy();
不知道对不对。

Answer 3

你要这样用啊：
Animal animal = new Dog("dogname","dogcolor");
animal.enjoy();//输出：dog
animal = new Cat("catname","catcolor");
animal.enjoy();//输入：cat
通过把子类的实例变量赋给父类的引用变量，可以实现不同的功能，例如都是调用enjoy()可以有不同的输出，当你新增加一个类时，只需要在增加一个类而不用修改源程序

Answer 4

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，这就是多态的好处。
向上转型属于多态的一种，下面就是向上转型。
假设你现在的程序是这样的: 
List list = f1();  //这个f1()是你的同事写的一个程序,返回参数类型是ArrayList 
list.get(2); 
list.iterator(); 
.... 
list这个引用用了很多地方了. 然后有一天,你的同事跟你说,不行啊,我这个f1()的方法返回参数类型一定要改为LinkList!!! 
那么,你将不用改任何的代码,然后轻松自在地喝着红茶跟你的同事说,没关系,你改吧. 但如果你开始的时候是这样写: 
ArrayList list = f1(); 
… 

Answer 5

JAVA最重要的一条就是“一切对接口编程，不要对具体对象编程”。
对接口编程的基本就是多态，使用多态程序扩展性好，便于维护，代码重用率高。

Answer 6

java 代码 
class Computer{     
         
    public void turnOn(){     
      }     
}    现在有了电脑这个类，那么个人PC，笔记本都是继承他。 java 代码 
class PC extends Computer{     
    public void turnOn(){     
          System.out.println("PC has turn on");     
      }     
}     
    
class NB extends Computer{     
    public void turnOn(){     
          System.out.println("NB has turn on");     
      }     
}    我们看到，每个类都有一个 turnOn()方法，而在父类中这个方法是空的，子类中各自有不同的实现，到这里可能还不太明显。如果有另外一个方法，要接受这些类作为参数，就像这样 java 代码 
class Test{     
    public void go(Computer computer){     
           computer.turnOn();     
      }     
}    这个方法接收的是基类参数，当然我们是可以把子类传递给方法的，也应该这么做。 java 代码 
go(new PC());     
go(new NB());    这样他就会去调用具体子类的turnOn()方法，所以这两次调用的输出是不一样的.如果不用基类作为参数,我们想调用每个子类的turnOn()方法，那么就要些两个方法体一样的go()而接收不同的参数的重载。 java 代码 
public void go(PC computer){        
           computer.turnOn();        
      }       
    
public void go(NB computer){        
           computer.turnOn();        
      }      这样些也是正确的，但是这样会产生很多重复代码，而且也不易维护，当然这只是多态中最基本的一个部分，Java多态机制还有很多特性，关于这些建议大家看看 java编程思想(think in java)这本书，里面讲的很详细，这里只是很简单的描述了一下，还望个各位高手不要见笑。 
 
 
 

Answer 7

多态通过分离做什么和怎么做，从另一角度将接口和实现分离开来。多态不但能够该三代码的组织机构和可读性，还能够创建可扩展的程序-即无论在项目最初创建时还是在需要加新功能时都可以“生长”的程序。用多态最主要的目的还是为了以后的扩展更加灵活，可以参考Java编程思想第8章对多态的解释