UN Interfaccia in Java il linguaggio di programmazione è definito come un tipo astratto utilizzato per specificare il comportamento di una classe. Un'interfaccia in Java è un modello di comportamento. Un'interfaccia Java contiene costanti statiche e metodi astratti.

Cosa sono le interfacce in Java?

L'interfaccia in Java è UN meccanismo da raggiungere astrazione . Possono esserci solo metodi astratti nell'interfaccia Java, non il corpo del metodo. Viene utilizzato per ottenere l'astrazione e eredità multiple in Java utilizzando l'interfaccia . 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 .

Quando decidiamo un tipo di entità in base al suo comportamento e non tramite attributi, dovremmo definirla come un'interfaccia.

Sintassi per le interfacce Java

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

Per dichiarare un'interfaccia, utilizzare la parola chiave Interface. Viene utilizzato per fornire un'astrazione totale. Ciò significa che tutti i metodi in un'interfaccia sono dichiarati con un corpo vuoto e sono pubblici 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. Per implementare l'interfaccia, utilizzare la parola chiave implements.

elenco degli stati

Usi delle interfacce in Java

Gli usi delle interfacce in Java sono menzionati di seguito:

• Viene utilizzato per ottenere l'astrazione totale.
• Poiché Java non supporta eredità multiple nel caso della classe, utilizzando un'interfaccia è possibile ottenere eredità multiple.
• Qualsiasi classe può estendere solo 1 classe, ma qualsiasi classe può implementare un numero infinito di interfacce.
• Viene utilizzato anche per ottenere un accoppiamento lasco.
• Le interfacce vengono utilizzate per implementare l'astrazione.

Quindi sorge la domanda: perché utilizzare le interfacce quando abbiamo classi astratte?

Il motivo è che le classi astratte possono contenere variabili non finali, mentre le variabili nell'interfaccia sono finali, pubbliche e statiche.

// A simple interface interface Player {  final int id = 10;  int move(); }>

Relazione tra classe e interfaccia

Una classe può estendere un'altra classe simile a questa un'interfaccia può estendere un'altra interfaccia. Ma solo una classe può estendersi ad un'altra interfaccia e viceversa non è consentito.

Differenza tra classe e interfaccia

Sebbene Classe e Interfaccia sembrino uguali, esistono alcune differenze tra Classi e Interfaccia. Le principali differenze tra una classe e un'interfaccia sono menzionate di seguito:

Implementazione: Per implementare un'interfaccia, utilizziamo la parola chiave implementa

// Java program to demonstrate working of // interface import java.io.*; // A simple interface interface In1 {    // public, static and final  final int a = 10;  // public and abstract  void display(); } // A class that implements the interface. class TestClass implements In1 {    // Implementing the capabilities of  // interface.  public void display(){   System.out.println('Geek');   }  // Driver Code  public static void main(String[] args)  {  TestClass t = new TestClass();  t.display();  System.out.println(t.a);  } }>

Geek 10>

Esempi di interfacce Java

Consideriamo l'esempio di veicoli come biciclette, automobili, biciclette, ecc. Hanno funzionalità comuni. Quindi creiamo un'interfaccia e inseriamo tutte queste funzionalità comuni. E lascia che la bicicletta, la bici, l'auto ecc. implementino tutte queste funzionalità nella propria classe a modo loro.

Di seguito è riportata l'implementazione dell'argomento precedente:

// Java program to demonstrate the  // real-world example of Interfaces import java.io.*; interface Vehicle {    // all are the abstract methods.  void changeGear(int a);  void speedUp(int a);  void applyBrakes(int a); } class Bicycle implements Vehicle{    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  } } class Bike implements Vehicle {    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  }   } class GFG {    public static void main (String[] args) {    // creating an instance of Bicycle  // doing some operations  Bicycle bicycle = new Bicycle();  bicycle.changeGear(2);  bicycle.speedUp(3);  bicycle.applyBrakes(1);    System.out.println('Bicycle present state :');  bicycle.printStates();    // creating instance of the bike.  Bike bike = new Bike();  bike.changeGear(1);  bike.speedUp(4);  bike.applyBrakes(3);    System.out.println('Bike present state :');  bike.printStates();  } }>

Bicycle present state : speed: 2 gear: 2 Bike present state : speed: 1 gear: 1>

Vantaggi delle interfacce in Java

I vantaggi dell'utilizzo delle interfacce in Java sono i seguenti:

• Senza preoccuparci della parte di implementazione, possiamo raggiungere la sicurezza dell'implementazione.
• In Java non sono consentite eredità multiple, tuttavia è possibile utilizzare un'interfaccia per utilizzarla poiché è possibile implementare più di un'interfaccia.

Eredità multipla in Java utilizzando l'interfaccia

L'ereditarietà multipla è un concetto OOP che non può essere implementato in Java utilizzando le classi. Ma possiamo utilizzare più eredità in Java utilizzando Interface. verifichiamolo con un esempio.

Esempio:

// Java program to demonstrate How Diamond Problem // Is Handled in case of Default Methods // Interface 1 interface API {  // Default method  default void show()  {  // Print statement  System.out.println('Default API');  } } // Interface 2 // Extending the above interface interface Interface1 extends API {  // Abstract method  void display(); } // Interface 3 // Extending the above interface interface Interface2 extends API {  // Abstract method  void print(); } // Main class // Implementation class code class TestClass implements Interface1, Interface2 {  // Overriding the abstract method from Interface1  public void display()  {  System.out.println('Display from Interface1');  }  // Overriding the abstract method from Interface2  public void print()  {  System.out.println('Print from Interface2');  }  // Main driver method  public static void main(String args[])  {  // Creating object of this class  // in main() method  TestClass d = new TestClass();  // Now calling the methods from both the interfaces  d.show(); // Default method from API  d.display(); // Overridden method from Interface1  d.print(); // Overridden method from Interface2  } }>

Default API>

Nuove funzionalità aggiunte nelle interfacce in JDK 8

Sono state aggiunte alcune funzionalità alle interfacce nell'aggiornamento JDK 8 menzionate di seguito:

1. Prima di JDK 8, l'interfaccia non poteva definire l'implementazione. Ora possiamo aggiungere l'implementazione predefinita per i metodi di interfaccia. Questa implementazione predefinita ha un uso speciale e non influisce sull'intenzione dietro le interfacce.

Supponiamo di dover aggiungere una nuova funzione a un'interfaccia esistente. Ovviamente il vecchio codice non funzionerà poiché le classi non hanno implementato le nuove funzioni. Quindi, con l'aiuto dell'implementazione predefinita, forniremo un corpo predefinito per le funzioni appena aggiunte. Quindi i vecchi codici funzioneranno ancora.

Di seguito è riportata l’implementazione del punto precedente:

// Java program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  default void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  TestClass t = new TestClass();  t.display();  } }>

hello>

2. Un'altra caratteristica aggiunta in JDK 8 è che ora possiamo definire metodi statici in interfacce che possono essere chiamate indipendentemente senza un oggetto.

Nota: questi metodi non vengono ereditati.

cos'è uno stack Java

// Java Program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  static void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  In1.display();  } }>

hello>

Interfacce estese

Un'interfaccia può ereditarne un'altra utilizzando la parola chiave extends. Quando una classe implementa un'interfaccia che eredita un'altra interfaccia, deve fornire un'implementazione per tutti i metodi richiesti dalla catena di ereditarietà dell'interfaccia.

Programma 1:

interface A {  void method1();  void method2(); } // B now includes method1 and method2 interface B extends A {  void method3(); } // the class must implement all method of A and B. class gfg implements B {  public void method1()  {  System.out.println('Method 1');  }  public void method2()  {  System.out.println('Method 2');  }  public void method3()  {  System.out.println('Method 3');  } }>

Programma 2:

interface Student  {  public void data();   } class avi implements Student {  public void data ()  {  String name='avinash';  int rollno=68;  System.out.println(name);  System.out.println(rollno);  } } public class inter_face  {  public static void main (String args [])  {  avi h= new avi();  h.data();  } }>

avinash 68>

In modo semplice, l'interfaccia contiene più metodi astratti, quindi scrivi l'implementazione nelle classi di implementazione. Se l'implementazione non è in grado di fornire un'implementazione di tutti i metodi astratti, dichiara la classe di implementazione con un modificatore astratto e completa l'implementazione rimanente del metodo nelle classi figlie create successivamente. È possibile dichiarare più classi figlie ma alla fine abbiamo completato l'implementazione di tutti i metodi astratti.

In generale, il processo di sviluppo avviene passo dopo passo:

Livello 1 – interfacce: contiene i dettagli del servizio.
Livello 2 – classi astratte: contiene un'implementazione parziale.
Livello 3 – classi di implementazione: contiene tutte le implementazioni.
Livello 4 – Codice finale/Metodo principale: ha accesso a tutti i dati delle interfacce.

Esempio:

// Java Program for // implementation Level wise import java.io.*; import java.lang.*; import java.util.*; // Level 1 interface Bank {  void deposit();  void withdraw();  void loan();  void account(); } // Level 2 abstract class Dev1 implements Bank {  public void deposit()  {  System.out.println('Your deposit Amount :' + 100);  } } abstract class Dev2 extends Dev1 {  public void withdraw()  {  System.out.println('Your withdraw Amount :' + 50);  } } // Level 3 class Dev3 extends Dev2 {  public void loan() {}  public void account() {} } // Level 4 class GFG {  public static void main(String[] args)  {  Dev3 d = new Dev3();  d.account();  d.loan();  d.deposit();  d.withdraw();  } }>

Your deposit Amount :100 Your withdraw Amount :50>

Nuove funzionalità aggiunte nelle interfacce in JDK 9

Da Java 9 in poi, le interfacce possono contenere anche quanto segue:

1. Metodi statici
2. Metodi privati
3. Metodi statici privati

Punti importanti nelle interfacce Java

Nell'articolo apprendiamo alcuni punti importanti sulle interfacce come menzionato di seguito:

• Non possiamo creare un'istanza (l'interfaccia non può essere istanziata) dell'interfaccia ma possiamo farne un riferimento che si riferisca all'Oggetto della sua classe di implementazione.
• Una classe può implementare più di un'interfaccia.
• Un'interfaccia può estendersi a un'altra interfaccia o interfaccia (più di un'interfaccia).
• Una classe che implementa l'interfaccia deve implementare tutti i metodi nell'interfaccia.
• Tutti i metodi sono pubblici e astratti. E tutti i campi sono pubblici, statici e definitivi.
• Viene utilizzato per ottenere eredità multiple.
• Viene utilizzato per ottenere un accoppiamento lasco.
• All'interno dell'interfaccia non è possibile dichiarare variabili di istanza perché per impostazione predefinita le variabili lo sono finale statica pubblica.
• All'interno dell'interfaccia non sono ammessi costruttori.
• All'interno dell'interfaccia il metodo main non è consentito.
• All'interno dell'interfaccia non sono possibili dichiarazioni di metodi statici, finali e privati.

Devi leggere

• Identificatore di accesso dei metodi nelle interfacce
• Specificatori di accesso per classi o interfacce in Java
• Classi astratte in Java
• Interfaccia comparatore in Java
• Metodi di interfaccia Java
• Interfaccia nidificata in Java

Domande frequenti sulle interfacce

1. Cos'è un marcatore o un'interfaccia contrassegnata?

Le interfacce contrassegnate sono interfacce senza alcun metodo che fungono da indicatore senza alcuna funzionalità.

2. Quanti tipi di interfacce in Java?

I tipi di interfacce in Java sono menzionati di seguito:

1. Interfaccia funzionale
2. Interfaccia marcatore

3. Perché l'ereditarietà multipla non è supportata tramite la classe in Java?

L'ereditarietà multipla non è supportata tramite le classi in Java, per evitare alcune sfide come l'ambiguità e i problemi dei diamanti.