java - 通过接口(interface)在2个模块之间进行转换

Question

假设我有 2 种通用类型的地球/火星模块。所以就会有EarthPerson、EarthDog和MarsPerson、MarsDog等。他们可以通过实现一个接口(interface)来相互转换，以确保他们可以相互转换但仍然保持相同的类型。例如:人只能是人不能是狗。

public interface Mars<T extends Earth> {
    T toEarth();
    interface Earth<T extends Mars<V>,V extends Earth>{
        T toMars();
    }
}

不知何故，我认为这些通配符似乎很复杂。但它为我保留了 TypeSafety。所以我的问题是如何重组这个？

Answer 1

你的例子的语义有点尴尬，但是你可以通过应用 decorator pattern 来解决这个问题。 。生成的客户端代码可能如下所示:

@Test
public void testPerson() {
    InterplanetaryTravelling<Person> traveller = new Person();
    assertEquals("", traveller.whereWasI());

    traveller = new ToEarth<>(traveller);
    assertEquals("Earth", traveller.getCurrentPlanet());
    assertEquals("Earth", traveller.whereWasI());

    traveller = new ToMars<>(traveller);
    assertEquals("Mars", traveller.getCurrentPlanet());
    assertEquals("Earth, Mars", traveller.whereWasI());
}

@Test
public void testDog() {
    InterplanetaryTravelling<Dog> traveller = new Shepherd();
    assertEquals("", traveller.whereWasI());
    // ... same as for the person
}

@Test
public void testTypeSafety() {
    InterplanetaryTravelling<Person> traveller = new Shepherd(); // Compiler Error
}

这是一个有效的解决方案，因为您只需实现一次依赖于类型的代码。它还具有可扩展性，对于每种新类型，您只需创建一个新类，而不必为每种可能的类型组合创建类。

我的装饰器具有以下实现:

interface InterplanetaryTravelling<T> {
    String getCurrentPlanet();

    String whereWasI();
}

abstract class InterplanetaryTravellingDecorator<S> implements InterplanetaryTravelling<S> {

    private final InterplanetaryTravelling<? extends S> decoratedTraveller;

    InterplanetaryTravellingDecorator(InterplanetaryTravelling<? extends S> traveller) {
        this.decoratedTraveller = traveller;
    }

    @Override
    public String whereWasI() {
        String previousTravels = decoratedTraveller.whereWasI();

        return previousTravels.isEmpty() ? this.getCurrentPlanet()
                : previousTravels + ", " + this.getCurrentPlanet();
    }
}

class ToEarth<S> extends InterplanetaryTravellingDecorator<S> {

    ToEarth(InterplanetaryTravelling<? extends S> person) {
        super(person);
    }

    @Override
    public String getCurrentPlanet() {
        return "Earth";
    }

}

class ToMars<S> extends InterplanetaryTravellingDecorator<S> {

    ToMars(InterplanetaryTravelling<? extends S> person) {
        super(person);
    }

    @Override
    public String getCurrentPlanet() {
        return "Mars";
    }

}

class Person implements InterplanetaryTravelling<Person> {

    @Override
    public String getCurrentPlanet() {
        return "";
    }

    @Override
    public String whereWasI() {
        return "";
    }

}

abstract class Dog implements InterplanetaryTravelling<Dog> {

    @Override
    public String getCurrentPlanet() {
        return "";
    }

    @Override
    public String whereWasI() {
        return "";
    }

}

class Shepherd extends Dog { }

尽管如此，这些通用边界看起来很复杂，但我想阻止声明一个可以引用人和/或狗的InterplanetaryTravelling旅行者。