An Grensesnitt i Java programmeringsspråk er definert som en abstrakt type som brukes til å spesifisere oppførselen til en klasse. Et grensesnitt i Java er en blåkopi av en atferd. Et Java-grensesnitt inneholder statiske konstanter og abstrakte metoder.

Hva er grensesnitt i Java?

Grensesnittet i Java er en mekanisme å oppnå abstraksjon . Det kan bare være abstrakte metoder i Java-grensesnittet, ikke metodekroppen. Det brukes til å oppnå abstraksjon og flere arv i Java ved hjelp av grensesnitt . Med andre ord kan du si at grensesnitt kan ha abstrakte metoder og variabler. Den kan ikke ha en metodekropp. Java-grensesnitt også representerer IS-A-forholdet .

Når vi bestemmer oss for en type enhet ved dens oppførsel og ikke via attributt, bør vi definere den som et grensesnitt.

Syntaks for Java-grensesnitt

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

For å deklarere et grensesnitt, bruk grensesnittnøkkelordet. Den brukes til å gi total abstraksjon. Det betyr at alle metodene i et grensesnitt er deklarert med en tom kropp og er offentlige og alle felt er offentlige, statiske og endelige som standard. En klasse som implementerer et grensesnitt må implementere alle metodene som er deklarert i grensesnittet. For å implementere grensesnittet, bruk implements nøkkelordet.

Bruk av grensesnitt i Java

Bruk av grensesnitt i Java er nevnt nedenfor:

• Den brukes for å oppnå total abstraksjon.
• Siden java ikke støtter flere arv når det gjelder klasse, kan den oppnå flere arv ved å bruke et grensesnitt.
• Enhver klasse kan utvide bare 1 klasse, men kan enhver klasse implementere et uendelig antall grensesnitt.
• Den brukes også for å oppnå løs kobling.
• Grensesnitt brukes til å implementere abstraksjon.

Så spørsmålet oppstår hvorfor bruke grensesnitt når vi har abstrakte klasser?

Årsaken er at abstrakte klasser kan inneholde ikke-endelige variabler, mens variabler i grensesnittet er endelige, offentlige og statiske.

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

Forholdet mellom klasse og grensesnitt

En klasse kan utvide en annen klasse som ligner på denne et grensesnitt kan utvide et annet grensesnitt. Men bare en klasse kan utvides til et annet grensesnitt, og omvendt er ikke tillatt.

Forskjellen mellom klasse og grensesnitt

Selv om klasse og grensesnitt virker like, er det visse forskjeller mellom klasser og grensesnitt. De største forskjellene mellom en klasse og et grensesnitt er nevnt nedenfor:

Gjennomføring: For å implementere et grensesnitt bruker vi nøkkelordet redskaper

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

La oss vurdere eksemplet med kjøretøy som sykler, biler, sykler, osv. de har felles funksjoner. Så vi lager et grensesnitt og legger alle disse vanlige funksjonene. Og lar Sykkel, sykkel, bil, etc implementere alle disse funksjonene i sin egen klasse på sin egen måte.

Nedenfor er implementeringen av emnet ovenfor:

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

Fordeler med grensesnitt i Java

Fordelene med å bruke grensesnitt i Java er som følger:

• Uten å bry oss om implementeringsdelen kan vi oppnå sikkerheten ved implementeringen.
• I Java er flere arv ikke tillatt, men du kan bruke et grensesnitt for å bruke det da du kan implementere mer enn ett grensesnitt.

Multippel arv i Java ved hjelp av grensesnitt

Multiple Inheritance er et OOPs-konsept som ikke kan implementeres i Java ved hjelp av klasser. Men vi kan bruke flere arv i Java ved å bruke grensesnitt. la oss sjekke dette med et eksempel.

skjær java

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 funksjoner lagt til i grensesnitt i JDK 8

Det er visse funksjoner lagt til grensesnitt i JDK 8-oppdateringen nevnt nedenfor:

1. Før JDK 8 kunne ikke grensesnittet definere implementeringen. Vi kan nå legge til standardimplementering for grensesnittmetoder. Denne standardimplementeringen har en spesiell bruk og påvirker ikke intensjonen bak grensesnitt.

Anta at vi må legge til en ny funksjon til et eksisterende grensesnitt. Det er klart at den gamle koden ikke vil fungere siden klassene ikke har implementert de nye funksjonene. Så ved hjelp av standardimplementering vil vi gi et standardlegeme for de nylig lagt til funksjonene. Da vil de gamle kodene fortsatt fungere.

Nedenfor er implementeringen av punktet ovenfor:

// 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 annen funksjon som ble lagt til i JDK 8 er at vi nå kan definere statiske metoder i grensesnitt som kan kalles uavhengig uten et objekt.

Merk: disse metodene 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>

Utvide grensesnitt

Ett grensesnitt kan arve et annet ved bruk av nøkkelord utvider. Når en klasse implementerer et grensesnitt som arver et annet grensesnitt, må den gi en implementering for alle metodene som kreves av grensesnittarvekjeden.

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åte inneholder grensesnittet flere abstrakte metoder, så skriv implementeringen i implementeringsklasser. Hvis implementeringen ikke er i stand til å gi en implementering av alle abstrakte metoder, erklærer du implementeringsklassen med en abstrakt modifikator, og fullfører den gjenværende metodeimplementeringen i de neste opprettede underklassene. Det er mulig å erklære flere barneklasser, men til slutt har vi fullført implementeringen av alle abstrakte metoder.

int streng

Generelt er utviklingsprosessen trinnvis:

Nivå 1 – grensesnitt: Den inneholder tjenestedetaljene.
Nivå 2 – abstrakte klasser: Den inneholder delvis implementering.
Nivå 3 – implementeringsklasser: Den inneholder alle implementeringer.
Nivå 4 – Endelig kode / hovedmetode: Den har tilgang til alle grensesnittdata.

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 funksjoner lagt til i grensesnitt i JDK 9

Fra Java 9 og utover kan grensesnitt også inneholde følgende:

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

Viktige punkter i Java-grensesnitt

I artikkelen lærer vi visse viktige punkter om grensesnitt som nevnt nedenfor:

• Vi kan ikke opprette en forekomst (grensesnitt kan ikke instansieres) av grensesnittet, men vi kan gjøre referansen til det som refererer til objektet til implementeringsklassen.
• En klasse kan implementere mer enn ett grensesnitt.
• Et grensesnitt kan utvides til et annet grensesnitt eller grensesnitt (mer enn ett grensesnitt).
• En klasse som implementerer grensesnittet må implementere alle metodene i grensesnittet.
• Alle metodene er offentlige og abstrakte. Og alle feltene er offentlige, statiske og endelige.
• Det brukes til å oppnå flere arv.
• Den brukes for å oppnå løs kobling.
• Inne i grensesnittet er det ikke mulig å deklarere forekomstvariabler fordi variabler som standard er det offentlig statisk finale.
• Inne i grensesnittet er konstruktører ikke tillatt.
• Inne i grensesnittet er hovedmetoden ikke tillatt.
• Inne i grensesnittet er statiske, endelige og private metoder ikke mulig.

Må lese

• Tilgang Spesifikasjon av metoder i grensesnitt
• Få tilgang til spesifikasjoner for klasser eller grensesnitt i Java
• Abstrakte klasser i Java
• Komparatorgrensesnitt i Java
• Java-grensesnittmetoder
• Nestet grensesnitt i Java

Ofte stilte spørsmål i grensesnitt

1. Hva er en markør eller et merket grensesnitt?

Merkede grensesnitt er grensesnitt uten noen metoder, de fungerer som en markør uten noen muligheter.

2. Hvor mange typer grensesnitt i Java?

Typer grensesnitt i Java er nevnt nedenfor:

1. Funksjonelt grensesnitt
2. Markør grensesnitt

3. Hvorfor støttes ikke multippel arv gjennom klassen i Java?

Multiple Inheritance støttes ikke gjennom klassen i Java, så for å unngå visse utfordringer som tvetydighet og diamantproblemer.