An Interface i Java programmeringssprog er defineret som en abstrakt type, der bruges til at specificere en klasses adfærd. En grænseflade i Java er en blueprint af en adfærd. En Java-grænseflade indeholder statiske konstanter og abstrakte metoder.

Hvad er grænseflader i Java?

Grænsefladen i Java er -en mekanisme at opnå abstraktion . Der kan kun være abstrakte metoder i Java-grænsefladen, ikke metodekroppen. Det bruges til at opnå abstraktion og flere arv i Java ved hjælp af Interface . Med andre ord kan man sige, at grænseflader kan have abstrakte metoder og variabler. Det kan ikke have et metodelegeme. Java Interface også repræsenterer IS-A-forholdet .

Når vi beslutter os for en type enhed ud fra dens adfærd og ikke via attribut, bør vi definere den som en grænseflade.

Syntaks for Java-grænseflader

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

For at erklære en grænseflade skal du bruge grænsefladenøgleordet. Det bruges til at give total abstraktion. Det betyder, at alle metoderne i en grænseflade er erklæret med en tom krop og er offentlige, og alle felter er offentlige, statiske og endelige som standard. En klasse, der implementerer en grænseflade, skal implementere alle de metoder, der er erklæret i grænsefladen. Brug nøgleordet implements for at implementere grænsefladen.

Brug af grænseflader i Java

Brug af grænseflader i Java er nævnt nedenfor:

• Det bruges til at opnå total abstraktion.
• Da java ikke understøtter flere nedarvninger i tilfælde af klasse, kan den ved at bruge en grænseflade opnå flere nedarvninger.
• Enhver klasse kan kun udvide 1 klasse, men kan enhver klasse implementere et uendeligt antal grænseflader.
• Det bruges også til at opnå løs kobling.
• Grænseflader bruges til at implementere abstraktion.

Så spørgsmålet opstår, hvorfor bruge grænseflader, når vi har abstrakte klasser?

Årsagen er, at abstrakte klasser kan indeholde ikke-endelige variabler, hvorimod variabler i grænsefladen er endelige, offentlige og statiske.

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

Forholdet mellem klasse og grænseflade

En klasse kan udvide en anden klasse svarende til denne en grænseflade kan udvide en anden grænseflade. Men kun en klasse kan udvides til en anden grænseflade, og omvendt er ikke tilladt.

Forskellen mellem klasse og grænseflade

Selvom klasse og grænseflade virker ens, er der visse forskelle mellem klasser og grænseflade. De største forskelle mellem en klasse og en grænseflade er nævnt nedenfor:

Implementering: For at implementere en grænseflade bruger vi nøgleordet redskaber

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

Eksempler på Java-grænseflader

Lad os overveje eksemplet med køretøjer som cykler, biler, cykler osv., de har fælles funktionaliteter. Så vi laver en grænseflade og sætter alle disse fælles funktionaliteter. Og lader Cykel, Cykel, bil osv. implementere alle disse funktioner i deres egen klasse på deres egen måde.

Nedenfor er implementeringen af ​​ovenstående emne:

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

Fordele ved grænseflader i Java

Fordelene ved at bruge grænseflader i Java er som følger:

• Uden at bekymre os om implementeringsdelen kan vi opnå sikkerheden ved implementeringen.
• I Java er flere arv ikke tilladt, men du kan bruge en grænseflade til at gøre brug af den, da du kan implementere mere end én grænseflade.

Multipel arv i Java ved hjælp af grænseflade

Multiple Inheritance er et OOPs-koncept, der ikke kan implementeres i Java ved hjælp af klasser. Men vi kan bruge flere arv i Java ved hjælp af Interface. lad os tjekke dette med et eksempel.

css-justeringsbilleder

Eksempel:

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

Nye funktioner tilføjet i grænseflader i JDK 8

Der er visse funktioner tilføjet til Interfaces i JDK 8-opdateringen nævnt nedenfor:

1. Før JDK 8 kunne grænsefladen ikke definere implementeringen. Vi kan nu tilføje standardimplementering for grænseflademetoder. Denne standardimplementering har en speciel anvendelse og påvirker ikke hensigten bag grænseflader.

Antag, at vi skal tilføje en ny funktion til en eksisterende grænseflade. Det er klart, at den gamle kode ikke vil fungere, da klasserne ikke har implementeret disse nye funktioner. Så ved hjælp af standardimplementering vil vi give et standardlegeme for de nyligt tilføjede funktioner. Så vil de gamle koder stadig fungere.

Nedenfor er implementeringen af ​​ovenstående punkt:

// 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. En anden funktion, der blev tilføjet i JDK 8, er, at vi nu kan definere statiske metoder i grænseflader, der kan kaldes uafhængigt uden et objekt.

Bemærk: disse metoder er ikke arvet.

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

Udvidelse af grænseflader

En grænseflade kan arve en anden ved at bruge nøgleordet udvider. Når en klasse implementerer en grænseflade, der arver en anden grænseflade, skal den levere en implementering for alle metoder, der kræves af grænsefladearvskæden.

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

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

På en enkel måde indeholder grænsefladen flere abstrakte metoder, så skriv implementeringen i implementeringsklasser. Hvis implementeringen ikke er i stand til at levere en implementering af alle abstrakte metoder, skal du deklarere implementeringsklassen med en abstrakt modifikator og fuldføre den resterende metodeimplementering i de næste oprettede underklasser. Det er muligt at erklære flere børneklasser, men til sidst har vi gennemført implementeringen af ​​alle abstrakte metoder.

int streng

Generelt er udviklingsprocessen trin for trin:

Niveau 1 – grænseflader: Den indeholder servicedetaljerne.
Niveau 2 – abstrakte klasser: Den indeholder delvis implementering.
Niveau 3 – implementeringsklasser: Den indeholder alle implementeringer.
Niveau 4 – Endelig kode / hovedmetode: Den har adgang til alle grænsefladedata.

Eksempel:

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

Nye funktioner tilføjet i grænseflader i JDK 9

Fra Java 9 og fremefter kan grænseflader også indeholde følgende:

1. Statiske metoder
2. Private metoder
3. Private statiske metoder

Vigtige punkter i Java-grænseflader

I artiklen lærer vi nogle vigtige punkter om grænseflader som nævnt nedenfor:

• Vi kan ikke oprette en instans (grænsefladen kan ikke instansieres) af grænsefladen, men vi kan lave referencen til den, der refererer til objektet for dens implementeringsklasse.
• En klasse kan implementere mere end én grænseflade.
• En grænseflade kan udvides til en anden grænseflade eller grænseflade (mere end én grænseflade).
• En klasse, der implementerer grænsefladen, skal implementere alle metoderne i grænsefladen.
• Alle metoder er offentlige og abstrakte. Og alle felterne er offentlige, statiske og endelige.
• Det bruges til at opnå flere arv.
• Det bruges til at opnå løs kobling.
• Inde i grænsefladen er det ikke muligt at erklære instansvariabler, fordi variabler som standard er det offentlig statisk finale.
• Inde i grænsefladen er konstruktører ikke tilladt.
• Inde i grænsefladen er hovedmetoden ikke tilladt.
• Inde i grænsefladen er statisk, endelig og privat metodeerklæring ikke mulig.

Skal læses

• Adgangsspecifikation af metoder i grænseflader
• Få adgang til specifikationer for klasser eller grænseflader i Java
• Abstrakte klasser i Java
• Komparatorgrænseflade i Java
• Java-grænseflademetoder
• Indlejret grænseflade i Java

Ofte stillede spørgsmål i grænseflader

1. Hvad er en markør eller tagget grænseflade?

Taggede grænseflader er grænseflader uden nogen metoder, de tjener som en markør uden nogen egenskaber.

2. Hvor mange typer grænseflader i Java?

Typer af grænseflader i Java er nævnt nedenfor:

1. Funktionel grænseflade
2. Markør interface

3. Hvorfor multipel nedarvning ikke understøttes gennem klasse i Java?

Multiple Inheritance understøttes ikke gennem klasse i Java, så for at undgå visse udfordringer som tvetydighed og diamantproblemer.