问题描述

这段java代码如何优雅的实现？

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)
多谢关注，这个写错了，修改了一下

解决方案三：

已经很优雅了

解决方案四：

既然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();
}

解决方案五：

应该就是java多态的表现方式啦！

解决方案六：

        Class<?> cClass = resp.getClass();
        Object temp = cClass.newInstance();
        temp = resp;
        直接使用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里面，调用泛型方法，那么它会自动找策略类。

解决方案九：

这种结构已经很好了，易读。
如果想减少代码量，也是在 if else 分支特别多的情况下才有用，就这几个分支就不用考虑了。

如果一定要考虑，可以试试 for 循环。但前提是各分支中的处理要基本上相同，可以抽象出来。否则，也无法实现！