TechCodeview

1. Interfaccia
2. Esempio di interfaccia
3. Ereditarietà multipla per interfaccia
4. Perché l'ereditarietà multipla è supportata nell'interfaccia mentre non è supportata in caso di classe.
5. Interfaccia marcatore
6. Interfaccia nidificata

UN interfaccia in Java è un progetto di una classe. Ha costanti statiche e metodi astratti.

L'interfaccia in Java è un meccanismo per raggiungere astrazione . Possono esserci solo metodi astratti nell'interfaccia Java, non il corpo del metodo. Viene utilizzato per ottenere astrazione e multiplo eredità in Java .

In altre parole, si può dire che le interfacce possono avere metodi e variabili astratti. Non può avere un corpo del metodo.

Anche l'interfaccia Java rappresenta la relazione IS-A .

Non può essere istanziato proprio come la classe astratta.

A partire da Java 8, possiamo avere metodi predefiniti e statici in un'interfaccia.

A partire da Java 9, possiamo avere metodi privati in un'interfaccia.

espressione regolare Java $

Perché utilizzare l'interfaccia Java?

Ci sono principalmente tre ragioni per utilizzare l'interfaccia. Sono riportati di seguito.

• Viene utilizzato per ottenere l'astrazione.
• Tramite l'interfaccia, possiamo supportare la funzionalità dell'ereditarietà multipla.
• Può essere utilizzato per ottenere un accoppiamento lasco.

Come dichiarare un'interfaccia?

Un'interfaccia viene dichiarata utilizzando la parola chiave Interface. Fornisce un'astrazione totale; significa che tutti i metodi in un'interfaccia sono dichiarati con il corpo vuoto e tutti i campi sono pubblici, statici e finali per impostazione predefinita. Una classe che implementa un'interfaccia deve implementare tutti i metodi dichiarati nell'interfaccia.

Sintassi:

 interface { // declare constant fields // declare methods that abstract // by default. } 

Miglioramento dell'interfaccia Java 8

Da Giava8 , l'interfaccia può avere metodi predefiniti e statici che verranno discussi più avanti.

Aggiunta interna da parte del compilatore

Il compilatore Java aggiunge parole chiave pubbliche e astratte prima del metodo dell'interfaccia. Inoltre, aggiunge parole chiave pubbliche, statiche e finali prima dei membri dati.

In altre parole, i campi dell'interfaccia sono pubblici, statici e finali per impostazione predefinita, mentre i metodi sono pubblici e astratti.

La relazione tra classi e interfacce

Come mostrato nella figura riportata di seguito, una classe estende un'altra classe, un'interfaccia estende un'altra interfaccia, ma a la classe implementa un'interfaccia .

Esempio di interfaccia Java

In questo esempio, l'interfaccia Printable ha un solo metodo e la sua implementazione è fornita nella classe A6.

 interface printable{ void print(); } class A6 implements printable{ public void print(){System.out.println('Hello');} public static void main(String args[]){ A6 obj = new A6(); obj.print(); } } 

Produzione:

 Hello 

Esempio di interfaccia Java: drawable

In questo esempio, l'interfaccia Drawable ha un solo metodo. La sua implementazione è fornita dalle classi Rectangle e Circle. In uno scenario reale, un'interfaccia è definita da qualcun altro, ma la sua implementazione è fornita da diversi fornitori di implementazione. Inoltre, viene utilizzato da qualcun altro. La parte di implementazione è nascosta dall'utente che utilizza l'interfaccia.

File: TestInterface1.java

 //Interface declaration: by first user interface Drawable{ void draw(); } //Implementation: by second user class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class Circle implements Drawable{ public void draw(){System.out.println('drawing circle');} } //Using interface: by third user class TestInterface1{ public static void main(String args[]){ Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable() d.draw(); }} 

Produzione:

 drawing circle 

Esempio di interfaccia Java: Banca

Vediamo un altro esempio di interfaccia Java che prevede l'implementazione dell'interfaccia Bank.

File: TestInterface2.java

 interface Bank{ float rateOfInterest(); } class SBI implements Bank{ public float rateOfInterest(){return 9.15f;} } class PNB implements Bank{ public float rateOfInterest(){return 9.7f;} } class TestInterface2{ public static void main(String[] args){ Bank b=new SBI(); System.out.println('ROI: '+b.rateOfInterest()); }} 

Produzione:

 ROI: 9.15 

Ereditarietà multipla in Java per interfaccia

Se una classe implementa più interfacce o un'interfaccia estende più interfacce, si parla di ereditarietà multipla.

css per centrare un'immagine

 interface Printable{ void print(); } interface Showable{ void show(); } class A7 implements Printable,Showable{ public void print(){System.out.println('Hello');} public void show(){System.out.println('Welcome');} public static void main(String args[]){ A7 obj = new A7(); obj.print(); obj.show(); } } 

 Output:Hello Welcome 

D) L'ereditarietà multipla non è supportata tramite la classe in Java, ma è possibile tramite un'interfaccia, perché?

Come spiegato nel capitolo sull'ereditarietà, l'ereditarietà multipla non è supportata nel caso di classe a causa dell'ambiguità. Tuttavia, è supportato nel caso di un'interfaccia poiché non vi è alcuna ambiguità. È perché la sua implementazione è fornita dalla classe di implementazione. Per esempio:

 interface Printable{ void print(); } interface Showable{ void print(); } class TestInterface3 implements Printable, Showable{ public void print(){System.out.println('Hello');} public static void main(String args[]){ TestInterface3 obj = new TestInterface3(); obj.print(); } } 

Produzione:

 Hello 

Come puoi vedere nell'esempio sopra, le interfacce Printable e Showable hanno gli stessi metodi ma la sua implementazione è fornita dalla classe TestTnterface1, quindi non c'è ambiguità.

Eredità dell'interfaccia

Una classe implementa un'interfaccia, ma un'interfaccia estende un'altra interfaccia.

 interface Printable{ void print(); } interface Showable extends Printable{ void show(); } class TestInterface4 implements Showable{ public void print(){System.out.println('Hello');} public void show(){System.out.println('Welcome');} public static void main(String args[]){ TestInterface4 obj = new TestInterface4(); obj.print(); obj.show(); } } 

Produzione:

 Hello Welcome 

Metodo predefinito Java 8 nell'interfaccia

A partire da Java 8, possiamo avere il corpo del metodo nell'interfaccia. Ma dobbiamo renderlo il metodo predefinito. Vediamo un esempio:

File: TestInterfaceDefault.java

 interface Drawable{ void draw(); default void msg(){System.out.println('default method');} } class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class TestInterfaceDefault{ public static void main(String args[]){ Drawable d=new Rectangle(); d.draw(); d.msg(); }} 

Produzione:

 drawing rectangle default method 

Metodo statico Java 8 nell'interfaccia

A partire da Java 8, possiamo avere un metodo statico nell'interfaccia. Vediamo un esempio:

File: TestInterfaceStatic.java

 interface Drawable{ void draw(); static int cube(int x){return x*x*x;} } class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class TestInterfaceStatic{ public static void main(String args[]){ Drawable d=new Rectangle(); d.draw(); System.out.println(Drawable.cube(3)); }} 

Produzione:

 drawing rectangle 27 

D) Che cos'è l'interfaccia marcatore o taggata?

Un'interfaccia che non ha membri è nota come marcatore o interfaccia con tag, ad esempio, Serializzabile , Clonabile, Remoto, ecc. Vengono utilizzati per fornire alcune informazioni essenziali alla JVM in modo che JVM possa eseguire alcune operazioni utili.

 //How Serializable interface is written? public interface Serializable{ } 

Interfaccia nidificata in Java

Nota: un'interfaccia può avere un'altra interfaccia nota come interfaccia nidificata. Lo impareremo in dettaglio nel classi annidate capitolo. Per esempio:

 interface printable{ void print(); interface MessagePrintable{ void msg(); } }