Java avoiding instanceof by design

Question

Consider the following class design:

public class SuperType { };
public class SubType1 extends SuperType { };
public class SubType2 extends SuperType { };
public class SubType3 extends SuperType { };

public class Tuple {
    SuperType t1;
    SuperType t2;

    public Tuple(SuperType t1, SuperType t2) {
        this.t1 = t1;
        this.t2 = t2;
    }

    public void DoSomething1() {
        if((t1 instanceof SubType1) && (t2 instanceof SubType3))
            switch(t1, t2);
        else if((t1 instanceof SubType2) && (t2 instanceof SubType1)) 
             t1.DoSomething();
        else if( ... ) {
             t1.DoSomething();
             t2.DoSomething();
        }
        else if( ... )
            // ...
    }

    public void DoSomething2() {
        // basically the same
    }
}

Since the action is dependent on two types I cant avoid the instanceof operator by moving the method to the subtypes. Is there a way I can improve my design so I can avoid using instanceof?

I know there are a lot of similar questions here, but I'd like to avoid the use of a visitor, because I have around twenty DoSomething()-Methods which would result in 9*20 implementations of visit().

This is too broad. We don't know what // Do some action does but more importantly, we don't know what goal you are trying to achieve. The typical way to avoid instanceof is to have a proper use of interface. — Tunaki
– Tunaki, Commented Nov 1, 2015 at 15:01
Your explanation of the problem ("I need to decide what action to take based on the types of the 2 elements of the tuple") does not really allow solutions radically different from what you're already doing. Explaining the specific problem you actually want to solve (instead of this generalization), though, might allow us to suggest another approach. — Arnout Engelen
– Arnout Engelen, Commented Nov 1, 2015 at 15:04
@JavaHD The actions are dependent on both types so I would just move instanceof into the SubType-classes. — user4758246
– user4758246, Commented Nov 1, 2015 at 15:08

Matt Timmermans · Accepted Answer · 2015-11-01 15:42:58Z

The proper way to do this in an OO language is using a pattern called "double-dispatch" (Googlable, but wikipedia's page on it is not great).

An "append" method makes a good example:

class Super
{
    abstract void appendTo(Super target);
    abstract void append(Sub1 source);
    abstract void append(Sub2 source);
}

class Sub1
{
    void appendTo(Super target)
    {
        target->append(this); //calls the Sub1 overload
    }
    void append(Sub1 source)
    {
        ... this is Sub1, source is Sub1 ...
    }
    void append(Sub2 source)
    {
        ... this is Sub1, source is Sub2 ...
    }
}
class Sub2
{
    void appendTo(Super target)
    {
        target->append(this); //calls the Sub2 overload
    }
    void append(Sub1 source)
    {
        ... this is Sub2, source is Sub1 ...
    }
    void append(Sub2 source)
    {
        ... this is Sub2, source is Sub2 ...
    }
}

Husam · Accepted Answer · 2015-11-02 07:19:05Z

Here an simple solution option you can use it, using Generics for the type safe & Polymorphism to do the actions behavior in each of subclass

interface SuperType<T> { void doAction(); };
class SubType1 implements SuperType<SubType1> { public void doAction(){} };
class SubType2 implements SuperType<SubType2> { public void doAction(){} };
class SubType3 implements SuperType<SubType3> { public void doAction(){} };

class Tuple {

   //if((t1 instanceof SubType1) && (t2 instanceof SubType3))
   //passing params rather than instanceof checking
   public void doSomething1CaseOne(SuperType<? extends SubType1> t1, SuperType<? extends SubType3> t3) {
       if(t1 == null || t3 == null) {
           throw new NullPointerException("Null Params!");
       }
       /**
        * the method action here
        * example: switch(t1, t2);
        */
   }

   //if((t1 instanceof SubType2) && (t2 instanceof SubType1))
   public void doSomething1CaseTwo(SuperType<? extends SubType2> t2, SuperType<? extends SubType1> t1) {
       if(t2 == null || t1 == null) {
           throw new NullPointerException("Null Params!");
       }
       /**
        * the method action here
        * example: t1.doAction();
        */
   }
   ... others methods
}

Now here an example for passing valid/invalid params to the method:

Tuple tuple = new Tuple();
SuperType<SubType1> t1 = new SubType1();
SuperType<SubType2> t2 = new SubType2();
SuperType<SubType3> t3 = new SubType3();

tuple.doSomething1CaseOne(t1, t3); //valid typesafe compilation time
tuple.doSomething1CaseOne(t1, t2); //invalid typesafe compilation time

tuple.doSomething1CaseTwo(t2, t1); //valid typesafe compilation time
tuple.doSomething1CaseTwo(t1, t2); //invalid typesafe compilation time

But then I had to change the fields in my tuple class to SuperType<?> t1 or SuperType<? extends SuperType> t2 and in that case I cannot call the methods at all for t1 and t2.

Collectives™ on Stack Overflow

Java avoiding instanceof by design

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related