在 Java 中在接口中定义类的能力的实用方面是什么？

Question

在 Java 中在接口中定义类的能力有什么实际意义：

interface IFoo
{
    class Bar
    {
        void foobar ()
        {
            System.out.println("foobaring...");
        }
    }
}

Answer 1

我可以想到 Eric P 链接之外的另一种用法：定义接口的默认/无操作实现。

./alex

interface IEmployee
{

    void workHard ();  
    void procrastinate ();

    class DefaultEmployee implements IEmployee 
    {
        void workHard () { procrastinate(); };
        void procrastinate () {};
    }

}

另一个示例 - 空对象模式的实现：

interface IFoo
{
    void doFoo();
    IFoo NULL_FOO = new NullFoo();

    final class NullFoo implements IFoo
    {
        public void doFoo () {};
        private NullFoo ()  {};
    }
}


...
IFoo foo = IFoo.NULL_FOO;
...
bar.addFooListener (foo);
...

Answer 2

我认为此页面 很好地解释了一个例子。 您可以使用它将某种类型紧密绑定到接口。

无耻地从上面的链接中窃取：

interface employee{
    class Role{
          public String rolename;
          public int roleId;
     }
    Role getRole();
    // other methods
}

在上面的界面中，您将角色类型强绑定到员工界面（employee.Role）。

Answer 3

一种用途（无论好坏）是作为 Java 不支持接口中的静态方法这一事实的解决方法。

interface Foo {
    int[] getData();

    class _ {
        static int sum(Foo foo) {
            int sum = 0;
            for(int i: foo.getData()) {
                sum += i;
            }
            return sum;
        }
    }
}

然后你可以这样调用它：

int sum = Foo._.sum(myFoo);

Answer 4

我可以毫不犹豫地说我从来没有这样做过。 我也想不出你会这样做的理由。 类嵌套在类中？ 当然，这样做有很多理由。 在这些情况下，我倾向于将这些内部类视为实现细节。 显然，接口没有实现细节。

Answer 5

这一习惯用法大量使用的地方是 XMLBeans。 该项目的目的是获取 XML 模式并生成一组 Java 类，您可以使用这些类双向处理与该模式相对应的 XML 文档。 因此，它允许您将 XML 解析为 xml bean 或创建 xml bean 并输出到 xml。

一般来说，大多数 xml 模式类型都映射到 Java 接口。 该接口内部有一个工厂，用于在默认实现中生成该接口的实例：

public interface Foo extends XmlObject {
  public boolean getBar();
  public boolean isSetBar();
  public void setBar(boolean bar);

  public static final SchemaType type = ...

  public static final class Factory {
    public static Foo newInstance() {
      return (Foo)XmlBeans.getContextTypeLoader().newInstance(Foo.type, null);
    }

    // other factory and parsing methods
  }
} 

当我第一次遇到这种情况时，将所有这些实现垃圾绑定到接口定义中似乎是错误的。 然而，我实际上越来越喜欢它，因为它让一切都根据接口来定义，但有一个统一的方法来获取接口的实例（而不是有另一个外部工厂/构建器类）。

我为那些有意义的类（特别是那些我对接口/实现有很大控制权的类）选择了它，并发现它相当干净。

Answer 6

我想您可以定义一个类，用作接口内方法的返回类型或参数类型。 好像不是特别有用。 您不妨单独定义类。 唯一可能的优点是它在某种意义上将类声明为“属于”接口。

Answer 7

Google Web Toolkit 使用此类将“普通”接口绑定到异步调用接口：

public interface LoginService extends RemoteService {

    /**
     * Utility/Convenience class.
     * Use LoginService.App.getInstance() to access static instance of LoginServiceAsync
     */
    class App {

        public static synchronized LoginServiceAsync getInstance() {
            ...
        }
    }
}

Answer 8

通过接口内的静态类，您可以缩短常见的编程片段：检查对象是否是接口的实例，如果是，则调用该接口的方法。 看这个例子：

public interface Printable {
    void print();

    public static class Caller {
        public static void print(Object mightBePrintable) {
            if (mightBePrintable instanceof Printable) {
                ((Printable) mightBePrintable).print();
            }
        }
    }
}

现在

void genericPrintMethod(Object obj) {
    if (obj instanceof Printable) {
        ((Printable) obj).print();
    }
}

你可以写：

void genericPrintMethod(Object obj) {
   Printable.Caller.print(obj);
}

Answer 9

这样做似乎写满了“糟糕的设计决策”。

Answer 10

每当创建非私有嵌套类看起来是个好主意时，我都会敦促您谨慎行事。 几乎可以肯定，直接进入外部班级会更好。 但是，如果您要创建一个公共嵌套类，那么将其放在接口中似乎并不比放在类中更奇怪。 外部类的抽象性与嵌套类的抽象性不一定相关。

Answer 11

这种方法可用于在同一文件中定义多个类。 这在过去对我来说效果很好，我有很多简单的接口实现。 但是，如果我再次这样做，我会使用一个实现接口的枚举，这将是一个更优雅的解决方案。