Posso creare l'oggetto per l'interfaccia?

Question

E 'possibile creare oggetti per un'interfaccia, se sì come possiamo? secondo il mio punto di vista il seguente codice dice che possiamo:

Runnable r= new Runnable(){ // some implementation }

Answer 1

Non è possibile creare un'istanza di un'interfaccia direttamente, ma è possibile creare un'istanza di una classe che implementa l'interfaccia:

public class RunClass implements Runnable { 
    // Class implementation 
} 

Runnable r = new RunClass(); 

Questo è fondamentalmente uguale a quello che stai facendo in linea. Le parentesi dopo il nuovo Runnable() conterranno la tua implementazione in linea.

Answer 2

Questo non sta creando l'istanza di Interfaccia, ma sta creando una classe che implementa l'interfaccia. Quindi Quando si scrive

Runnable runnable = new Runnable() { 

     @Override 
     public void run() { 
      // TODO Auto-generated method stub 

     } 
    }; 

In realtà si sta creando una classe che sta implementando l'interfaccia Runnable. È necessario seguire tutte le regole qui, qui, stiamo override del metodo di esecuzione per Runnable

There is similar thing for abstract class also. We can test using an example 

public abstract class AbstractClass { 

    public void someMethod(){ 
     System.out.println("abstract class"); 
    } 

} 

e un altro esempio di classe TestClass

public class TestClass { 

    public static void main(String[] args) { 

     AbstractClass abstractClass = new AbstractClass() { 
      public void someMethod() { 
       System.out.println("concrete class method"); 
      } 
     }; 
     abstractClass.someMethod(); 
    } 
} 

Questo creerà l'istanza di una sottoclasse in cui ci troviamo sovrascrivendo someMethod(); Questo programma stampe

concrete class method 

Questo dimostra che stiamo creando l'istanza di sottoclasse.

Answer 3

È possibile creare oggetti per un'interfaccia?

No. Il codice che hai mostrato crea un oggetto da una classe anonima , che implementa l'interfaccia. Sotto le copertine, la JVM crea effettivamente una classe che implementa l'interfaccia e quindi crea un'istanza di quella classe.

---

La classe "anonimo" generato sarà in realtà hanno un nome, in base al nome della classe in cui compare questo codice, per esempio YourClass$1 o simili. Ad esempio:

public class AnonymousName { 
    public static final void main(String[] args) { 
     Runnable r = new Runnable() { 
      public void run() { 
      } 
     }; 

     System.out.println(r.getClass().getName()); 
    } 
} 

... uscite

AnonymousName$1

;

(almeno sulla JVM di Oracle non so se la convenzione di denominazione è nella JLS o se si tratta di un comportamento specifico per JVM).

Answer 4

non siamo in grado di instaziare l'interfaccia (dal momento che non hanno costruttore).

Answer 5

È possibile creare una classe interna anonima:

Runnable r = new Runnable() { 
    @Override 
    public void run() { 
    } 
}; 

Quindi si crea un nuovo class che implementa il data interface.

Answer 6

Quello che stai vedendo è un anonymous inner class.

sta creando un'istanza di un nuovo, anonimo, implementatore della classe Runnable.

Poiché una definizione di classe anonima è un'espressione, deve essere parte di una dichiarazione.