Dove è utile avere classi nidificate in un'interfaccia?

Question

In quale scenario è possibile che un'interfaccia abbia classi nidificate?

Il seguente codice è consentito e valido.

public interface Iface { 

    void show(); 

    class ifaceClass { 
     int x; 

     public ifaceClass() { 
      System.out.println(x); 
     } 
    } 
} 

sto anche lottando per fare oggetto della classe ifaceClass.

EDIT:

sono in grado di fare oggetto come questo

public class Test implements Iface {  

    public static void main(String[] args){ 
     ifaceClass ifaceClassObj = new ifaceClass(); 
    } 

    public void show() {  

    } 
} 

ho notato se Test non ha attuato il Iface poi ho bisogno di seguente importazione,

import com.jls.Iface.ifaceClass; 

Ma si è ridotto allo stesso problema, perché non usarlo come una semplice classe.

Quale differenza o valore aggiunto con questo approccio?

Answer 1

Dove è utile avere classi nidificate in un'interfaccia?

non c'è nessun caso tale che può solo essere soddisfatti con classe interna dell'interfaccia. È sintatticamente valido avere un'interfaccia di classe interna e per la classe che implementa l'interfaccia può creare un'istanza di classe e, a parte questo, Interface.Class può rendere accessibile quella classe perché non può essere affatto private.

ho notato se prova non ha attuato l'Iface poi ho bisogno seguente importazione import com.jls.Iface.ifaceClass;

Non necessariamente, se l'interfaccia è accessibile la classe interna diventerà automaticamente accessible.Here si sta tentando di accedere classe direttamente senza nemmeno importare interface in questo caso la seguente dichiarazione deve avere una dichiarazione di importazione superiore.

ifaceClass ifaceClassObj = new ifaceClass(); 

Ma ridusse a stesso problema che perché non usarlo come un solo un'altra classe.Quale la differenza o valore aggiunto di questo approccio

Esattamente, la creazione di un'altra classe può anche fornire la stessa struttura e non ho mai visto alcun caso d'uso nel mio giorno di programmazione al giorno, che può essere soddisfatta solo con classe interna di interfaccia. Non fornisce nient'altro che l'accessibilità attraverso l'interfaccia.

L'ho usato una volta che penso piuttosto un cattiva pratica però. Un giorno dobbiamo implementare un metodo comune in diverse classi che sono l'interfaccia di implementazione dire X e volevamo aggiungere un metodo extra da utilizzare per tutte queste classi per aggiungere un tipo di controllo sullo Object che controlla solo alcuni parametri e restituisce boolean anche se tale caso d'uso può essere soddisfatto in altro modo, ma per essere specifico che è destinato solo alle classi che stanno implementando questa interfaccia, abbiamo aggiunto l'interfaccia di classe in modo che possiamo fornire quel metodo per implementare le classi. (NOTA: Al giorno d'oggi di default metodo può essere usato in questo caso al posto di classe interna)

Qui, è bene notare che in grandi progetti è del tutto impossibile per chiunque (diverso creatore) da notare che qualsiasi interfaccia ha classe interiore. Quindi, finché non implementiamo quella classe o controlliamo manualmente l'interfaccia, non possiamo sapere che l'interfaccia ha una classe interna.

Answer 2

È possibile creare un'istanza di ifaceClass all'interno della classe che implementa Iface:

interface Iface { 
    void show(); 
    class ifaceClass { 
     int x; 
     public ifaceClass() { 
      System.out.println(x); 
     } 
    } 
} 

public class Test implements Iface { 

    public static void main(String args[]) { 
     ifaceClass iface = new ifaceClass(); 
    } 

    @Override 
    public void show() { 
     // ... 
    } 
} 

Se la classe non implementa l'interfaccia, basta creare un'istanza in questo modo:

Iface.ifaceClass iface = new Iface.ifaceClass(); 

Perché creare una classe all'interno di un'interfaccia? Fondamentalmente per lo stesso motivo per cui si crea una classe all'interno di un'altra classe, per raggruppare insieme le classi correlate.