One builder method implementation for all sub-classes (generics?)

Question

My dilema is in creating one method that follows the builder pattern, which sets a variable and returns itself, but I have an interface Visitor which is implemented by BasicVisitor and that is extended by other visitor implementations.

Furthermore, I have a Visitable interface, which is implemented by SampleVisitable and that has methods that keep a history of all visitors that have visited.

So the problem is that I want to only keep a full reference of the visitor in the history of SampleVisitable if that visitor is "important", since the host calls Visitor.clean() before the visitor visits, which cleans all the data from the last visit, but I want the "important" visitors' data to remain in the history.

This is what I have so far for the implementation:

public interface Visitor {
    public void visit( Visitable visitable );

    public Visitor clone();

    public <V extends Visitor> V important();

    public boolean isImportant();
}

This is a snippet from the SampleVisitable class:

public void accept( Visitor visitor ) {
    visitor.clean();
    visitor.visit( this );
    addToHistory( visitor ); // only adds if visitor.isImportant() == true
}

Then I have BasicVisitor which implements the important() method. Now I don't want to have to override the important() method every time, but with my implementation I would have to, since any other visitors would have an error of the form "cannot convert from BasicVisitor to [OtherVisitor]" if they use the important() method without overriding it:

OtherVisitor otherVisitor = new OtherVisitor().important(); // cannot convert from BasicVisitor to OtherVisitor error.

What is the best way to do this? I need to have this feature implemented once, and available for use by all other sub-classes, without requiring them to override it. Thank you!

Edit:

Wow, abstract classes are exactly what I was looking for! I did some more research and found this post on differences between interfaces and abstract classes, and I hope it helps others looking for an answer.

After I posted this answer I realized that I didn't have to use the builder pattern in this situation, I could have just created a setImportant( boolean isImportant ) and would have basically what I needed, but I'm glad I asked anyways, because this is what I needed for another design issue.

Edit2:

After trying the abstract class, my main problem is still there, I still have to override the important() method for each sub-class of Visitor.

Ilya

score 1 · Accepted Answer · edited Oct 26 '12 at 23:53

1

Please try this. If you use an abstract class, then the method that you implement will be available for all sub-classes.

public abstract class Visitor {
    public abstract void visit( Visitable visitable );

    public abstract Visitor clone();

    public abstract <V extends Visitor> V important();

    public boolean isImportant() {
        //logic to store important visitors
    }
}

edited Oct 26 '12 at 23:53

Leigh

28,765
10
55
103

answered Oct 26 '12 at 21:10

sunleo

10,589
35
116
196

1

Space is missing in abstract class and your code will never compile. Besides that I don't know why this solves his problem. – Thomas Jungblut Oct 26 '12 at 21:22
1

It still won't compile because the methods with no implementation need to be abstract. Better would be to implement his interface and override the last method. Still this does not solve his problem. – Thomas Jungblut Oct 26 '12 at 21:30
I got an Idea about your last 2 lines.So if we use interface we have to override important method for all implementing classes . using abstract class important method will be automatically available for all child class.There is no need of override in all child classed. – sunleo Oct 26 '12 at 21:55

score 0 · Answer 2 · answered Nov 21 '12 at 20:54

I was able to solve this issue using abstract class, as @sunleo mentioned in his answer, and changing the important() builder function to a setter setImportant( boolean isImportant ) and generics.

So now I have the following implementation:

public abstract class Visitor<T> implements Cloneable  {
    private boolean important = false;
    private Graphable host;

    @Override
    public Visitor<T> clone() {
        try {
            return ( Visitor<T> ) super.clone();
        }
        catch( CloneNotSupportedException exception ) {
            log.info( exception, exception );        
        }
        return null;
    }

    public Graphable getHost() {
        return host;
    }

    public boolean isImportant() {
        return important;
    }

    public void setHost( Graphable host ) {
        this.host = host;
    }

    public void setImportant( boolean isImportant ) {
        important = isImportant;
    }

    public void visit( Graphable graphable ) {
        if( graphable instanceof Node ) {
            visit( ( Node ) graphable );
        }
        else if ( graphable instanceof Edge ) {
            visit( ( Edge ) graphable );
        }
    }

    public abstract void clean();

    public abstract void visit( Edge edge );

    public abstract void visit( Node node );
}

With the Visitor being cloneable, it makes it easy to make a copy for retention in my history.

One builder method implementation for all sub-classes (generics?)

2 Answers2