Java：如何使用相同的代码相同地对待2个不同的对象？

Question

I have a situation where I have two different objects that do mostly the same thing, but that have a different API.

If I could treat them the same I could use one method to take care of both of them.

Basically, I need to iterate through either using a for loop. The two objects have different function names for getting the size and retriving the latest result inside of each:

CustomUnMutableObj1.getMySize() CustomUnMutableObj2.getTotal()

CustomUnMutableObj1.getlastresult() CustomUnMutableObj2.getlastvalue()

Is there anyway I can use the same for loop for both, without a big clumsy set of conditionals, and having the code being blind to the type of object?

Answer 1

If you can't modify the two classes in question so they implement a common interface, you could still get the same effect by writing some "adapter classes" :

interface CustomObjInterface {
    int getSize();
    int getLatestResult();
}

class CustomUnMutableObj1Adapter implements CustomObjInterface {
    private CustomUnMutableObj1 wrapped;
    public CustomUnMutableObj1Adapter(CustomUnMutableObj1 wrapped) {
        this.wrapped = wrapped;
    }
    @Override int getSize() {return wrapped.getMySize();}
    @Override int getLatestResult() {return wrapped.getTotal();}
}

// and a similar class for CustomUnMutableObj2

and then use the adapters instead of the original objects:

void doStuff(CustomObjInterface obj) {
    // do stuff with obj here, using getSize and getLatestResult
}

// call it like this, for a CustomUnMutableObj1
// If you had a CustomUnMutableObj2, you'd use a CustomUnMutableObj2Adapter instead
doStuff(new CustomUnMutableObj1Adapter(obj));

Answer 2

Something that is unclear: you said "iterate thru either using a for loop", does it mean that your method is getting either a Collection<Obj1> or a Collection<Obj2> , but not a Collection<Object> which will contains both Obj1 and Obj2 ? (My answer is base on the above assumption)

IMHO, using adapter (as suggested in other answer) may not be a good choice for above case, because if you are passing in a List<Obj1> , you have to construct a List<CustomUnMutableObj1Adapter> and pass to your "common processing method" for which you still need a bunch of code to handle it, and you will create one adapter list + one adapter for each element for each invocation of process logic, which may not be a good idea

Of course the best way to solve is to introduce a common interface/superclass to give these operations a meaningful concept. However if it is not a choice, you may see if the following helps you.

One way to reduce the boiler-plate code is by using something similar to a template method (If you are familiar with Spring, there are a lot of similar template like this)

eg (pseudo-code, not compiled)

interface ProcessInfoExtractor<T> {
    int getSize(T entity);
    String getLastValue(T entity);
}

The above interface will be responsible to perform the "common" operation against a provided object.

Then make your processing method like this:

void <T> process(Collection<? extends T> entities, ProcessInfoExtractor<T> infoExtractor) {
    for (T entity : entites) {
        System.out.println("size " + infoExtractor.getSize(entity)
                         + " last value " + infoExtractor.getLastValue(entity));
    }
}

so when you need to iterate thru a List<Obj1> , simply do:

process(obj1List,
        new ProcessInfoExtractor<Obj1> (
            @Override
            int getSize(Obj1 obj1) { return obj1.getMySize(); }
            @Override
            String getLastValue(Obj1 obj1) { return obj1.getLastResult(); }
        ));

(Similar case for Obj2 )

To ease caller, you can make 2 wrapper methods which internally call the above process method, like

void process(Collection<Obj1> obj1List) {
    process(obj1List, obj1InfoExtractor); // assume extractor is stateless,
                                          // you can create one and reuse it
};

void process(Collection<Obj2> obj2List) {
    process(obj2List, obj2InfoExtractor); // assume extractor is stateless,
                                          // you can create one and reuse it
};