假设我定义了一个Interface以及类,如下:

Interface Actor{   
     void act(){}
   }

class HappyActor implements Actor {
   public void act(){
   System.out.println("I am HappyActor");}
 }

class SadActor implements Actor {
   public void act(){
  Syste,.out.println("I am SadActor");
   }

 .....  //** Some other Code here

public static void main(String[] args) {
   ..... //** Some code here
 
 HappyActor actor1= new HappyActor();
 SadActor  actor2= new SadActor();
  
 Vector actors= new Vector();

//** 把actor1和actor2加入Vector
   
 .......
  }

但是如果我在以后的代码中要把向量里面的元素取出来的话,我将会失去向量中对象
的type information,也就是说,我不知道他是SadActor还是HappyActor,于是我把
他上溯(Upcast)到Actor类,但是问题来了:我是否可以调用这个上溯以后的类里面的
方法act()?
如果我可以调用这个上溯的类里面的方法的话,Java Compiler是否可以正确的识别应该调用哪个对象的方法?

也许有大侠会说要我直接将向量里面的元素在取出来时候直接塑造成Happy或者SadActor,但是,各位观众,如果我要随机的取出向量里面的元素的话以上的问题就
出现了,小弟菜蔬学前请各位大侠指点一二.


谢谢谢谢谢谢

HappyActor actor1= new HappyActor();
SadActor  actor2= new SadActor();
  
ArrayList actors= new ArrayList();
actors.add(actor1);
actors.add(actor2);

Actor actor = (Actor)actors.get(0);
actor.act(); // print out "I am HappyActor"
actor = (Actor)actors.get(1);
actor.act(); // print out "I am SadActor"

或者
for (Iterator it = actors.Iterator(); it.hasNext(); )
{
   Object obj = it.next();
   if (obj instanceof HappyActor) {
      ((HappyActor)obj).act(); // invoke the act() in HappyActor
   } 
   if (obj instanceof SadActor) {
      ((SadActor)obj).act(); // invoke the act() in SadActor
   } 
}

kf_young(野风)说的对，这时，实际上，你的HappyActor和SadActor
已经和Actor无关了，所以就不能用Actor来”抽象“他们了，这时
就应该用instanceof 来区别他们了

以下是Test.java 可运行，请笑纳。
java 中的所有类方法都是virtrue 的，是什么类就实际调用方法，而不受声名影响。

import java.util.Vector;

interface Actor{  
    void act();
}

class HappyActor implements Actor {
    public void act(){
        System.out.println("I am HappyActor");
    }
}

class SadActor implements Actor {
    public void act(){
        System.out.println("I am SadActor");
    }
}

//** Some other Code here
public class Test {
    public static void main(String[] args) {
    //** Some code here

        HappyActor actor1= new HappyActor();
        SadActor  actor2= new SadActor();
  
        Vector actors= new Vector();
    
        actors.add(actor1);
        actors.add(actor2);
    
        for (int i = 0; i

    

 

请教一个问题：java为什么没有多态性，这样有什么好处嘛？