Un Interfață în Java limbajul de programare este definit ca un tip abstract folosit pentru a specifica comportamentul unei clase. O interfață în Java este un model al unui comportament. O interfață Java conține constante statice și metode abstracte.

conține metoda java

Ce sunt interfețele în Java?

Interfața în Java este A mecanism de a realiza abstractizare . În interfața Java pot exista doar metode abstracte, nu corpul metodei. Este folosit pentru realizarea abstracției și moșteniri multiple în Java folosind Interfața . Cu alte cuvinte, puteți spune că interfețele pot avea metode și variabile abstracte. Nu poate avea un corp de metodă. De asemenea, interfața Java reprezintă relația IS-A .

Când decidem asupra unui tip de entitate prin comportamentul său și nu prin atribut, ar trebui să o definim ca interfață.

Sintaxă pentru interfețele Java

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

Pentru a declara o interfață, utilizați cuvântul cheie interfață. Este folosit pentru a oferi o abstractizare totală. Aceasta înseamnă că toate metodele dintr-o interfață sunt declarate cu un corp gol și sunt publice și toate câmpurile sunt publice, statice și finale în mod implicit. O clasă care implementează o interfață trebuie să implementeze toate metodele declarate în interfață. Pentru a implementa interfața, utilizați cuvântul cheie implements.

Utilizări ale interfețelor în Java

Utilizările interfețelor în Java sunt menționate mai jos:

• Este folosit pentru a realiza o abstractizare totală.
• Deoarece java nu acceptă moșteniri multiple în cazul clasei, prin utilizarea unei interfețe se poate obține moșteniri multiple.
• Orice clasă poate extinde doar o clasă, dar orice clasă poate implementa un număr infinit de interfețe.
• Este, de asemenea, utilizat pentru a obține cuplajul liber.
• Interfețele sunt folosite pentru a implementa abstractizarea.

Deci, se pune întrebarea de ce folosim interfețe atunci când avem clase abstracte?

Motivul este că clasele abstracte pot conține variabile non-finale, în timp ce variabilele din interfață sunt finale, publice și statice.

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

Relația dintre clasă și interfață

O clasă poate extinde o altă clasă similară cu aceasta, o interfață poate extinde o altă interfață. Dar numai o clasă se poate extinde la o altă interfață și viceversa nu este permisă.

Diferența dintre clasă și interfață

Deși clasa și interfața par la fel, există anumite diferențe între clase și interfață. Diferențele majore dintre o clasă și o interfață sunt menționate mai jos:

Implementare: Pentru a implementa o interfață, folosim cuvântul cheie unelte

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

Exemple de interfețe Java

Să luăm în considerare exemplul vehiculelor precum bicicletele, mașinile, bicicletele etc., care au funcționalități comune. Așa că facem o interfață și punem toate aceste funcționalități comune. Și permite Bicicletă, Bicicletă, mașină, etc să implementeze toate aceste funcționalități în propria lor clasă în felul lor.

Mai jos este implementarea subiectului de mai sus:

cum se convertesc șir în int

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

Avantajele interfețelor în Java

Avantajele utilizării interfețelor în Java sunt următoarele:

• Fără a ne deranja cu privire la partea de implementare, putem obține securitatea implementării.
• În Java, moștenirile multiple nu sunt permise, cu toate acestea, puteți utiliza o interfață pentru a o folosi, deoarece puteți implementa mai multe interfețe.

Moștenire multiplă în Java folosind interfața

Moștenirea multiplă este un concept OOP care nu poate fi implementat în Java folosind clase. Dar putem folosi mai multe moșteniri în Java folosind Interfață. hai sa verificam asta cu un exemplu.

Exemplu:

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

Caracteristici noi adăugate în interfețele din JDK 8

Există anumite caracteristici adăugate la Interfețe în actualizarea JDK 8 menționate mai jos:

1. Înainte de JDK 8, interfața nu putea defini implementarea. Acum putem adăuga implementare implicită pentru metodele de interfață. Această implementare implicită are o utilizare specială și nu afectează intenția din spatele interfețelor.

dhl înseamnă ce

Să presupunem că trebuie să adăugăm o nouă funcție la o interfață existentă. Evident, vechiul cod nu va funcționa, deoarece clasele nu au implementat acele funcții noi. Deci, cu ajutorul implementării implicite, vom oferi un corp implicit pentru funcțiile nou adăugate. Atunci vechile coduri vor funcționa în continuare.

Mai jos este implementarea punctului de mai sus:

// 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. O altă caracteristică care a fost adăugată în JDK 8 este că acum putem defini metode statice în interfețe care pot fi apelate independent fără un obiect.

Notă: aceste metode nu sunt moștenite.

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

Extinderea interfețelor

O interfață poate moșteni alta prin utilizarea cuvântului cheie extinde. Când o clasă implementează o interfață care moștenește o altă interfață, trebuie să furnizeze o implementare pentru toate metodele cerute de lanțul de moștenire a interfeței.

Programul 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');  } }>

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

Într-un mod simplu, interfața conține mai multe metode abstracte, așa că scrieți implementarea în clase de implementare. Dacă implementarea nu poate furniza o implementare a tuturor metodelor abstracte, atunci declarați clasa de implementare cu un modificator abstract și finalizați implementarea metodei rămase în următoarele clase copil create. Este posibil să declarați mai multe clase copil, dar la final am finalizat implementarea tuturor metodelor abstracte.

1 milion câte 0

În general, procesul de dezvoltare este pas cu pas:

Nivelul 1 – interfețe: Conține detaliile serviciului.
Nivelul 2 – clase abstracte: Conține implementare parțială.
Nivelul 3 – clase de implementare: Conține toate implementările.
Nivelul 4 – Cod final / Metoda principală: are acces la toate datele interfeței.

Exemplu:

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

Caracteristici noi adăugate în interfețele din JDK 9

De la Java 9 în sus, interfețele pot conține și următoarele:

1. Metode statice
2. Metode private
3. Metode statice private

Puncte importante în interfețele Java

În articol, aflăm anumite puncte importante despre interfețe, așa cum este menționat mai jos:

• Nu putem crea o instanță (interfața nu poate fi instanțiată) a interfeței, dar putem face referința acesteia care se referă la Obiectul clasei sale de implementare.
• O clasă poate implementa mai mult de o interfață.
• O interfață se poate extinde la o altă interfață sau interfață (mai mult de o interfață).
• O clasă care implementează interfața trebuie să implementeze toate metodele din interfață.
• Toate metodele sunt publice și abstracte. Și toate câmpurile sunt publice, statice și finale.
• Este folosit pentru a obține moșteniri multiple.
• Este folosit pentru a realiza cuplaje libere.
• În interiorul interfeței nu este posibil să se declare variabile de instanță, deoarece variabilele sunt implicite public static final.
• În interiorul interfeței, constructorii nu sunt permisi.
• Metoda principală a interfeței nu este permisă.
• În interiorul interfeței, declararea metodelor statice, finale și private nu sunt posibile.

Trebuie citit

• Specificator de acces al metodelor în interfețe
• Specificatori de acces pentru clase sau interfețe în Java
• Clase abstracte în Java
• Interfață de comparație în Java
• Metode de interfață Java
• Interfață imbricată în Java

Întrebări frecvente în interfețe

1. Ce este un marker sau o interfață etichetată?

Interfețele etichetate sunt interfețe fără nicio metodă, care servesc ca un marker fără nicio capacitate.

2. Câte tipuri de interfețe în Java?

Tipurile de interfețe în Java sunt menționate mai jos:

1. Interfață funcțională
2. Interfață marker

3. De ce moștenirea multiplă nu este acceptată prin clasă în Java?

Moștenirea multiplă nu este acceptată prin clasă în Java, astfel încât să se evite anumite provocări precum ambiguitatea și problemele de diamant.