An Interfeiss Java valodā programmēšanas valoda ir definēta kā abstrakts veids, ko izmanto, lai norādītu klases uzvedību. Java saskarne ir darbības plāns. Java saskarne satur statiskas konstantes un abstraktas metodes.

Kas ir Java saskarnes?

Java saskarne ir a sasniegšanas mehānisms abstrakcija . Java saskarnē var būt tikai abstraktas metodes, nevis metodes pamatteksts. To izmanto, lai panāktu abstrakciju un vairāki mantojumi Java, izmantojot interfeisu . Citiem vārdiem sakot, jūs varat teikt, ka saskarnēm var būt abstraktas metodes un mainīgie. Tam nevar būt metodes korpusa. Arī Java interfeiss atspoguļo IS-A attiecības .

Kad mēs izlemjam par entītijas veidu pēc tā uzvedības, nevis pēc atribūta, mums tas jādefinē kā saskarne.

Sintakse Java interfeisiem

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

Lai deklarētu saskarni, izmantojiet interfeisa atslēgvārdu. To izmanto, lai nodrošinātu pilnīgu abstrakciju. Tas nozīmē, ka visas saskarnes metodes ir deklarētas ar tukšu pamattekstu un ir publiskas, un visi lauki pēc noklusējuma ir publiski, statiski un galīgi. Klasei, kas ievieš saskarni, jāievieš visas saskarnē deklarētās metodes. Lai ieviestu saskarni, izmantojiet implements atslēgvārdu.

Saskarņu izmantošana Java

Interfeisu lietojumi Java ir minēti tālāk:

• To izmanto, lai panāktu pilnīgu abstrakciju.
• Tā kā java neatbalsta vairākus mantojumus klases gadījumā, izmantojot interfeisu, tā var sasniegt vairākus mantojumus.
• Jebkura klase var paplašināt tikai 1 klasi, bet jebkura klase var īstenot bezgalīgu skaitu saskarņu.
• To izmanto arī, lai panāktu vaļīgu savienojumu.
• Abstrakcijas īstenošanai tiek izmantotas saskarnes.

Tātad rodas jautājums, kāpēc izmantot saskarnes, ja mums ir abstraktas klases?

Iemesls ir tāds, ka abstraktās klases var saturēt mainīgos, kas nav galīgi, savukārt saskarnes mainīgie ir galīgi, publiski un statiski.

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

Saistība starp klasi un saskarni

Klase var paplašināt citu klasi, kas ir līdzīga šai, saskarne var paplašināt citu saskarni. Bet tikai klase var paplašināties līdz citam interfeisam, un otrādi nav atļauts.

Atšķirība starp klasi un interfeisu

Lai gan klase un saskarne šķiet vienādas, starp klasēm un interfeisu ir noteiktas atšķirības. Galvenās atšķirības starp klasi un saskarni ir minētas tālāk:

Īstenošana: Lai ieviestu saskarni, mēs izmantojam atslēgvārdu īsteno

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

Java interfeisu piemēri

Apskatīsim piemēru ar tādiem transportlīdzekļiem kā velosipēdi, automašīnas, velosipēdi utt., kuriem ir kopīgas funkcijas. Tāpēc mēs izveidojam saskarni un ievietojam visas šīs kopīgās funkcijas. Un ļauj velosipēdiem, velosipēdiem, automašīnām utt. ieviest visas šīs funkcijas savā klasē savā veidā.

Zemāk ir aprakstīta iepriekš minētās tēmas īstenošana:

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

Java saskarņu priekšrocības

Java saskarņu izmantošanas priekšrocības ir šādas:

• Neuztraucoties par ieviešanas daļu, mēs varam sasniegt ieviešanas drošību.
• Programmā Java nav atļauta vairākkārtēja mantošana, tomēr varat izmantot saskarni, lai to izmantotu, jo varat ieviest vairāk nekā vienu saskarni.

Vairāku Java mantojumu, izmantojot interfeisu

Daudzkārtēja mantošana ir OOP koncepcija, ko nevar ieviest Java, izmantojot klases. Bet mēs varam izmantot vairākus Java mantojumus, izmantojot interfeisu. pārbaudīsim to ar piemēru.

Piemērs:

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

JDK 8 saskarnēs pievienotas jaunas funkcijas

Tālāk norādītajā JDK 8 atjauninājumā ir pievienotas noteiktas funkcijas.

ins atslēga

1. Pirms JDK 8 saskarne nevarēja definēt ieviešanu. Tagad mēs varam pievienot interfeisa metožu noklusējuma ieviešanu. Šai noklusējuma ieviešanai ir īpašs lietojums, un tā neietekmē saskarņu nolūku.

Pieņemsim, ka esošajam interfeisam ir jāpievieno jauna funkcija. Acīmredzot vecais kods nedarbosies, jo klases nav ieviesušas šīs jaunās funkcijas. Tātad, izmantojot noklusējuma ieviešanu, mēs piešķirsim noklusējuma pamattekstu tikko pievienotajām funkcijām. Tad vecie kodi joprojām darbosies.

Tālāk ir aprakstīta iepriekš minētā punkta īstenošana:

// 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. Vēl viena iezīme, kas tika pievienota JDK 8, ir tā, ka tagad mēs varam definēt statiskas metodes saskarnēs, kuras var izsaukt neatkarīgi bez objekta.

Piezīme: šīs metodes nav iedzimtas.

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

Saskarņu paplašināšana

Viena saskarne var mantot citu, izmantojot atslēgvārdu paplašinājumus. Kad klase ievieš saskarni, kas manto citu saskarni, tai ir jānodrošina visu saskarnes mantošanas ķēdei nepieciešamo metožu ieviešana.

1. programma:

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

2. programma:

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>

Vienkāršā veidā saskarne satur vairākas abstraktas metodes, tāpēc ierakstiet ieviešanu ieviešanas klasēs. Ja ieviešana nevar nodrošināt visu abstrakto metožu ieviešanu, deklarējiet ieviešanas klasi ar abstraktu modifikatoru un pabeidziet atlikušās metodes ieviešanu nākamajās izveidotajās pakārtotajās klasēs. Ir iespējams deklarēt vairākas bērnu klases, taču beidzot esam pabeiguši visu abstrakto metožu ieviešanu.

Kopumā izstrādes process notiek soli pa solim:

1. līmenis – saskarnes: tajā ir informācija par pakalpojumu.
2. līmenis – abstraktās klases: tajā ir daļēja ieviešana.
3. līmenis – ieviešanas klases: tajā ir visas implementācijas.
4. līmenis - Galīgais kods / galvenā metode: tai ir piekļuve visiem saskarņu datiem.

Piemērs:

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

Jaunas funkcijas, kas pievienotas JDK 9 saskarnēm

Sākot no Java 9, saskarnēs var būt arī:

1. Statiskās metodes
2. Privātas metodes
3. Privātās statiskās metodes

Svarīgi punkti Java saskarnēs

Rakstā mēs uzzinām dažus svarīgus punktus par saskarnēm, kā minēts tālāk:

• Mēs nevaram izveidot interfeisa instanci (interfeisu nevar izveidot), taču mēs varam izveidot atsauci uz to, kas attiecas uz tās ieviešanas klases objektu.
• Klase var ieviest vairāk nekā vienu saskarni.
• Saskarne var paplašināties līdz citam interfeisam vai interfeisam (vairāk nekā vienam interfeisam).
• Klasei, kas ievieš saskarni, ir jāievieš visas saskarnē esošās metodes.
• Visas metodes ir publiskas un abstraktas. Un visi lauki ir publiski, statiski un galīgi.
• To izmanto, lai panāktu vairākus mantojumus.
• To izmanto, lai panāktu vaļīgu savienojumu.
• Interfeisa iekšpusē nav iespējams deklarēt gadījumu mainīgos, jo pēc noklusējuma mainīgie ir tādi publisks statisks fināls.
• Saskarnes iekšpusē konstruktori nav atļauti.
• Interfeisa iekšpusē galvenā metode nav atļauta.
• Saskarnē nav iespējama statisko, galīgo un privāto metožu deklarēšana.

Vajag izlasīt

• Piekļuves metožu specifikācija saskarnēs
• Piekļūstiet Java klašu vai saskarņu specifikācijām
• Abstraktās klases Java valodā
• Java salīdzinājuma interfeiss
• Java interfeisa metodes
• Ligzdota saskarne Java

Bieži uzdotie jautājumi saskarnēs

1. Kas ir marķieris vai marķētais interfeiss?

Atzīmētās saskarnes ir saskarnes bez jebkādām metodēm, tās kalpo kā marķieris bez jebkādām iespējām.

2. Cik interfeisu veidu Java?

Tālāk ir minēti Java saskarņu veidi:

1. Funkcionālais interfeiss
2. Marķiera interfeiss

3. Kāpēc Java klasē netiek atbalstīta vairākkārtēja mantošana?

Java klasē netiek atbalstīta daudzkārtēja mantošana, lai izvairītos no noteiktiem izaicinājumiem, piemēram, neskaidrības un dimanta problēmām.