在java的接口中使用实现类型

Question

我想为实现的类的类型创建一个接口，强制实现它的每个类具有特定的功能。

假设我有 MyClassA、MyClassB、MyClassC 等类，它们都需要针对自己类型的函数：

在 MyClassA 中：

public class MyClassA implements MyClass {
    MyClassA function(MyClassA x) {
        doSomethingImplementedInMyClassA(x);
    }
}

在 MyClassB 中：

public class MyClassB implements MyClass {
    MyClassB function(MyClassB x) {
        doSomethingImplementedInMyClassB(x);
    }
}

问题是，接口MyClass需要这样的功能怎么写？

public interface MyClass {
    MyClass function(MyClass x);
}

显然不起作用，因为返回类型是 MyClass 而不是它的实现。如何在 Java 中正确执行此操作？

Answer 1

你可以使用泛型：

public interface MyClass<V extends MyClass<V>> {
    V function(V x);
}

public class MyClassA implements MyClass<MyClassA> 

这称为CRTP。

---

这并不完美；它仍然允许像

public class MyClassB implements MyClass<MyClassA> 

要正确执行此操作，您需要 Java 不支持的更高种类的类型^{[需要引用]}。

Answer 2

如果实现总是调用参数上的方法，为什么不直接将该方法添加到接口中？

interface MyClass {
    MyClass doSomething();
}

class MyClassA implements MyClass {
    MyClassA doSomething() {
        //implementation here
    }
}

class MyClassB implements MyClass {
    MyClassB doSomething() {
        //implementation here
    }
}

Answer 3

除了接口之外，您可能还需要一个父类。

我发现一个接口最适合用来定义行为，因此GroupElementA 是一个 GroupElement 在概念上听起来比GroupElementA 更准确 表现得像一个 @987654324 @。

我会考虑使用父类来实现你想要的。

/**
 * An abstract group element.
 */
abstract class GroupElement
{
    // attributes of all group elements
}

/**
 * Defines behavior for objects that can be multiplied with
 * GroupElements.
 */
interface GroupElementMultipliable
{
    public GroupElement multiplyBy(GroupElement groupElement);
}

/**
 * Defines behavior for objects that can be divided by
 * GroupElements.
 */
interface GroupElementDivisible
{
    public GroupElement divideBy(GroupElement groupElement);
}

/**
 * An abstract GroupElement that can perform operations like
 * multiplication and division.
 *
 * Then again this class may not be necessary. The interfaces
 * implemented here may actually be directly implemented by
 * GroupElementA. GroupElementA will also be the one to inherit
 * GroupElement.
 */
abstract class OperableGroupElement extends GroupElement
        implements GroupElementMultipliable, GroupElementDivisible
{
    // attributes of all operable group elements
}

/**
 * A concrete GroupElement that can perform operations like
 * multiplication and division.
 */
class GroupElementA extends OperableGroupElement
{
    @Override
    public GroupElementA multiplyBy(GroupElement groupElement)
    {
        // Since we expect to multiply with another GroupElementA
        // we attempt to typcast the groupElement
        GroupElementA groupElementA = (GroupElementA) groupElement;

        // do multiplication operation -- this * groupElementA
        // then return new self
        return this;
    }

    @Override
    public GroupElementA divideBy(GroupElement groupElement)
    {
        // Since we expect to divide by another GroupElementA
        // we attempt to typcast the groupElement
        GroupElementA groupElementA = (GroupElementA) groupElement;

        // do division operation -- this / groupElementA
        // then return new self
        return this;
    }
}

Answer 4

在 Java 中做你想做的事情的正确方法是这样的：

首先定义包含一个抽象方法的接口，这是一个尚未定义的方法。 提醒一下，接口不是类！

public interface Animal {
    public Animal reproduceWith(Animal someAnimal);
}

然后您定义实现接口的类并覆盖抽象方法，但现在您使用您选择的代码实现它。这样，类中唯一相同的就是方法名称。 这有效地强制类实现某个方法。

public class Dog implements Animal {

    @Override
    public Animal reproduceWith(Animal someAnimal) {
        return new Dog();
    }
}


public class Cat implements Animal {

    @Override
    public Animal reproduceWith(Animal someAnimal) {
        return new Cat();
    }
}

之后，例如，您可以创建一个 MyInterface 列表并对其进行迭代，调用相同的方法，即使它是不同的类。

List<Animal> list = new ArrayList<Animal>();
list.add(new Cat());
list.add(new Dog());

Animal cat = new Cat();
Animal dog = new Dog();

for (Animal animal : list) {
    System.out.println(animal.reproduceWith(cat));
    System.out.println(animal.reproduceWith(dog));
}

希望对你有所帮助。