Question

是否可以在界面中创建内部类？如果可能的话，我们为什么要创建一个像这样的内部类我们不打算创建任何接口对象？

这些内部类是否有助于任何开发过程？

Answer 1

是的，我们可以在接口内部使用类。使用的一个例子可能是

public interface Input
{
    public static class KeyEvent {
         public static final int KEY_DOWN = 0;
         public static final int KEY_UP = 1;
         public int type;
         public int keyCode;
         public char keyChar;
    }
    public static class TouchEvent {
         public static final int TOUCH_DOWN = 0;
         public static final int TOUCH_UP = 1;
         public static final int TOUCH_DRAGGED = 2;
         public int type;
         public int x, y;
         public int pointer;
    }
    public boolean isKeyPressed(int keyCode);
    public boolean isTouchDown(int pointer);
    public int getTouchX(int pointer);
    public int getTouchY(int pointer);
    public float getAccelX();
    public float getAccelY();
    public float getAccelZ();
    public List<KeyEvent> getKeyEvents();
    public List<TouchEvent> getTouchEvents();
}

这里的代码有两个嵌套类，用于封装有关事件对象的信息，这些事件对象稍后在方法定义中使用，如getKeyEvents（）。将它们放在Input界面内可以提高内聚力。

Answer 2

有效使用IMHO定义了封闭接口方法接收或返回的对象。数据保持结构。通过这种方式，如果对象仅用于该接口，则可以使用更具凝聚力的方式。

以示例：

interface UserChecker {
   Ticket validateUser(Credentials credentials);

   class Credentials {
      // user and password
   }

   class Ticket {
      // some obscure implementation
   }
}

但无论如何......这只是品味问题。

Answer 3

是的，你可以在Java界面中创建嵌套类或内部类（请注意，与流行的看法相反，没有“静态内部类“：这根本没有意义，当嵌套类是静态的时，没有”内部“和”外部“类，所以它不能是”静态内部“。

无论如何，下面的编译很好：

public interface A { class B { } }

我已经看到它曾经在接口定义中直接放置某种“合同检查器”（好吧，在嵌套在接口中的类中，可以有静态方法，与接口本身相反，这不能）。如果我没记错的话就是这样。

public interface A { static class B { public static boolean verifyState( A a ) { return (true if object implementing class A looks to be in a valid state) } } }

请注意，我不是在评论这种事情的用处，我只是回答你的问题：它可以完成，这是我见过的一种用法。

现在我不会评论这种构造的有用性，并且从我看到过：我已经看过了，但它不是一个非常常见的构造。

200KLOC代码库这里恰好发生了零时间（但后来我们还有很多其他事情，我们认为不好的做法恰好发生在零时间，以至于其他人会发现完全正常......）。 p>

Answer 4

来自Java 7 spec：

的引用

接口可能包含成员类型声明（第8.5节）。

接口中的成员类型声明是隐式静态和公共的。允许冗余地指定其中一个或两个修饰符。

在Java接口中声明非静态类是不可能的，这对我来说很有意义。

Answer 5

一个有趣的用例是通过内部类为接口方法提供一种默认实现，如下所述：https://stackoverflow.com/a/3442218/454667（以克服单类继承的问题）。

Answer 6

这当然是可能的，并且我发现它有用的一个案例是接口必须抛出自定义异常。你可以使用相关的接口来保存异常，我认为它通常比乱七八糟的异常文件乱丢你的源代码树更整洁。

interface MyInterface {

   public static class MyInterfaceException extends Exception {
   }

   void doSomething() throws MyInterfaceException;
}

Answer 7

是的，可以在接口内部使用静态类定义，但是这个功能最有用的方面可能是使用枚举类型（这是一种特殊的静态类）。例如，你可以这样：

public interface User {
    public enum Role {
        ADMIN("administrator"),
        EDITOR("editor"),
        VANILLA("regular user");

        private String description;

        private Role(String description) {
            this.description = description;
        }

        public String getDescription() {
            return description;
        }
    }

    public String getName();
    public void setName(String name);
    public Role getRole();
    public void setRole(Role role);
    ...
}

Answer 8

@Bachi提到的内容类似于Scala中的特征，实际上是使用接口内的嵌套类实现的。这可以用Java模拟。另请参阅java traits or mixins pattern?

Answer 9

Maybe when you want more complex constructions like some different implementation behaviours, consider:

    public interface A {
    public void foo();
    public static class B implements A{
        @Override
        public void foo(){
            System.out.println("B foo");
        }
    }
}

This is your interface and this will be the implementee:

    public class C implements A {
    @Override
    public void foo(){ A.B b = new A.B(); b.foo(); }


    public static void main(String[] strings) {
        C c = new C();
        c.foo();
    }
}

May provide some static implementations, but won't that be confusing, I don't know.

Answer 10

我找到了这种结构的用途。

您可以使用此构造来定义和分组所有静态最终常量。
因为，它是一个可以在类上实现它的接口。

您可以访问所有已分组的常量;在这种情况下，类的名称充当命名空间。

Answer 11

You can also create "Helper" static classes for common functionality for the objects that implement this interface:

public interface A {
    static class Helper {
        public static void commonlyUsedMethod( A a ) {
           ...
        }
    }
}

Answer 12

我现在需要一个。我有一个接口，可以方便地从它的几个方法中返回一个唯一的类。这个课程才有意义作为此接口方法响应的容器。

因此，有一个静态嵌套类定义是很方便的，它只与这个接口相关联，因为这个接口应该是创建这个结果容器类的唯一地方。

Answer 13

例如，Groovy中的traits（与实现方法的接口类似）。它们被编译为一个接口，该接口包含实现所有方法的内部类。

Interface中的内部类

13 个答案: