选择在运行时从java扩展的子类

Question

I have two classes (say B & C) that both derive from a class (say A). Now I need to write a class (say D) that should dynamically derive either from B or C at runtime.

B, C & A are classes provided to me through libraries and the only class in my control is D class. How do I write D with respect to constraints mentioned above. Obviously B and C have come from different vendors and hence would need different methods to be overridden in D depending on which is its parent class.

I cannot write different versions of D that would subclass from B & C since the override methods would have same code under different method names.

Answer 1

You should define an interface I , then define concrete implementations that correspond to B and C . At runtime you can determine which implementation of I is necessary, perhaps using a factory method. Then your code need only call methods of I instead of methods of B or C .

EDIT

There seems to be some confusion about how this works. What you want is for your business logic to operate on a consistent, stable API that belongs to you. For this you create an interface which we'll call I . Now you need implementation classes for the different external classes you need to adapt to ( A , B , and C ). It might look something like this:

public interface I {
    void doSomething();
}

public class IA implements I {
    private A a;

    public IA(A a) {
        this.a = a;
    }

    public void doSomething() {
        // specific to A
        a.doSomethingUnique();
    }
}

// similar implementation classes for B and C

Now you need to obtain an instance of I at runtime specific to your current situation. Whatever informs you about which specific class is in use at runtime can be used for this purpose. At worst, you can do this:

// in some util class
public static I getI(Object obj) {
    if (obj instanceof A) {
        return new IA((A) obj);
    } else if (obj instanceof B) {
        return new IB((B) obj);
    } else if (obj instanceof C) {
        return new IC((C) obj);
    }
    // maybe throw an exception? or return a mock I implementation?
}

Now all your business logic refers only to instances of I and calls methods defined in your interface, abstracting away the different concrete classes you have no control over.

Answer 2

You can do it with private inheritance.

If you have :

class A
{
  public void methodA() {...}
}
class B extends A
{
  public void methodB() {...}
}
class C extends A
{
  public void methodC() {...}
}

D would be implemented as :

class D
{
  private B b;
  private C c;
  private D() {}
  public static D instantiateAsB()
  {
    D res = new D();
    res.b = new B();
  }
  public static D instantiateAsC()
  {
    D res = new D();
    res.c = new C();
  }
  public void methodA()
  {
    if ( b!=null )
      b.methodA();
    else
      c.methodA();
  }
  public foid methodB() 
  {
    if ( b==null )
      throw new MethodNotImplementedException();
    else
      b.methodB();
  }
  public foid methodC()
  {
    if ( c==null )
      throw new MethodNotImplementedException();
    else
      c.methodC();
  }
}

Private inheritance has some drawbacks. One is that D would not be an A. So you can't pass a D object as a parameter to a method which requires an A. This code would not compile :

void method( A a ) {...}

D d = D.instantiateAsB();
method( d );

You can work around that using cast methods in D's definition :

// inside D class :
public A castAsA()
{
  if ( b!=null )
    return (A)b;
  else
    return (A)c;
}

public B castAsB()
{
  if ( b==null )
    throw new ClassCastException();
  else
    return b;
}

public C castAsC()
{
  if ( c==null )
    throw new ClassCastException();
  else
    return c;
}

And the previous non compiling code would be rewritten as :

D d = D.instantiateAsB()
method( d.castAsA() );