Question

我有以下两种方法：

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

ClassA＆amp;事实上，ClassB共享一些共同属性，但是，我们无法编写另一个父类＆amp;制作ClassA＆amp;自ClassA＆amp; A以来，ClassB继承自父类。 ClassB不受我们的控制。

问题：没有重复的代码，如果是ClassA ......否则如果ClassB ... 处理此类场景的最佳方法是什么才能实现编写继承的新父类的效果？感谢。

Answer 1

有一个很好的设计模式 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());
}

Answer 2

为什么不简单地测试instanceof？

e.g。

void m (SourceClass s, Object a_or_b) {

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

编辑：

实现继承没有父类或接口

2 个答案: