Cannot access the unique properties of a concrete class using polymorphism

design-patterns, java

Solution

You should have a look at the visitor pattern. You need to declare an interface ConnectionVisitor and add an method visit for each of your connection class in your hierarchy.

public interface ConnectionVisitor {

    public int visit (Connection connection);
    public int visit (SqlServerConnection sqlconnection);
    public int visit (OracleConnection oracleConnection)
}

Now you need to add an accept method in your base class connection and that accepts a ConnectionVisitor and then calls visit on it. Your new Connection class will look something like

public abstract class Connection {
  private int port;
  private int ipAddress;

  public Connection() {}

  public String description() {
     return "Generic";
  }

  public int accept(ConnectionVisitor visitor){
     return visitor.visit(this);
  }

}

Notice that the accept method does a dual dispatch. It dispatches on the base of the object on which it is called and the parameter that is passed to this method. This is at the heart of visitor pattern.

You can then implement the ConnectionVisitor interface to define any new functionality without changing your base class.

class   DemoVisitor implements ConnectionVisitor{
  public  int visit(Connection connection){
     System.out.println("Visiting Connection");
     return 1;
  }

  public int visit(SqlServerConnection sqlServerConnection){
     System.out.println("Visiting SqlServerConnection");
     return 1;
  }

  public  int visit(OracleConnection oracleConnection){
     System.out.println("Visiting Oracle Connection");
     return 1;
  }

}

In your TestConnection class you can simply create a new connection object and then call accept method on that object passing a visitor object.

public class TestConnection {
  public static void main(String[] args) {
    ConnectionFactory factory = new ConnectionFactory("SQLServer");
    Connection conn = factory.createConnection();

    conn = factory.createConnection();
    System.out.println(conn.description());
    ConnectionVisitor visitor = new DemoVisitor();
    System.out.println(conn.accept(visitor));
  }

}

So now any child class specific functionality must not reside in connection class hierarchy instead they must be implemented in new visitors.

Note that this pattern is not going to fit as such in your scenario. One of the limitation of this pattern in that the return type for all the methods in visitor interface must be same. This pattern may or may not fit your needs but it is worth looking into your case as such. You will probably need to modify this pattern to fit your needs. And that is what patterns are all about looking into some common solutions and then modifying those solutions to fit into your problem.

Problem

Original source