Een Interface in Java programmeertaal wordt gedefinieerd als een abstract type dat wordt gebruikt om het gedrag van een klasse te specificeren. Een interface in Java is een blauwdruk van gedrag. Een Java-interface bevat statische constanten en abstracte methoden.

Wat zijn interfaces in Java?

De interface in Java is A mechanisme te bereiken abstractie . Er kunnen alleen abstracte methoden in de Java-interface voorkomen, niet in de hoofdtekst van de methode. Het wordt gebruikt om abstractie te bereiken en meerdere overervingen in Java met behulp van Interface . Met andere woorden, je kunt zeggen dat interfaces abstracte methoden en variabelen kunnen hebben. Het kan geen method body hebben. Java-interface ook vertegenwoordigt de IS-A-relatie .

Wanneer we een type entiteit kiezen op basis van zijn gedrag en niet op basis van een attribuut, moeten we deze definiëren als een interface.

Syntaxis voor Java-interfaces

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

Om een ​​interface te declareren, gebruikt u het interface-trefwoord. Het wordt gebruikt om totale abstractie te bieden. Dat betekent dat alle methoden in een interface worden gedeclareerd met een lege hoofdtekst en openbaar zijn, en dat alle velden standaard openbaar, statisch en definitief zijn. Een klasse die een interface implementeert, moet alle methoden implementeren die in de interface zijn gedeclareerd. Gebruik het trefwoord implements om de interface te implementeren.

java lambda voorbeeld

Gebruik van interfaces in Java

Het gebruik van interfaces in Java wordt hieronder vermeld:

• Het wordt gebruikt om totale abstractie te bereiken.
• Omdat Java in het geval van een klasse geen meerdere overervingen ondersteunt, kan het door een interface te gebruiken meerdere overervingen bewerkstelligen.
• Elke klasse kan slechts één klasse uitbreiden, maar elke klasse kan een oneindig aantal interfaces implementeren.
• Het wordt ook gebruikt om losse koppeling te bereiken.
• Interfaces worden gebruikt om abstractie te implementeren.

De vraag rijst dus: waarom zouden we interfaces gebruiken als we abstracte klassen hebben?

De reden hiervoor is dat abstracte klassen niet-definitieve variabelen kunnen bevatten, terwijl variabelen in de interface definitief, openbaar en statisch zijn.

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

Relatie tussen klasse en interface

Een klasse kan een andere klasse uitbreiden die vergelijkbaar is met deze, een interface kan een andere interface uitbreiden. Maar alleen een klasse kan zich uitbreiden naar een andere interface, en omgekeerd is niet toegestaan.

Verschil tussen klasse en interface

Hoewel klasse en interface hetzelfde lijken, zijn er bepaalde verschillen tussen klassen en interface. De belangrijkste verschillen tussen een klasse en een interface worden hieronder vermeld:

Implementatie: Om een ​​interface te implementeren gebruiken we het trefwoord werktuigen

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

Voorbeelden van Java-interfaces

Laten we eens kijken naar het voorbeeld van voertuigen zoals fietsen, auto's, fietsen, enz. Ze hebben gemeenschappelijke functionaliteiten. Dus maken we een interface en plaatsen al deze gemeenschappelijke functionaliteiten. En laat Fiets, Fiets, Auto, etc al deze functionaliteiten in hun eigen klasse op hun eigen manier implementeren.

Hieronder vindt u de implementatie van het bovenstaande onderwerp:

geheel getal naar tekenreeks Java

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

Voordelen van interfaces in Java

De voordelen van het gebruik van interfaces in Java zijn als volgt:

• Zonder ons druk te maken over het implementatiegedeelte, kunnen we de veiligheid van de implementatie bereiken.
• In Java zijn meerdere overnames niet toegestaan, maar u kunt wel een interface gebruiken om er gebruik van te maken, aangezien u meer dan één interface kunt implementeren.

Meervoudige overerving in Java met behulp van de interface

Multiple Inheritance is een OOPs-concept dat niet in Java kan worden geïmplementeerd met behulp van klassen. Maar we kunnen meerdere overervingen in Java gebruiken met behulp van Interface. laten we dit met een voorbeeld controleren.

Voorbeeld:

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

Nieuwe functies toegevoegd aan interfaces in JDK 8

Er zijn bepaalde functies toegevoegd aan interfaces in de JDK 8-update die hieronder worden vermeld:

1. Vóór JDK 8 kon de interface de implementatie niet definiëren. We kunnen nu standaardimplementatie voor interfacemethoden toevoegen. Deze standaardimplementatie heeft een speciaal gebruik en heeft geen invloed op de bedoeling achter interfaces.

Stel dat we een nieuwe functie aan een bestaande interface moeten toevoegen. Het is duidelijk dat de oude code niet zal werken omdat de klassen deze nieuwe functies niet hebben geïmplementeerd. Dus met behulp van de standaardimplementatie zullen we een standaardtekst geven voor de nieuw toegevoegde functies. Dan werken de oude codes nog steeds.

Hieronder vindt u de implementatie van het bovenstaande punt:

// 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. Een andere functie die in JDK 8 is toegevoegd, is dat we nu statische methoden kunnen definiëren in interfaces die onafhankelijk kunnen worden aangeroepen zonder een object.

Opmerking: deze methoden worden niet geërfd.

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

Interfaces uitbreiden

De ene interface kan de andere overnemen door het gebruik van trefwoordextensies. Wanneer een klasse een interface implementeert die een andere interface erft, moet deze een implementatie bieden voor alle methoden die vereist zijn voor de interface-overervingsketen.

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>

Op een eenvoudige manier bevat de interface meerdere abstracte methoden, dus schrijf de implementatie in implementatieklassen. Als de implementatie niet in staat is een implementatie van alle abstracte methoden te bieden, declareer dan de implementatieklasse met een abstracte modifier en voltooi de resterende methode-implementatie in de volgende gemaakte onderliggende klassen. Het is mogelijk om meerdere onderliggende klassen te declareren, maar uiteindelijk hebben we de implementatie van alle abstracte methoden voltooid.

Over het algemeen verloopt het ontwikkelingsproces stap voor stap:

Niveau 1 – interfaces: het bevat de servicedetails.
Level 2 – abstracte klassen: het bevat een gedeeltelijke implementatie.
Niveau 3 – implementatieklassen: het bevat alle implementaties.
Niveau 4 – Laatste code / hoofdmethode: het heeft toegang tot alle interfacegegevens.

Voorbeeld:

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

Nieuwe functies toegevoegd aan interfaces in JDK 9

Vanaf Java 9 kunnen interfaces ook het volgende bevatten:

1. Statische methoden
2. Privé methoden
3. Privé statische methoden

Belangrijke punten in Java-interfaces

In het artikel leren we bepaalde belangrijke punten over interfaces, zoals hieronder vermeld:

• We kunnen geen instantie maken (de interface kan niet worden geïnstantieerd) van de interface, maar we kunnen er wel een verwijzing naar maken die verwijst naar het object van de implementerende klasse ervan.
• Een klasse kan meer dan één interface implementeren.
• Een interface kan zich uitbreiden naar een andere interface of interface (meer dan één interface).
• Een klasse die de interface implementeert, moet alle methoden in de interface implementeren.
• Alle methoden zijn openbaar en abstract. En alle velden zijn openbaar, statisch en definitief.
• Het wordt gebruikt om meerdere erfenissen te verkrijgen.
• Het wordt gebruikt om losse koppeling te bereiken.
• Binnen de interface is het niet mogelijk om instantievariabelen te declareren, omdat variabelen dat standaard wel zijn openbare statische finale.
• Binnen de interface zijn constructors niet toegestaan.
• Binnen de interface is de hoofdmethode niet toegestaan.
• Binnen de interface zijn declaraties van statische, definitieve en privémethoden niet mogelijk.

Moet lezen

• Toegangsspecificatie van methoden in interfaces
• Toegang tot specificaties voor klassen of interfaces in Java
• Abstracte klassen in Java
• Vergelijkingsinterface in Java
• Java-interfacemethoden
• Geneste interface in Java

Veelgestelde vragen over interfaces

1. Wat is een marker- of getagde interface?

Tagged Interfaces zijn interfaces zonder enige methode en dienen als markering zonder enige mogelijkheid.

2. Hoeveel soorten interfaces in Java?

Soorten interfaces in Java worden hieronder vermeld:

mijnlivecricket

1. Functionele interface
2. Marker-interface

3. Waarom wordt meervoudige overerving niet ondersteund via klasse in Java?

Multiple Inheritance wordt niet ondersteund via klasse in Java om bepaalde uitdagingen zoals Ambiguïteit en diamantproblemen te vermijden.