java - 创建具有依赖约束的多态对象的模式

Question

首先，我的结构:

抽象对象
--对象A
--对象B

抽象其他对象
--其他对象A
--其他对象B

通过多态性，我想基于我的 AbstractObject 创建一个 AbstractOtherObject。更准确地说，如果它是 ObjectA，我想要一个 OtherObjectA，对于 B 也是如此。
重要的一点是，我不希望依赖于 AbstractObject 中的 AbstractOtherObject。我无法在 AbstractObject 中创建抽象方法AbstractOtherObject toOtherObject()。

我找不到不使用instanceof的解决方案。

提前致谢。

更新:伪代码

如果我没有依赖约束，我会这样做:

public class Any{
    void do(AbstractObject o){
        AbstractOtherObject otherO = o.toOtherObject();
        doSomething(otherO);
    }
}

但是由于我不想依赖，所以我只能做一些丑陋的事情，例如:

public class Any{
    void do(AbstractObject o){
        AbstractOtherObject otherO;
        if(o instanceof ObjectA){
            otherO = new OtherObjectA(o);
        } else {
            otherO = new OtherObjectB(o);
        }
        doSomething(otherO);
    }
}

Answer 1

访问者模式来救援!

public class VisitorExample {
    public static void main(String[] args) {
        ConverterVisitor converterVisitor = new ConverterVisitor();
        A a = new A();
        B b = new B();
        a.accept(converterVisitor);
        AbsOther aother = converterVisitor.getOther();
        b.accept(converterVisitor);
        AbsOther bother = converterVisitor.getOther();
    }
}

在本例中，要点是让一个单独的类 ConverterVisinor 完成类型之间转换的实际工作。

Visitor 类需要了解应访问的不同具体类，但 Visitable 只需要依赖于 Visitor 接口(interface)即可。

interface Visitor {
    void visit(A a);
    void visit(B b);
    void visit(Visitable visitable);
}

interface Visitable {
    void accept(Visitor v);
}

因此，执行类型之间转换的实际工作的访问者将类似于:

class ConverterVisitor implements Visitor {


    // Added field and getter to store the other object in...
    private AbsOther other;

    public AbsOther getOther {
        return other;
    }

    public void visit(B b) {
        System.out.println("Convert a to BOther");
        other = new BOther();
    }

    public void visit(A a) {
        System.out.println("Convert a to AOther");
        other = new AOther();
    }

    @Override
    public void visit(Visitable visitable) {
        throw new IllegalArgumentException("Type: " + 
            visitable.getClass().getName() + " not supported");
    }

}

然后抽象类和参与转换的类可以如下所示:

abstract class Abs implements Visitable { }
abstract class AbsOther { }

class A extends Abs {

    public void accept(Visitor v) {
        v.visit(this);
    }

}

class B extends Abs {

    public void accept(Visitor v) {
        v.visit(this);
    }

}

class AOther extends AbsOther {

}

class BOther extends AbsOther {

}

如果您无法向具体类添加任何内容，则需要将它们包装在类型感知的 Visitable 包装器中。

编辑:要获得转换后的其他对象，您有两种可能的解决方案。您可以使访问者成为有状态的(见上文)。或者，如果您需要接受器方法返回值，则可以使用通用访问者/可访问者。

public class VisitorExample {
    public static void main(String[] args) {
        AConverterVisitor converterVisitor = new AConverterVisitor();
        A a = new A();
        B b = new B();
        AOther aother = a.accept(converterVisitor);
        System.out.println("Got AOther!");

        try {
            b.accept(converterVisitor); 
        } catch (IllegalArgumentException iae) {
            System.out.println("Calling accept on b with a AConverterVisitor will result in a exception");
        }

    }
}

访客和可访问现在是通用的:

interface Visitor<T> {
    T visit(A a);
    T visit(B b);
    T visit(Visitable visitable);
}

interface Visitable {
    <T> T accept(Visitor<T> v);
}

ConverterVisitor 是抽象的，并且根据每种类型被子类化为具体访问者:

abstract class ConverterVisitor<T> implements Visitor<T> {

    public T visit(Visitable visitable) {
        throw new IllegalArgumentException("Type: " + visitable.getClass().getName() + " not supported");
    }


    public T visit(A visitable) {
        return visit((Visitable) visitable);
    }


    public T visit(B visitable) {
        return visit((Visitable) visitable);
    }

}

class AConverterVisitor extends ConverterVisitor<AOther> {

    @Override
    public AOther visit(A a) {
        return new AOther();
    }

}

A 和 B 的接受方法现在的实现如下:

A 类扩展了 Abs {

public <T> T accept(Visitor<T> v) {
    return v.visit(this);
}

}

B 类扩展了 Abs {

public <T> T accept(Visitor<T> v) {
    return v.visit(this);
}

}

其他类和抽象类与第一个示例中的相同。