An Rozhranie v jazyku Java programovací jazyk je definovaný ako abstraktný typ používaný na špecifikáciu správania triedy. Rozhranie v Jave je návrhom správania. Rozhranie Java obsahuje statické konštanty a abstraktné metódy.

string java pole

Čo sú rozhrania v Jave?

Rozhranie v jazyku Java je a mechanizmus na dosiahnutie abstrakcie . V rozhraní Java môžu byť iba abstraktné metódy, nie telo metódy. Používa sa na dosiahnutie abstrakcie a viacnásobné dedičstvo v Jave pomocou rozhrania . Inými slovami, môžete povedať, že rozhrania môžu mať abstraktné metódy a premenné. Nemôže mať telo metódy. Rozhranie Java tiež predstavuje vzťah IS-A .

Keď sa pre typ entity rozhodujeme podľa jej správania a nie podľa atribútu, mali by sme ju definovať ako rozhranie.

Syntax pre rozhrania Java

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

Ak chcete deklarovať rozhranie, použite kľúčové slovo interface. Používa sa na poskytnutie úplnej abstrakcie. To znamená, že všetky metódy v rozhraní sú deklarované s prázdnym telom a sú verejné a všetky polia sú štandardne verejné, statické a konečné. Trieda, ktorá implementuje rozhranie, musí implementovať všetky metódy deklarované v rozhraní. Na implementáciu rozhrania použite kľúčové slovo implements.

Použitie rozhraní v Jave

Použitie rozhraní v jazyku Java je uvedené nižšie:

• Používa sa na dosiahnutie úplnej abstrakcie.
• Keďže java v prípade triedy nepodporuje viacnásobnú dedičnosť, pomocou rozhrania môže dosiahnuť viacnásobnú dedičnosť.
• Každá trieda môže rozšíriť iba 1 triedu, ale ktorákoľvek trieda môže implementovať nekonečný počet rozhraní.
• Používa sa tiež na dosiahnutie voľného spojenia.
• Na implementáciu abstrakcie sa používajú rozhrania.

Vynára sa teda otázka, prečo používať rozhrania, keď máme abstraktné triedy?

Dôvodom je, že abstraktné triedy môžu obsahovať nefinálne premenné, zatiaľ čo premenné v rozhraní sú konečné, verejné a statické.

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

Vzťah medzi triedou a rozhraním

Trieda môže rozšíriť ďalšiu triedu podobnú tejto, rozhranie môže rozšíriť ďalšie rozhranie. Ale iba trieda sa môže rozšíriť na iné rozhranie a naopak to nie je povolené.

Rozdiel medzi triedou a rozhraním

Hoci sa trieda a rozhranie zdajú rovnaké, medzi triedami a rozhraním existujú určité rozdiely. Hlavné rozdiely medzi triedou a rozhraním sú uvedené nižšie:

Implementácia: Na implementáciu rozhrania používame kľúčové slovo náradia

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

Príklady rozhraní Java

Zoberme si príklad vozidiel, ako sú bicykle, autá, bicykle atď., ktoré majú spoločné funkcie. Takže vytvoríme rozhranie a umiestnime všetky tieto bežné funkcie. A nechajte Bicykel, Bicykel, auto atď. implementovať všetky tieto funkcie vo svojej triede vlastným spôsobom.

Nižšie je uvedená implementácia vyššie uvedenej témy:

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

Výhody používania rozhraní v Jave sú nasledovné:

• Bez trápenia sa s implementačnou časťou môžeme dosiahnuť bezpečnosť implementácie.
• V jazyku Java nie je povolené viacnásobné dedičstvo, avšak na jeho využitie môžete použiť rozhranie, pretože môžete implementovať viac ako jedno rozhranie.

Viacnásobné dedičstvo v jazyku Java pomocou rozhrania

Viacnásobné dedičstvo je koncept OOP, ktorý nie je možné implementovať v jazyku Java pomocou tried. Ale môžeme použiť viacnásobnú dedičnosť v Jave pomocou rozhrania. overme si to príkladom.

Prí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é funkcie pridané do rozhraní v JDK 8

Existujú určité funkcie pridané do rozhraní v aktualizácii JDK 8 uvedenej nižšie:

1. Pred JDK 8 rozhranie nemohlo definovať implementáciu. Teraz môžeme pridať predvolenú implementáciu pre metódy rozhrania. Táto predvolená implementácia má špeciálne použitie a neovplyvňuje zámer rozhrania.

Predpokladajme, že potrebujeme pridať novú funkciu do existujúceho rozhrania. Je zrejmé, že starý kód nebude fungovať, pretože triedy neimplementovali tieto nové funkcie. Takže pomocou predvolenej implementácie dáme predvolené telo pre novo pridané funkcie. Potom budú staré kódy stále fungovať.

Nižšie je uvedená implementácia vyššie 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. Ďalšou funkciou, ktorá bola pridaná do JDK 8, je, že teraz môžeme definovať statické metódy v rozhraniach, ktoré možno volať nezávisle bez objektu.

čo je 10 z 1 milióna

Poznámka: tieto metódy sa nededia.

// 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šírenie rozhraní

Jedno rozhranie môže zdediť druhé pomocou kľúčového slova extends. Keď trieda implementuje rozhranie, ktoré zdedí iné rozhranie, musí poskytnúť implementáciu pre všetky metódy vyžadované reťazcom dedičnosti rozhrania.

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>

Jednoducho povedané, rozhranie obsahuje viacero abstraktných metód, takže implementáciu napíšte do implementačných tried. Ak implementácia nedokáže poskytnúť implementáciu všetkých abstraktných metód, potom deklarujte implementačnú triedu s abstraktným modifikátorom a dokončite zostávajúcu implementáciu metódy v ďalších vytvorených podradených triedach. Je možné deklarovať viacero detských tried, ale nakoniec sme dokončili implementáciu všetkých abstraktných metód.

xor c++

Vo všeobecnosti je proces vývoja krok za krokom:

Úroveň 1 – rozhrania: Obsahuje podrobnosti o službe.
Úroveň 2 – abstraktné triedy: Obsahuje čiastočnú implementáciu.
Úroveň 3 – triedy implementácie: Obsahuje všetky implementácie.
Úroveň 4 – Final Code / Main Method: Má prístup ku všetkým údajom rozhrania.

Prí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é funkcie pridané do rozhraní v JDK 9

Od Java 9 a vyššie môžu rozhrania obsahovať aj nasledovné:

1. Statické metódy
2. Súkromné ​​metódy
3. Súkromné ​​statické metódy

Dôležité body v rozhraniach Java

V článku sa dozvieme niektoré dôležité body o rozhraniach, ako je uvedené nižšie:

• Nemôžeme vytvoriť inštanciu (rozhranie nemožno vytvoriť inštanciou) rozhrania, ale môžeme naň vytvoriť odkaz, ktorý odkazuje na objekt jeho implementačnej triedy.
• Trieda môže implementovať viac ako jedno rozhranie.
• Rozhranie sa môže rozšíriť na ďalšie rozhranie alebo rozhranie (viac ako jedno rozhranie).
• Trieda, ktorá implementuje rozhranie, musí implementovať všetky metódy v rozhraní.
• Všetky metódy sú verejné a abstraktné. A všetky polia sú verejné, statické a konečné.
• Používa sa na dosiahnutie viacnásobného dedičstva.
• Používa sa na dosiahnutie voľného spojenia.
• Vo vnútri rozhrania nie je možné deklarovať premenné inštancie, pretože v predvolenom nastavení sú premenné verejné statické finále.
• Vo vnútri rozhrania nie sú povolené konštruktory.
• Vo vnútri rozhrania nie je povolená hlavná metóda.
• Vo vnútri rozhrania nie je možná deklarácia statických, konečných a súkromných metód.

Musíte prečítať

• Prístupový špecifikátor metód v rozhraniach
• Špecifikátory prístupu pre triedy alebo rozhrania v jazyku Java
• Abstraktné triedy v Jave
• Rozhranie komparátora v jazyku Java
• Metódy rozhrania Java
• Vnorené rozhranie v jazyku Java

Často kladené otázky v rozhraniach

1. Čo je značka alebo značkované rozhranie?

Tagged Interfaces sú rozhrania bez akýchkoľvek metód, slúžia ako značka bez akýchkoľvek schopností.

2. Koľko typov rozhraní v Jave?

Typy rozhraní v jazyku Java sú uvedené nižšie:

1. Funkčné rozhranie
2. Rozhranie značky

3. Prečo nie je podporované viacnásobné dedičstvo prostredníctvom triedy v jazyku Java?

Viacnásobné dedičstvo nie je podporované prostredníctvom triedy v jazyku Java, aby sa predišlo určitým problémom, ako sú nejednoznačnosť a problémy s diamantmi.