Jakiś Interfejs w Javie język programowania definiuje się jako typ abstrakcyjny używany do określania zachowania klasy. Interfejs w Javie jest planem zachowania. Interfejs Java zawiera stałe statyczne i metody abstrakcyjne.

Czym są interfejsy w Javie?

Interfejs w Javie jest A mechanizm do osiągnięcia abstrakcja . W interfejsie Java mogą znajdować się tylko metody abstrakcyjne, a nie treść metody. Służy do osiągnięcia abstrakcji i wielokrotne dziedziczenie w Javie przy użyciu interfejsu . Innymi słowy, można powiedzieć, że interfejsy mogą mieć abstrakcyjne metody i zmienne. Nie może mieć treści metody. Interfejs Java również reprezentuje relację IS-A .

Kiedy decydujemy o typie obiektu na podstawie jego zachowania, a nie atrybutów, powinniśmy zdefiniować go jako interfejs.

Składnia interfejsów Java

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

Aby zadeklarować interfejs, użyj słowa kluczowego interfejs. Służy do zapewnienia całkowitej abstrakcji. Oznacza to, że wszystkie metody w interfejsie są zadeklarowane z pustą treścią i są publiczne, a wszystkie pola są domyślnie publiczne, statyczne i ostateczne. Klasa implementująca interfejs musi implementować wszystkie metody zadeklarowane w interfejsie. Aby zaimplementować interfejs, użyj słowa kluczowego implements.

Zastosowania interfejsów w Javie

Poniżej wymieniono zastosowania interfejsów w Javie:

• Służy do osiągnięcia całkowitej abstrakcji.
• Ponieważ Java nie obsługuje wielokrotnego dziedziczenia w przypadku klasy, za pomocą interfejsu może osiągnąć wielokrotne dziedziczenie.
• Dowolna klasa może rozszerzać tylko 1 klasę, ale dowolna klasa może implementować nieskończoną liczbę interfejsów.
• Służy również do uzyskania luźnego połączenia.
• Interfejsy służą do implementacji abstrakcji.

Powstaje zatem pytanie, po co używać interfejsów, gdy mamy klasy abstrakcyjne?

Powodem jest to, że klasy abstrakcyjne mogą zawierać zmienne inne niż końcowe, podczas gdy zmienne w interfejsie są ostateczne, publiczne i statyczne.

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

Związek między klasą a interfejsem

Klasa może rozszerzać inną klasę w podobny sposób, interfejs może rozszerzać inny interfejs. Ale tylko klasa może rozciągać się na inny interfejs i odwrotnie, nie jest to dozwolone.

Różnica między klasą a interfejsem

Chociaż klasa i interfejs wydają się takie same, istnieją pewne różnice między klasami i interfejsem. Poniżej wymieniono główne różnice między klasą a interfejsem:

Realizacja: Aby zaimplementować interfejs, używamy słowa kluczowego przybory

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

Przykłady interfejsów Java

Rozważmy przykład pojazdów takich jak rowery, samochody, rowery itp., które mają wspólne funkcje. Tworzymy więc interfejs i umieszczamy w nim wszystkie wspólne funkcjonalności. I pozwala rowerowi, rowerowi, samochodowi itp. wdrożyć wszystkie te funkcje w swojej klasie na swój własny sposób.

Poniżej realizacja powyższego tematu:

Java vs C++

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

Zalety interfejsów w Javie

Zalety stosowania interfejsów w Javie są następujące:

• Nie zawracając sobie głowy częścią implementacyjną, możemy osiągnąć bezpieczeństwo wdrożenia.
• W Javie wielokrotne dziedziczenie nie jest dozwolone, jednakże możesz użyć interfejsu, aby z niego skorzystać, ponieważ możesz zaimplementować więcej niż jeden interfejs.

Dziedziczenie wielokrotne w Javie przy użyciu interfejsu

Dziedziczenie wielokrotne to koncepcja OOP, której nie można zaimplementować w Javie przy użyciu klas. Ale możemy używać wielu dziedzicień w Javie za pomocą interfejsu. sprawdźmy to na przykładzie.

Przykład:

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

Nowe funkcje dodane w interfejsach w JDK 8

W aktualizacji JDK 8 dodano pewne funkcje, o których mowa poniżej:

1. Przed wersją JDK 8 interfejs nie mógł definiować implementacji. Możemy teraz dodać domyślną implementację metod interfejsu. Ta domyślna implementacja ma specjalne zastosowanie i nie wpływa na intencję interfejsów.

Załóżmy, że musimy dodać nową funkcję do istniejącego interfejsu. Oczywiście stary kod nie będzie działał, ponieważ klasy nie zaimplementowały nowych funkcji. Zatem za pomocą domyślnej implementacji nadamy domyślną treść nowo dodanym funkcjom. Wtedy stare kody będą nadal działać.

Poniżej realizacja powyższego punktu:

// 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. Kolejną funkcją dodaną w JDK 8 jest to, że możemy teraz definiować metody statyczne w interfejsach, które można wywoływać niezależnie bez obiektu.

Notatka: metody te nie są dziedziczone.

cyfry rzymskie 1-100

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

Rozszerzanie interfejsów

Jeden interfejs może dziedziczyć inny poprzez użycie słowa kluczowego Extends. Kiedy klasa implementuje interfejs, który dziedziczy inny interfejs, musi zapewnić implementację wszystkich metod wymaganych przez łańcuch dziedziczenia interfejsu.

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>

W prosty sposób interfejs zawiera wiele metod abstrakcyjnych, dlatego implementację zapisz w klasach implementacyjnych. Jeśli implementacja nie jest w stanie zapewnić implementacji wszystkich metod abstrakcyjnych, zadeklaruj klasę implementacji z modyfikatorem abstrakcyjnym i dokończ implementację pozostałej metody w kolejnych utworzonych klasach potomnych. Można zadeklarować wiele klas potomnych, ale ostatecznie zakończyliśmy implementację wszystkich metod abstrakcyjnych.

Ogólnie rzecz biorąc, proces rozwoju przebiega krok po kroku:

Poziom 1 – interfejsy: Zawiera szczegóły usługi.
Poziom 2 – klasy abstrakcyjne: Zawiera częściową implementację.
Poziom 3 – klasy implementacji: Zawiera wszystkie implementacje.
Poziom 4 – Kod końcowy / Metoda główna: Ma dostęp do danych wszystkich interfejsów.

Przykład:

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

Nowe funkcje dodane w interfejsach w JDK 9

Począwszy od wersji Java 9, interfejsy mogą zawierać także:

1. Metody statyczne
2. Metody prywatne
3. Prywatne metody statyczne

Ważne punkty w interfejsach Java

W artykule dowiadujemy się o kilku ważnych kwestiach dotyczących interfejsów, jak wspomniano poniżej:

• Nie możemy utworzyć instancji (nie można utworzyć instancji interfejsu) interfejsu, ale możemy stworzyć do niego referencję, która będzie odnosić się do obiektu jego klasy implementującej.
• Klasa może implementować więcej niż jeden interfejs.
• Interfejs może rozciągać się na inny interfejs lub interfejs (więcej niż jeden interfejs).
• Klasa implementująca interfejs musi implementować wszystkie metody w interfejsie.
• Wszystkie metody są publiczne i abstrakcyjne. Wszystkie pola są publiczne, statyczne i ostateczne.
• Służy do osiągnięcia wielokrotnego dziedziczenia.
• Służy do uzyskania luźnego połączenia.
• Wewnątrz interfejsu nie można deklarować zmiennych instancji, ponieważ domyślnie są to zmienne publiczny statyczny finał.
• Wewnątrz interfejsu konstruktory nie są dozwolone.
• Wewnątrz interfejsu główna metoda nie jest dozwolona.
• Wewnątrz interfejsu deklaracja metod statycznych, końcowych i prywatnych nie jest możliwa.

Musisz przeczytać

• Specyfikator dostępu do metod w interfejsach
• Specyfikatory dostępu dla klas lub interfejsów w Javie
• Klasy abstrakcyjne w Javie
• Interfejs komparatora w Javie
• Metody interfejsu Java
• Zagnieżdżony interfejs w Javie

Często zadawane pytania dotyczące interfejsów

1. Co to jest znacznik lub interfejs z tagami?

Tagged Interfaces to interfejsy bez żadnych metod, które służą jako znacznik bez żadnych możliwości.

2. Ile typów interfejsów w Javie?

Poniżej wymieniono typy interfejsów w Javie:

1. Funkcjonalny interfejs
2. Interfejs znacznika

3. Dlaczego dziedziczenie wielokrotne nie jest obsługiwane przez klasę w Javie?

Dziedziczenie wielokrotne nie jest obsługiwane przez klasę w Javie, aby uniknąć pewnych wyzwań, takich jak problemy z niejednoznacznością i diamentami.