实现无父类或接口的继承

Question

我有以下两种方法：

void m1(SourceClass s, ClassA a);
void m2(SourceClass s, ClassB b);

ClassA 和 ClassB 实际上有一些共同的属性，但是，我们不能编写另一个父类并让 ClassA 和 ClassB 从父类继承，因为 ClassA 和 ClassB 是我们无法控制的。

问题：没有重复代码，如果 ClassA ... else if ClassB ... 为了达到编写被继承的新父类的效果，处理这种情况的最佳方法是什么？谢谢。

Answer 1

为什么不简单地测试instanceof？

例如

void m (SourceClass s, Object a_or_b) {

    if (a_or_b instanceof ClassA) {
        // do blahA
    }
    if (a_or_b instanceof ClassB) {
        // do blahB
    }
}

Answer 2

有一个很好的设计模式Decorator Design可以解决：

• 动态地将附加职责附加到对象。装饰器为扩展功能提供了一种灵活的替代子类的方法
• 通过递归包装核心对象，由客户指定修饰。
• 包装礼物，放入盒子，然后包装盒子。

注意：在Strategy Design Pattern之后的单独类中提取公共代码，并动态地动态更改对象的行为。

例如：

public class CommonSteps {

   public void perform() {
      System.out.println("common steps");
   }
}

public class A{
   private CommonSteps commonSteps;
   public A(CommonSteps commonSteps) {
      this.commonSteps = commonSteps;
   }
   public void action() {
      System.out.println("some steps of class A");
      commonSteps.perform();
      System.out.println("some more steps of class A");
   }
}

public class B{
   private CommonSteps commonSteps;
   public B(CommonSteps commonSteps) {
      this.commonSteps = commonSteps;
   }
   public void action() {
      System.out.println("some steps of class B");
      commonSteps.perform();
      System.out.println("some more steps of class B");
   }
}

---

编辑：

这里是根据您的要求的完整示例代码和步骤：

步骤：

创建一个具有通用方法签名的接口Wrapper。

interface Wrapper {
    void setP1(String p1); 
    void setP2(String p2);
} 

创建Wrapper接口的类特定实现。

class ClassAWrapper implements Wrapper{
    ClassA classA;
    ClassAWrapper(ClassA classA){
        this.classA = classA;
    }
    @Override
    public void setP1(String p1)
    {
        classA.setP1(p1);
    }
    @Override
    public void setP2(String p2)
    {
        classA.setP2(p2);
    }
}

现在更改方法签名，如

void m(SourceClass s, Wrapper w) {
    w.setP1(s.getP1()); 
    w.setP2(s.getP2());
} 

问题解决了

**完整代码：

interface Wrapper {
    void setP1(String p1); 
    void setP2(String p2);
}

class ClassAWrapper implements Wrapper{
    ClassA classA;
    ClassAWrapper(ClassA classA){
        this.classA = classA;
    }
    @Override
    public void setP1(String p1)
    {
        classA.setP1(p1);
    }
    @Override
    public void setP2(String p2)
    {
        classA.setP2(p2);
    }
}

class ClassBWrapper implements Wrapper{
    ClassB classB;
    ClassBWrapper(ClassB classB){
        this.classB = classB;
    }
    @Override
    public void setP1(String p1)
    {
        classB.setP1(p1);
    }
    @Override
    public void setP2(String p2)
    {
        classB.setP2(p2);
    }
}

class ClassA {
    void setP1(String p1) {
        System.out.println("ClassA - " + p1);
    }

    void setP2(String p2) {
        System.out.println("ClassA - " + p2);
    }
}

class ClassB {
    void setP1(String p1) {
        System.out.println("ClassB - " + p1);
    }

    void setP2(String p2) {
        System.out.println("ClassB - " + p2);
    }
}

class SourceClass {
    String getP1() {
        return "p1";
    }

    String getP2() {
        return "p2";
    }
}

void m(SourceClass s, Wrapper w) {
    w.setP1(s.getP1()); 
    w.setP2(s.getP2());
}