【问题标题】:How to make two classes which both have method with the same name, signature and return type behave like they would implement the same interface如何使两个具有相同名称、签名和返回类型的方法的类的行为就像它们实现相同的接口一样
【发布时间】:2019-04-29 18:10:45
【问题描述】:

我会用一个例子来解释我的问题。

我有两个课程NumberGeneratorApple 和NumberGeneratorOrange。它们都有具有相同签名和返回类型public Integer getNumber() 的方法。问题是他们没有实现相同的接口,尽管它是合乎逻辑的。我可以使用此方法创建接口并修改这些类以实现它,但我不想这样做。这就是为什么。这些类是从 xml 中自动生成的。在实际示例中,有几十个这样的类。我们必须不时生成它们,它会覆盖旧的。我不想在每一代之后手动更改每个类来实现接口。此外,对于从事同一项目的其他人,甚至在一段时间后对我来说,这可能并不明显。
这是第一堂课:

public class NumberGeneratorApple {
    public Integer getNumber(){
        return 9;
    }
}  

第二个:

public class NumberGeneratorOrange {
    public Integer getNumber(){
        return 19;
    }
}

虽然它们没有实现相同的接口,但我需要以通用方式使用它们。我只想做这样的事情:

public class ClassThatOperates<T extends NumberGeneratorInterface> {
    T generator;

    public ClassThatOperates(T generator) {
        this.generator = generator;
    }

    public void doSomeOperation(){
        //Obviously it won't work for NumberGeneratorApple and NumberGeneratorOrange
        // because they do not implement NumberGeneratorInterface
        //And if I change "<T extends NumberGeneratorInterface>" to "<T>"
        // I cannot write method call "generator.getNumber()"
        System.out.print("The number with constant is: ");
        System.out.println(generator.getNumber() + 5);
    }
}

这是接口(我知道 public 在那里没有必要,默认情况下它就在那里。我只是想强调一下):

public interface NumberGeneratorInterface {
    public Integer getNumber();
}

如您所见,这是不可能的,因为NumberGeneratorApple 和NumberGeneratorOrange 都没有实现NumberGeneratorInterface。然而,我想出了一些解决方案,但按照我的直觉,我认为它相当糟糕。我制作了包装类:

public class NumberGeneratorAppleWrapper extends NumberGeneratorApple implements NumberGeneratorInterface {
}

和

public class NumberGeneratorOrangeWrapper extends NumberGeneratorOrange implements NumberGeneratorInterface {
}

这有点棘手。一开始可能并不明显,但是当您在其中一个类的对象上调用 getNumber() 时,实际上您调用的是这样的:

@Override
public Integer getNumber() {
    return super.getNumber();
}

现在我可以这样称呼它了:

public class Main {
    public static void main(String[] args) {
        ClassThatOperates<NumberGeneratorAppleWrapper> classThatOperatesApple = new ClassThatOperates<>(new NumberGeneratorAppleWrapper());
        ClassThatOperates<NumberGeneratorOrangeWrapper> classThatOperatesOrange = new ClassThatOperates<>(new NumberGeneratorOrangeWrapper());
        classThatOperatesApple.doSomeOperation();
        classThatOperatesOrange.doSomeOperation();
    }
}

我得到以下输出:

The number with constant is: 14
The number with constant is: 24

这种方法而不是手动添加implements NumberGeneratorInterface 到每个生成的类的优点是我们不必在每一代之后重复相同的工作(这会覆盖旧类)。当生成产生一些新的附加类时,我们只需要添加一个新的包装器。

我知道在这种情况下,我可以摆脱 ClassThatOperates 中的泛型,只声明 NumberGeneratorInterface generator; 而没有 &lt;T extends...&gt; 等等(我什至应该这样做)所以代码会更简单,但我想做这个例子与我在一些实际项目中发现的非常相似。我写道:我有,我做了,我想出了等等,但实际上它是基于我在某个项目中找到的已经存在的代码。

有我的问题:
1.有没有更好的解决方案?
2.这个解决方案是不是所谓的“坏味道”?
3. 如果我必须使用这样的解决方案,也许我的整个方法是错误的?
4. 如果即使整个方法都错了也没有更好的解决方案,那么这段代码可以改进什么(包括摆脱泛型)?

【问题讨论】:

  • 你也可以使用反射。但是不确定这是否比您的方法更好
  • 可能反射是一种方法,但我认为它可能非常复杂,结果比这种方法更糟糕,尤其是在代码的清洁度方面。

标签: java generics interface java-8


【解决方案1】:

考虑:

class ClassThatOperates
{
    final Supplier<Integer> m_generator;

    ClassThatOperates(Supplier<Integer> generator)
    {
        m_generator = generator;
    }
    void doSomething()
    {
        ...
        m_generator.get();
    }
}

NumberGeneratorApple nga = new NumberGeneratorApple();
ClassThatOperates cta = new ClassThatOperates(nga::generate);

【讨论】:

  • 您的解决方案很好,但仅限于这种简化的情况。在我的真实案例中,NumberGeneratorApple 和 NumberGeneratorApple 中有许多类似的方法,使用这样的解决方案可能没有意义。然而,这个答案是正确的,可能会帮助其他有类似问题的人。
  • 在这种情况下,您的解决方案还不错,但您可能希望通过构造像 NumberGenerator ng = new NumberGeneratorApple implements NumberGenerator {}; 这样的匿名类来避免定义所有这些适配器类,Java 将识别您在 NumberGeneratorApple 中拥有的内容作为什么的实现你需要在NumberGenerator
【解决方案2】:
  1. 有更好的解决方案吗?

您的解决方案对我来说看起来不错。您使用了Adapter Pattern,它使用现有功能来符合其他不相关的接口。在不更改 NumberGeneratorApple 和 NumberGeneratorOrange 的情况下,您已将这些类的功能调整为 NumberGeneratorInterface。

更一般地说,您可以使具有不同签名的现有方法适应接口,例如如果你有

public class NumberGeneratorApple {
    public Integer getAppleNumber(){
        return 9;
    }
}

那么你的适配器类会在实现接口时显式调用getAppleNumber。

public class NumberGeneratorAppleWrapper extends NumberGeneratorApple implements NumberGeneratorInterface {
    @Override
    public Integer getNumber() {
        return getAppleNumber();
    }
}
  1. 这个解决方案是不是所谓的“坏味道”?

这种解决方案不会留下不好的味道。适配器模式是一种成熟的软件设计模式。

  1. 如果我必须使用这样的解决方案,也许我的整个方法都是错误的?

如果您无法更改现有的类,例如NumberGeneratorApple,那么适配器模式就是您的选择。如果您可以更改它们,那么只需让类直接实现必要的接口即可。

public class NumberGeneratorApple implements NumberGeneratorInterface {
    @Override
    public Integer getNumber() {
        return 9;
    }
}

或者,如果方法签名不同:

public class NumberGeneratorApple implements NumberGeneratorInterface {
    public Integer getAppleNumber() {
        return 9;
    }

    @Override
    public Integer getNumber() {
        return getAppleNumber();
    }
}
  1. 如果即使整个方法都错了也没有更好的解决方案,那么这段代码可以改进什么(包括摆脱泛型)?

如果您的类(例如NumberGeneratorApple)确实只有一个方法,并且不仅仅是为了解决这个问题而简化了具有多种方法的更复杂的类,那么您可以使用方法引用作为另一个答案的暗示。可以将方法引用键入为Supplier&lt;Integer&gt;,而不是声明您自己的接口NumberGeneratorInterface。

public class ClassThatOperates {
    Supplier<Integer> generator;

    public ClassThatOperates(Supplier<Integer> generator) {
        this.generator = generator;
    }

    public void doSomeOperation(){
        System.out.print("The number with constant is: ");
        System.out.println(generator.get() + 5);
    }
}

那么你可以把它当作:

NumberGeneratorOrange ngo = new NumberGeneratorOrange();
ClassThatOperates cto = new ClassThatOperates(ngo::getNumber);
cto.doSomeOperation();

【讨论】:

  • Ad 4. 如果类中只有一个方法,例如NumberGeneratorApple,则此解决方案是有意义的。但正如您所指出的,此示例只是对更复杂情况的简化,在这种情况下,此类类具有多个要调整的方法。所以在我的真实情况下,不能使用这样的解决方案。感谢您提到此供应商解决方案只能在特定场景中使用。
【解决方案3】:

使用 java8,您可以实例化您的自定义类之一

NumberGeneratorApple apple = new NumberGeneratorApple();

并从中创建一个通用供应商:

Supplier<Integer> numberGenerator = apple::getNumber;

然后你可以传递它或用它做任何你需要的事情:

Integer number = numberGenerator.get();
externalObject.execute(numberGenerator);

听起来怎么样?

【讨论】:

  • 您的解决方案很好,但仅限于这种简化的情况。在我的真实案例中,NumberGeneratorApple 和 NumberGeneratorApple 中有许多类似的方法,使用这样的解决方案可能没有意义。然而,这个答案是正确的,可以帮助其他有类似问题的人。
  • 那么没有通用接口或父类就没有自动解决方案。无论您选择哪种方法,您都需要分别处理每种编码方法。因此,例如创建一个 Generator 类并通过为它们提供功能接口实现(Functions、Suppliers、Consumers ..)来实现所有这些方法,或者使用组合并将所有调用委托给此类内部的实现对象(NumberGeneratorApple)使用反射.更多关于反射 API docs.oracle.com/javase/tutorial/reflect/member/methodInvocation.html
  • 我上面评论中建议的解决方案将适用于每个新生成的类,使用适配器模式会有额外的工作 - 显式地调整每个生成的类
  • 我同意这个解决方案甚至适用于更复杂的情况。但是假设我们有五种方法。在这种情况下,我们必须将五个参数传递给构造函数。这有点太多了,如果所有或部分参数具有相同的类型,假设 Supplier 我们可能会不小心以错误的顺序传递它们。主类负责适配器将调用重定向到适当的方法。它甚至可能违反单一职责原则。所以最好隐藏适配器类中的所有内容并只将一个参数传递给构造函数。你怎么看?
  • 也许使用构建器模式会有所帮助,因此创建可能如下所示: Generator gen=new Generator.Builder().withNumberGen(apple::getNumber).withFeature2(apple::feature2).withFeature3(apple ::feature3).build();
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2018-11-04
  • 1970-01-01
  • 1970-01-01
  • 2015-03-11
  • 1970-01-01
  • 2013-02-28
  • 2011-07-26
相关资源
最近更新 更多