for(AbstractResponse resp : responseList) {
if (resp instanceof AResponse) {
AResponse areponse = (AResponse)resp;
//1
//2
//3
}else if (resp instanceof BResponse) {
BResponse breponse = (BResponse)resp;
//1
//2
//3
}else if (resp instanceof CResponse) {
CResponse creponse = (CResponse)resp;
//1
//2
//3
}
}
不好意思，刚才写错了，修改了一下
这代码有问题啊，for(AResponse resp : responseList) 这个地方初期化的resp一定是AResponse类，不可能走到else if里面的后面的代码都是多余的
for(AResponse resp : responseList)
多谢关注，这个写错了，修改了一下
已经很优雅了
这种结构已经很好了，易读。
如果想减少代码量，也是在 if else 分支特别多的情况下才有用，就这几个分支就不用考虑了。
如果一定要考虑，可以试试 for 循环。但前提是各分支中的处理要基本上相同，可以抽象出来。否则，也无法实现！
既然AResponse，BResponse,CResponse都是继承AbstractResponse，那直接在AbstractResponse 定义一个方法，让AResponse，BResponse,CResponse都实现这个方法，那在上面的程序调用时就不需要判断是否是AResponse，BResponse,CResponse了。
E.g.
abstract class AbstractResponse
{
abstract void print();
}
class AResponse extends AbstractResponse
{
public void print()
{
System.out.println("AResponse");
}
}
class BResponse extends AbstractResponse
{
public void print()
{
System.out.println("BResponse");
}
}
class CResponse extends AbstractResponse
{
public void print()
{
System.out.println("CResponse");
}
}
for(AbstractResponse resp : responseList) {
resp.print();
}
Class<?> cClass = resp.getClass();
Object temp = cClass.newInstance();
temp = resp;
直接使用java的反射机制 你可以试试效果
应该就是java多态的表现方式啦！
List<Object> abc = new ArrayList<Object>();
Map<String,Object> d = new HashMap<String,Object>();
d.put("abc", "abc");
abc.add(d);
Map<String,Object> e = new Hashtable<String,Object>();
e.put("abc", "abc");
abc.add(e);
for(Object tempMap :abc){
Class<?> cClass = tempMap.getClass();
Object temp = cClass.newInstance();
temp = tempMap;
System.out.println("This is " + cClass);
System.out.println(temp);
}
要优雅，有两个办法，一个是
AbstractResponse定义一个方法，它的派生类重写这个方法。
你循环直接调用，它会调用对应的派生类重写的不同方法
另一个，你不能或者不想改变AbstractResponse的代码。
那么可以使用泛型+策略模式，为每个类型编写一个策略实现类，在你的for里面，调用泛型方法，那么它会自动找策略类。