An Rozhraní v Javě programovací jazyk je definován jako abstraktní typ používaný k určení chování třídy. Rozhraní v Javě je návrhem chování. Rozhraní Java obsahuje statické konstanty a abstraktní metody.

Co jsou rozhraní v Javě?

Rozhraní v Javě je A mechanismus k dosažení abstrakce . V rozhraní Java mohou být pouze abstraktní metody, nikoli tělo metody. Používá se k dosažení abstrakce a vícenásobná dědičnost v Javě pomocí rozhraní . Jinými slovy, můžete říci, že rozhraní mohou mít abstraktní metody a proměnné. Nemůže mít tělo metody. Rozhraní Java také představuje vztah IS-A .

Když se o typu entity rozhodujeme podle jejího chování a ne podle atributu, měli bychom ji definovat jako rozhraní.

Syntaxe pro rozhraní Java

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

Chcete-li deklarovat rozhraní, použijte klíčové slovo interface. Používá se k poskytnutí úplné abstrakce. To znamená, že všechny metody v rozhraní jsou deklarovány s prázdným tělem a jsou veřejné a všechna pole jsou ve výchozím nastavení veřejná, statická a konečná. Třída, která implementuje rozhraní, musí implementovat všechny metody deklarované v rozhraní. K implementaci rozhraní použijte klíčové slovo implements.

Použití rozhraní v Javě

Použití rozhraní v Javě je uvedeno níže:

• Používá se k dosažení úplné abstrakce.
• Protože java v případě třídy nepodporuje vícenásobnou dědičnost, pomocí rozhraní může dosáhnout vícenásobné dědičnosti.
• Jakákoli třída může rozšířit pouze 1 třídu, ale jakákoli třída může implementovat nekonečný počet rozhraní.
• Používá se také k dosažení volného spojení.
• K implementaci abstrakce se používají rozhraní.

Nabízí se tedy otázka, proč používat rozhraní, když máme abstraktní třídy?

Důvodem je, že abstraktní třídy mohou obsahovat nefinální proměnné, zatímco proměnné v rozhraní jsou konečné, veřejné a statické.

co je rom

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

Vztah mezi třídou a rozhraním

Třída může rozšířit další třídu podobnou této, rozhraní může rozšířit další rozhraní. Ale pouze třída se může rozšířit na jiné rozhraní a naopak to není povoleno.

Rozdíl mezi třídou a rozhraním

Přestože se třída a rozhraní zdají stejné, existují určité rozdíly mezi třídami a rozhraním. Hlavní rozdíly mezi třídou a rozhraním jsou uvedeny níže:

Implementace: K implementaci rozhraní používáme klíčové slovo nářadí

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

Příklady rozhraní Java

Podívejme se na příklad vozidel, jako jsou jízdní kola, auta, kola atd., která mají společné funkce. Takže vytvoříme rozhraní a vložíme všechny tyto běžné funkce. A nechte Bicycle, Bike, car atd. implementovat všechny tyto funkce ve své vlastní třídě svým vlastním způsobem.

Níže je implementace výše uvedeného tématu:

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

Výhody rozhraní v Javě

Výhody použití rozhraní v Javě jsou následující:

• Bez obtěžování implementační části můžeme dosáhnout bezpečnosti implementace.
• V Javě není povoleno vícenásobné dědění, ale můžete použít rozhraní, protože můžete implementovat více než jedno rozhraní.

Vícenásobná dědičnost v Javě pomocí rozhraní

Vícenásobná dědičnost je koncept OOP, který nelze implementovat v Javě pomocí tříd. Ale můžeme použít vícenásobnou dědičnost v Javě pomocí rozhraní. ověřte si to na příkladu.

Příklad:

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

Nové funkce přidané do rozhraní v JDK 8

Do rozhraní v aktualizaci JDK 8 byly přidány určité funkce uvedené níže:

vyčistit mezipaměť npm

1. Před JDK 8 nemohlo rozhraní definovat implementaci. Nyní můžeme přidat výchozí implementaci pro metody rozhraní. Tato výchozí implementace má speciální použití a neovlivňuje záměr rozhraní.

Předpokládejme, že potřebujeme přidat novou funkci do stávajícího rozhraní. Je zřejmé, že starý kód nebude fungovat, protože třídy tyto nové funkce neimplementovaly. Takže pomocí výchozí implementace dáme výchozí tělo pro nově přidané funkce. Pak budou staré kódy stále fungovat.

Níže je implementace výše uvedeného bodu:

// 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. Další funkcí, která byla přidána do JDK 8, je, že nyní můžeme definovat statické metody v rozhraních, které lze volat nezávisle bez objektu.

Poznámka: tyto metody se nedědí.

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

Rozšíření rozhraní

Jedno rozhraní může zdědit jiné pomocí klíčového slova extends. Když třída implementuje rozhraní, které dědí jiné rozhraní, musí poskytnout implementaci pro všechny metody vyžadované řetězem dědičnosti rozhraní.

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>

Jednoduše řečeno, rozhraní obsahuje více abstraktních metod, takže implementaci zapište do implementačních tříd. Pokud implementace není schopna poskytnout implementaci všech abstraktních metod, deklarujte implementační třídu s abstraktním modifikátorem a dokončete zbývající implementaci metody v dalších vytvořených podřízených třídách. Je možné deklarovat více podřízených tříd, ale nakonec jsme dokončili implementaci všech abstraktních metod.

Obecně je proces vývoje krok za krokem:

Úroveň 1 – rozhraní: Obsahuje podrobnosti o službě.
Úroveň 2 – abstraktní třídy: Obsahuje částečnou implementaci.
Úroveň 3 – třídy implementace: Obsahuje všechny implementace.
Úroveň 4 – Final Code / Main Method: Má přístup ke všem datům rozhraní.

Příklad:

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

Nové funkce přidané do rozhraní v JDK 9

Od Java 9 výše mohou rozhraní obsahovat také následující:

1. Statické metody
2. Soukromé metody
3. Soukromé statické metody

Důležité body v rozhraní Java

V článku se dozvíme některé důležité body o rozhraních, jak je uvedeno níže:

rychlé třídění

• Nemůžeme vytvořit instanci (rozhraní nelze vytvořit instanci) rozhraní, ale můžeme na něj vytvořit odkaz, který odkazuje na objekt jeho implementační třídy.
• Třída může implementovat více než jedno rozhraní.
• Rozhraní se může rozšířit na další rozhraní nebo rozhraní (více než jedno rozhraní).
• Třída, která implementuje rozhraní, musí implementovat všechny metody v rozhraní.
• Všechny metody jsou veřejné a abstraktní. A všechna pole jsou veřejná, statická a konečná.
• Používá se k dosažení vícenásobné dědičnosti.
• Používá se k dosažení volného spojení.
• Uvnitř rozhraní není možné deklarovat proměnné instance, protože ve výchozím nastavení jsou proměnné veřejné statické finále.
• Uvnitř rozhraní nejsou konstruktéři povoleni.
• Uvnitř rozhraní není hlavní metoda povolena.
• Uvnitř rozhraní není možná deklarace statických, konečných a soukromých metod.

Musíš číst

• Přístupový specifikátor metod v rozhraních
• Specifikátory přístupu pro třídy nebo rozhraní v Javě
• Abstraktní třídy v Javě
• Rozhraní komparátoru v Javě
• Metody rozhraní Java
• Vnořené rozhraní v Javě

Často kladené otázky v rozhraních

1. Co je to značka nebo tagované rozhraní?

Tagged Interfaces jsou rozhraní bez jakýchkoliv metod, slouží jako značka bez jakýchkoliv schopností.

2. Kolik typů rozhraní v Javě?

Typy rozhraní v Javě jsou uvedeny níže:

1. Funkční rozhraní
2. Rozhraní značky

3. Proč vícenásobná dědičnost není podporována prostřednictvím třídy v Javě?

Vícenásobná dědičnost není podporována prostřednictvím třídy v Javě, aby se předešlo určitým problémům, jako je nejednoznačnost a diamantové problémy.