An Interfície en Java El llenguatge de programació es defineix com un tipus abstracte utilitzat per especificar el comportament d'una classe. Una interfície en Java és un pla d'un comportament. Una interfície Java conté constants estàtiques i mètodes abstractes.

Què són les interfícies a Java?

La interfície en Java és a mecanisme per aconseguir abstracció . Només hi pot haver mètodes abstractes a la interfície Java, no el cos del mètode. S'utilitza per aconseguir l'abstracció i múltiples herències a Java mitjançant la interfície . En altres paraules, es pot dir que les interfícies poden tenir mètodes i variables abstractes. No pot tenir un cos de mètode. Interfície Java també representa la relació IS-A .

Quan decidim un tipus d'entitat pel seu comportament i no per atribut, l'hauríem de definir com una interfície.

Sintaxi per a les interfícies de Java

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

Per declarar una interfície, utilitzeu la paraula clau interfície. S'utilitza per proporcionar una abstracció total. Això vol dir que tots els mètodes d'una interfície es declaren amb un cos buit i són públics i tots els camps són públics, estàtics i finals per defecte. Una classe que implementa una interfície ha d'implementar tots els mètodes declarats a la interfície. Per implementar la interfície, utilitzeu la paraula clau implements.

Usos de les interfícies en Java

Els usos de les interfícies a Java s'esmenten a continuació:

• S'utilitza per aconseguir l'abstracció total.
• Com que java no admet múltiples herències en el cas de classe, mitjançant l'ús d'una interfície es pot aconseguir múltiples herències.
• Qualsevol classe pot estendre només 1 classe, però qualsevol classe pot implementar un nombre infinit d'interfícies.
• També s'utilitza per aconseguir un acoblament solt.
• Les interfícies s'utilitzen per implementar l'abstracció.

Aleshores, sorgeix la pregunta per què utilitzar interfícies quan tenim classes abstractes?

El motiu és que les classes abstractes poden contenir variables no finals, mentre que les variables de la interfície són finals, públiques i estàtiques.

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

Relació entre classe i interfície

Una classe pot estendre una altra classe similar a aquesta una interfície pot estendre una altra interfície. Però només una classe es pot estendre a una altra interfície, i viceversa no està permès.

Diferència entre classe i interfície

Tot i que la classe i la interfície semblen iguals, hi ha certes diferències entre les classes i la interfície. Les principals diferències entre una classe i una interfície s'esmenten a continuació:

Implementació: Per implementar una interfície, utilitzem la paraula clau implements

// 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>

Exemples d'interfícies Java

Considerem l'exemple de vehicles com bicicletes, cotxes, bicicletes, etc. tenen funcionalitats comunes. Així que fem una interfície i posem totes aquestes funcionalitats comunes. I permet que Bicycle, Bike, Car, etc. implementi totes aquestes funcionalitats a la seva pròpia classe a la seva manera.

A continuació es mostra la implementació del tema anterior:

// 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>

Avantatges de les interfícies en Java

Els avantatges d'utilitzar interfícies en Java són els següents:

• Sense preocupar-nos de la part d'implementació, podem aconseguir la seguretat de la implementació.
• A Java, no es permeten les herències múltiples, però, podeu utilitzar una interfície per fer-ne ús, ja que podeu implementar més d'una interfície.

Herència múltiple a Java mitjançant la interfície

L'herència múltiple és un concepte de POO que no es pot implementar a Java mitjançant classes. Però podem utilitzar múltiples herències a Java mitjançant la Interfície. comprovem-ho amb un exemple.

Exemple:

// 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>

Noves funcions afegides a les interfícies de JDK 8

Hi ha determinades funcions afegides a les interfícies a l'actualització de JDK 8 que es mencionen a continuació:

1. Abans del JDK 8, la interfície no podia definir la implementació. Ara podem afegir una implementació predeterminada per als mètodes d'interfície. Aquesta implementació per defecte té un ús especial i no afecta la intenció darrere de les interfícies.

Suposem que hem d'afegir una funció nova a una interfície existent. Òbviament, el codi antic no funcionarà ja que les classes no han implementat aquestes funcions noves. Per tant, amb l'ajuda de la implementació per defecte, donarem un cos per defecte per a les noves funcions afegides. Aleshores, els codis antics encara funcionaran.

A continuació es mostra la implementació del punt anterior:

// 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. Una altra característica que es va afegir a JDK 8 és que ara podem definir mètodes estàtics en interfícies que es poden cridar de manera independent sense cap objecte.

Nota: aquests mètodes no s'hereten.

// 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>

Ampliació d'interfícies

Una interfície pot heretar una altra mitjançant l'ús de la paraula clau extensions. Quan una classe implementa una interfície que hereta una altra interfície, ha de proporcionar una implementació per a tots els mètodes requerits per la cadena d'herència de la interfície.

Programa 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');  } }>

Programa 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>

D'una manera senzilla, la interfície conté múltiples mètodes abstractes, així que escriviu la implementació a les classes d'implementació. Si la implementació no pot proporcionar una implementació de tots els mètodes abstractes, declareu la classe d'implementació amb un modificador abstracte i completeu la implementació del mètode restant a les següents classes fills creades. És possible declarar diverses classes fills, però al final hem completat la implementació de tots els mètodes abstractes.

En general, el procés de desenvolupament és pas a pas:

Nivell 1 – interfícies: conté els detalls del servei.
Nivell 2 – Classes abstractes: Conté una implementació parcial.
Nivell 3 – Classes d'implementació: Conté totes les implementacions.
Nivell 4 – Codi final / Mètode principal: té accés a totes les dades de les interfícies.

Exemple:

// 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>

Noves funcions afegides a les interfícies de JDK 9

A partir de Java 9, les interfícies també poden contenir el següent:

1. Mètodes estàtics
2. Mètodes privats
3. Mètodes estàtics privats

Aspectes importants de les interfícies de Java

A l'article, aprenem alguns punts importants sobre les interfícies, tal com s'esmenta a continuació:

• No podem crear una instància (la interfície no es pot instanciar) de la interfície però podem fer-ne la referència que faci referència a l'Objecte de la seva classe d'implementació.
• Una classe pot implementar més d'una interfície.
• Una interfície es pot estendre a una altra interfície o interfície (més d'una interfície).
• Una classe que implementa la interfície ha d'implementar tots els mètodes de la interfície.
• Tots els mètodes són públics i abstractes. I tots els camps són públics, estàtics i finals.
• S'utilitza per aconseguir múltiples herències.
• S'utilitza per aconseguir un acoblament solt.
• Dins de la interfície no es poden declarar variables d'instància perquè les variables per defecte ho són final estàtica pública.
• Dins de la interfície, els constructors no estan permesos.
• Dins de la interfície, el mètode principal no està permès.
• Dins de la interfície, la declaració de mètodes estàtics, finals i privats no és possible.

Cal llegir

• Especificador d'accés de mètodes en interfícies
• Especificadors d'accés per a classes o interfícies en Java
• Classes abstractes en Java
• Interfície de comparació en Java
• Mètodes d'interfície Java
• Interfície anidada en Java

Preguntes freqüents a les interfícies

1. Què és un marcador o una interfície etiquetada?

Les interfícies etiquetades són interfícies sense cap mètode que serveixen com a marcador sense cap capacitat.

integer compareto java

2. Quants tipus d'interfícies a Java?

Els tipus d'interfícies a Java s'esmenten a continuació:

1. Interfície funcional
2. Interfície de marcador

3. Per què no s'admet l'herència múltiple mitjançant classe a Java?

L'herència múltiple no s'admet a través de classe a Java, per tal d'evitar certs reptes com l'ambigüitat i els problemes de diamants.