如何在没有instanceof的情况下“映射”两个不同的对象继承树

Question

I have a design question I can't get a good solution for. This is my problem:

There are two different object "trees" which need to processed together. Object tree one:

• AbstractObjectTreeOne with Sub1ObjectTreeOne and Sub2ObjectTreeOne
• AbstractObjectTreeTwo with Sub1ObjectTreeTwo and Sub2ObjectTreeTwo

I now have a method where I get a list of AbstractObjectTreeOne and a list of AbstractObjectTreeTwo. They are exact the same size and "match" to each other by name. So I can loop through the objects in the list of AbstractObjectTreeOne and get the according AbstractObjectTreeTwo by name.

Now it should be validated if the "matching" objects (by name) really match to each other, so the current code contains a lot of instanceof stuff. Example:

if (!(objectOfAbstractObjectTreeOne instanceof Sub1ObjectTreeOne)) {
   throw exception;
}

and then also in the same method

if (!(objectOfAbstractObjectTreeTwo instanceof Sub1ObjectTreeTwo)) {
   throw exception;
}

After that, both parameters are cast to their "real" subtype to be further processed. This also does not feel very good.

This all feels not very object-oriented, but I currently do not have a good idea how to solve this. I tried the visitor pattern, but it only solves the instanceof issue in either AbstractObjectTreeOne or AbstractObjectTreeTwo and still contains a lot of instanceof.

Maybe some of you have a good idea about this kind of problem. Maybe it's easy to solve, but I do not have the right idea yet.

Answer 1

This is called OOO Principle Polymorfism .

No need to use instanceof . You have to create an interface and use it in the declaration of the tree. All subtypes should implement this interface, and you can call the required methods without typecasting.

This is an example.

public interface ObjectTreeOne { void payloadOne() {}   }
public class Sub1ObjectTreeOne implements ObjectTreeOne {   void payloadOne() {}    }
public class Sub2ObjectTreeOne implements ObjectTreeOne {   void payloadOne() {}    }

List<ObjectTreeOne> objectTreeOne = new ArrayList<>();
objectTreeOne.add(new Sub1ObjectTreeOne()); 
objectTreeOne.add(new Sub2ObjectTreeOne());

public interface ObjectTreeTwo {    void payloadTwo() {}    }
public class Sub1ObjectTreeTwo implements ObjectTreeTwo {   void payloadTwo() {}    }
public class Sub2ObjectTreeTwo implements ObjectTreeTwo {   void payloadTwo() {}    }

List<ObjectTreeTwo> objectTreeTwo = new ArrayList<>();
objectTreeTwo.add(new Sub1ObjectTreeTwo()); 
objectTreeTwo.add(new Sub2ObjectTreeTwo());

for(int i = 0; i < 2; i++) {
    ObjectTreeOne objectTreeOne = objectTreeOne.get(i);
    ObjectTreeTwo objectTreeTwo = objectTreeTwo.get(i);
    
    objectTreeOne.payloadOne();
    objectTreeTwo.payloadTwo();
    
}