当某些类的接口方法的实现相同时，您如何处理？

Question

假设我已经使用方法 foo 和 bar 定义了接口 ISomeInterface。
例如。

public interface ISomeInterface {  
    public void foo();  
    public void bar();  
} 

假设我有 A 和 B 类，对它们来说，实现接口是有意义的。但是为foo() 设置不同的实现也没有任何意义。
考虑到从 B 派生 A 或从 A 派生 B 是不正确/奇怪的，这种设计是否有标准的编码实践？
我假设我可以创建一些实用程序类来实现foo() 并将其作为委托调用，但我想知道是否可以以不同方式处理整个结构

更新：
为了充分理解我的问题，我偶然发现了这个：http://perlbuzz.com/2010/07/why-roles-in-perl-are-awesome.html，我试图了解我们在 Java 中使用传统 OO 概念时是否缺少此功能

Answer 1

您的编辑表明您的真正问题是：“Java 中的 Perl 角色是否有等价物？”

由于 Java 8 在接口中引入了default 方法，具有默认方法的接口似乎非常适合角色。特别是，您可以在示例中做您想做的事情：为foo() 提供默认实现：

interface ISomeInterface {
    public default void foo(){ /* your default impl goes here */}
    public void bar(); // Abstract, must be implemented by subclasses
}

class A implements ISomeInterface {
    // must only implement bar, can reuse foo's default impl
}

class B implements ISomeInterface {
    // must only implement bar, can reuse foo's default impl
}

如果我缺少有关角色的功能，请告诉我。否则，我认为 Java8 接口可以很好地替代角色。

Answer 2

决定把我的评论变成答案：

您可以使用抽象类而不是接口：

    public abstract class FooBar {  
        public void foo(){
       //your implementation goes here  
        }

        abstract void bar();  
    } 

    public class A extends FooBar{

        @Override
        public void bar(){

        }
    }

Answer 3

为什么不这样：

public class abstract SomeAbstractClass {  
    public void foo(){
       //implementation
    }  
    public abstract void bar();  
} 

class A extends SomeAbstractClass {

}

class B extends SomeAbstractClass {

}

Answer 4

public abstract class SomeClass implements ISomeInterface {
    public void foo() {
        // I do stuff..
    }
}

public class A extends SomeClass {
    public void bar() {
        // A specific impl. of bar..
    }
}

public class B extends SomeClass {
    public void bar() {
        // B specific impl. of bar..
    }
}

Answer 5

或者，如果您不想通过扩展抽象类来捆绑 A 和 B，则可以使用组合。如果您要将FooImpl 作为构造函数的一部分注入，这也提供了在运行时更改IFoo 行为的灵活性。在这个例子中，为了简洁起见，我只是硬连线了FooImpl。

public class B implements ISomeInterface {

    private IFoo foo = new FooImpl();

    public void foo() {
        foo.doSomethingFooey();
    }

    public void bar() {
        // B specific implementation        
    }
}

public class A implements ISomeInterface {

    private IFoo foo = new FooImpl();

    public void foo() {
        foo.doSomethingFooey();
    }

    public void bar() {
        // A specific implementation
    }
}