Klasa wewnętrzna w interfejsie

Tak, możemy mieć klasy wewnątrz interfejsów. Jednym z przykładów użycia może być

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();
}

Tutaj kod ma dwie zagnieżdżone klasy, które służą do hermetyzacji informacji o obiektach zdarzeń, które są później używane w definicjach metod, takich jak getKeyEvents(). Posiadanie ich wewnątrz interfejsu wejściowego poprawia spójność.

Poprawnym zastosowaniem, IMHO, jest definiowanie obiektów, które są odbierane lub zwracane przez metody interfejsu. Tipically Data holding structures. W ten sposób, jeśli obiekt jest używany tylko dla tego interfejsu, masz rzeczy w bardziej spójny sposób.

Przez przykład:

interface UserChecker {
   Ticket validateUser(Credentials credentials);

   class Credentials {
      // user and password
   }

   class Ticket {
      // some obscure implementation
   }
}

Cytat z Java 7 spec:

Interfejsy mogą zawierać deklaracje typu member (§8.5).

Deklaracja typu member w interfejsie jest domyślnie statyczna i publiczna. Dozwolone jest redundantne określanie jednego lub obu tych modyfikatorów.

Nie jest możliwe deklarowanie niestatycznych klas wewnątrz interfejsu Java, co ma dla mnie sens.

Interesującym przypadkiem użycia jest dostarczenie pewnego rodzaju domyślnej implementacji do metod interfejsu poprzez wewnętrzną klasę, jak opisano tutaj: https://stackoverflow.com/a/3442218/454667 (aby przezwyciężyć problem dziedziczenia jednoklasowego).

Z pewnością jest to możliwe, a jednym z przypadków, w którym uznałem to za przydatne, jest sytuacja, w której interfejs musi rzucać niestandardowe wyjątki. Zachowaj wyjątki z powiązanym interfejsem, który moim zdaniem jest często bardziej schludny niż zaśmiecanie drzewa źródłowego stertami trywialnych plików WYJĄTKÓW.

interface MyInterface {

   public static class MyInterfaceException extends Exception {
   }

   void doSomething() throws MyInterfaceException;
}

Tak, możliwe jest posiadanie statycznych definicji klas wewnątrz interfejsu, ale być może najbardziej przydatnym aspektem tej funkcji jest użycie typów enum (które są specjalnym rodzajem klas statycznych). Na przykład możesz mieć coś takiego:

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);
    ...
}

To, o czym wspomina @Bachi, jest podobne do cech w Scali i jest zaimplementowane przy użyciu zagnieżdżonej klasy wewnątrz interfejsu. Można to symulować w Javie. Zobacz też cechy Javy czy wzór mixins?

Może, jeśli chcesz bardziej złożonych konstrukcji, takich jak różne zachowania implementacyjne, rozważ:

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

To jest Twój interfejs i to będzie implementacja:

    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();
    }
}

Może dostarczyć jakieś statyczne implementacje, ale nie będzie to mylące, Nie wiem.

Znalazłem zastosowanie fir tego typu konstrukcji.

1. możesz użyć tego konstruktu do zdefiniowania i pogrupowania wszystkich statycznych stałych końcowych.
2. ponieważ jest to interfejs, który możesz zaimplementować na klasie.

Masz dostęp do wszystkich stałych pogrupowanych; nazwa klasy działa w tym przypadku jako przestrzeń nazw.

Można również tworzyć statyczne klasy "Helper" dla wspólnej funkcjonalności dla obiektów implementujących ten interfejs:

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

Potrzebuję go teraz. Mam interfejs, w którym wygodnie byłoby zwrócić unikalną klasę z kilku jego metod. Ta klasa ma tylko sens jako kontener odpowiedzi z metod tego interfejsu.

Stąd byłoby wygodne posiadanie statycznej, zagnieżdżonej definicji klasy, która jest powiązana tylko z tym interfejsem, ponieważ ten interfejs powinien być jedynym miejscem, w którym ta klasa kontenera results jest kiedykolwiek tworzona.

Na przykład traits (smth jak interfejs z zaimplementowanymi metodami) w Groovy. Są one kompilowane do interfejsu, który zawiera wewnętrzną klasę, w której zaimplementowane są wszystkie metody.