En Gränssnitt i Java programmeringsspråk definieras som en abstrakt typ som används för att specificera beteendet hos en klass. Ett gränssnitt i Java är en ritning av ett beteende. Ett Java-gränssnitt innehåller statiska konstanter och abstrakta metoder.

Vad är gränssnitt i Java?

Gränssnittet i Java är a mekanism att uppnå abstraktion . Det kan bara finnas abstrakta metoder i Java-gränssnittet, inte metodkroppen. Det används för att uppnå abstraktion och flera arv i Java med gränssnitt . Med andra ord kan man säga att gränssnitt kan ha abstrakta metoder och variabler. Det kan inte ha en metodkropp. Java-gränssnitt också representerar IS-A-relationen .

När vi bestämmer oss för en typ av entitet genom dess beteende och inte via attribut bör vi definiera den som ett gränssnitt.

Syntax för Java-gränssnitt

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

Använd nyckelordet för gränssnitt för att deklarera ett gränssnitt. Det används för att ge total abstraktion. Det betyder att alla metoder i ett gränssnitt deklareras med en tom kropp och är offentliga och alla fält är offentliga, statiska och slutgiltiga som standard. En klass som implementerar ett gränssnitt måste implementera alla metoder som deklareras i gränssnittet. Använd nyckelordet implements för att implementera gränssnittet.

tecken till sträng

Användning av gränssnitt i Java

Användning av gränssnitt i Java nämns nedan:

• Det används för att uppnå total abstraktion.
• Eftersom java inte stöder flera arv när det gäller klass, kan det genom att använda ett gränssnitt uppnå flera arv.
• Vilken klass som helst kan bara utöka 1 klass, men kan vilken klass som helst implementera ett oändligt antal gränssnitt.
• Den används också för att uppnå lös koppling.
• Gränssnitt används för att implementera abstraktion.

Så frågan uppstår varför använda gränssnitt när vi har abstrakta klasser?

Anledningen är att abstrakta klasser kan innehålla icke-slutliga variabler, medan variabler i gränssnittet är slutliga, offentliga och statiska.

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

Förhållandet mellan klass och gränssnitt

En klass kan utöka en annan klass liknande denna ett gränssnitt kan utöka ett annat gränssnitt. Men bara en klass kan utökas till ett annat gränssnitt, och vice versa är inte tillåtet.

Skillnaden mellan klass och gränssnitt

Även om klass och gränssnitt verkar likadana finns det vissa skillnader mellan klasser och gränssnitt. De största skillnaderna mellan en klass och ett gränssnitt nämns nedan:

Genomförande: För att implementera ett gränssnitt använder vi nyckelordet redskap

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

Exempel på Java-gränssnitt

Låt oss betrakta exemplet med fordon som cyklar, bilar, cyklar, etc. de har gemensamma funktioner. Så vi gör ett gränssnitt och lägger alla dessa vanliga funktioner. Och låter Cykel, Cykel, bil, etc implementera alla dessa funktioner i sin egen klass på sitt eget sätt.

Nedan är implementeringen av ovanstående ämne:

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

Fördelar med gränssnitt i Java

Fördelarna med att använda gränssnitt i Java är följande:

• Utan att bry oss om implementeringsdelen kan vi uppnå säkerheten i implementeringen.
• I Java är flera arv inte tillåtna, men du kan använda ett gränssnitt för att använda det eftersom du kan implementera mer än ett gränssnitt.

Multipelt arv i Java med gränssnitt

Multiple Inheritance är ett OOPs-koncept som inte kan implementeras i Java med hjälp av klasser. Men vi kan använda flera arv i Java med Interface. låt oss kontrollera detta med ett exempel.

Exempel:

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

Nya funktioner tillagda i gränssnitt i JDK 8

Det finns vissa funktioner som läggs till i gränssnitt i JDK 8-uppdateringen som nämns nedan:

1. Före JDK 8 kunde gränssnittet inte definiera implementeringen. Vi kan nu lägga till standardimplementering för gränssnittsmetoder. Denna standardimplementering har en speciell användning och påverkar inte avsikten bakom gränssnitt.

Anta att vi behöver lägga till en ny funktion till ett befintligt gränssnitt. Uppenbarligen kommer den gamla koden inte att fungera eftersom klasserna inte har implementerat de nya funktionerna. Så med hjälp av standardimplementering kommer vi att ge en standardkropp för de nyligen tillagda funktionerna. Då kommer de gamla koderna fortfarande att fungera.

Nedan följer implementeringen av ovanstående punkt:

tostring java

// 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 annan funktion som lagts till i JDK 8 är att vi nu kan definiera statiska metoder i gränssnitt som kan anropas oberoende utan objekt.

Notera: dessa metoder ärvs inte.

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

Utöka gränssnitt

Ett gränssnitt kan ärva ett annat genom att använda nyckelordet extends. När en klass implementerar ett gränssnitt som ärver ett annat gränssnitt måste den tillhandahålla en implementering för alla metoder som krävs av gränssnittets arvskedja.

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:

java int i sträng

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å ett enkelt sätt innehåller gränssnittet flera abstrakta metoder, så skriv implementeringen i implementeringsklasser. Om implementeringen inte kan tillhandahålla en implementering av alla abstrakta metoder, deklarera implementeringsklassen med en abstrakt modifierare och slutför den återstående metodimplementeringen i nästa skapade underordnade klasser. Det är möjligt att deklarera flera barnklasser men till slut har vi slutfört implementeringen av alla abstrakta metoder.

I allmänhet är utvecklingsprocessen steg för steg:

Nivå 1 – gränssnitt: Den innehåller servicedetaljerna.
Nivå 2 – abstrakta klasser: Den innehåller partiell implementering.
Nivå 3 – implementeringsklasser: Den innehåller alla implementeringar.
Nivå 4 – Slutlig kod / huvudmetod: Den har tillgång till alla gränssnittsdata.

Exempel:

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

Nya funktioner tillagda i gränssnitt i JDK 9

Från Java 9 och framåt kan gränssnitt även innehålla följande:

1. Statiska metoder
2. Privata metoder
3. Privata statiska metoder

Viktiga punkter i Java-gränssnitt

I artikeln lär vi oss vissa viktiga punkter om gränssnitt som nämns nedan:

• Vi kan inte skapa en instans (gränssnittet kan inte instansieras) av gränssnittet men vi kan göra referensen till det som refererar till objektet för dess implementeringsklass.
• En klass kan implementera mer än ett gränssnitt.
• Ett gränssnitt kan utökas till ett annat gränssnitt eller gränssnitt (mer än ett gränssnitt).
• En klass som implementerar gränssnittet måste implementera alla metoder i gränssnittet.
• Alla metoder är offentliga och abstrakta. Och alla fält är offentliga, statiska och slutgiltiga.
• Det används för att uppnå flera arv.
• Den används för att uppnå lös koppling.
• Inuti gränssnittet är det inte möjligt att deklarera instansvariabler eftersom variabler som standard är det offentlig statisk final.
• Inuti gränssnittet är konstruktörer inte tillåtna.
• Inuti gränssnittet är huvudmetoden inte tillåten.
• Inuti gränssnittet är statisk, slutlig och privat metoddeklaration inte möjlig.

Måste läsas

• Åtkomstspecifikation av metoder i gränssnitt
• Åtkomstspecifikationer för klasser eller gränssnitt i Java
• Abstrakta klasser i Java
• Komparatorgränssnitt i Java
• Java-gränssnittsmetoder
• Kapslade gränssnitt i Java

Vanliga frågor i gränssnitt

1. Vad är en markör eller ett taggat gränssnitt?

Taggade gränssnitt är gränssnitt utan några metoder de fungerar som en markör utan några möjligheter.

2. Hur många typer av gränssnitt i Java?

Typer av gränssnitt i Java nämns nedan:

1. Funktionellt gränssnitt
2. Markör gränssnitt

3. Varför stöds inte multipelt arv genom klass i Java?

Multiple Inheritance stöds inte genom klass i Java så för att undvika vissa utmaningar som tvetydighet och diamantproblem.