An Sąsaja Java programavimo kalba apibrėžiama kaip abstraktus tipas, naudojamas klasės elgsenai nurodyti. „Java“ sąsaja yra elgesio planas. „Java“ sąsajoje yra statinių konstantų ir abstrakčių metodų.

Kas yra „Java“ sąsajos?

„Java“ sąsaja yra a pasiekti mechanizmą abstrakcija . „Java“ sąsajoje gali būti tik abstraktūs metodai, o ne metodo korpusas. Jis naudojamas abstrakcijai pasiekti ir keli paveldėjimai Java naudojant sąsają . Kitaip tariant, galite sakyti, kad sąsajos gali turėti abstrakčius metodus ir kintamuosius. Jis negali turėti metodo kūno. Java sąsaja taip pat reprezentuoja IS-A santykį .

Kai nustatome objekto tipą pagal jo elgesį, o ne per atributą, turėtume apibrėžti jį kaip sąsają.

„Java“ sąsajų sintaksė

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

Norėdami deklaruoti sąsają, naudokite sąsajos raktinį žodį. Jis naudojamas siekiant užtikrinti visišką abstrakciją. Tai reiškia, kad visi sąsajos metodai deklaruojami tuščiu turiniu ir yra vieši, o visi laukai pagal numatytuosius nustatymus yra vieši, statiniai ir galutiniai. Klasė, kuri įgyvendina sąsają, turi įgyvendinti visus sąsajoje deklaruotus metodus. Norėdami įdiegti sąsają, naudokite raktinį žodį implements.

„Java“ sąsajų naudojimas

„Java“ sąsajų naudojimas yra nurodytas toliau:

• Jis naudojamas norint pasiekti visišką abstrakciją.
• Kadangi „Java“ nepalaiko kelių paveldėjimų klasės atveju, naudojant sąsają ji gali pasiekti kelis paveldėjimus.
• Bet kuri klasė gali išplėsti tik 1 klasę, tačiau bet kuri klasė gali įgyvendinti begalinį skaičių sąsajų.
• Jis taip pat naudojamas norint pasiekti laisvą sujungimą.
• Abstrakcijai įgyvendinti naudojamos sąsajos.

Taigi, kyla klausimas, kodėl naudoti sąsajas, kai turime abstrakčias klases?

mano flikseris

Priežastis ta, kad abstrakčiose klasėse gali būti negalutinių kintamųjų, o sąsajos kintamieji yra galutiniai, vieši ir statiniai.

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

Klasės ir sąsajos ryšys

Klasė gali išplėsti kitą klasę, panašią į šią, sąsaja gali išplėsti kitą sąsają. Tačiau tik klasė gali būti išplėsta į kitą sąsają, o atvirkščiai – neleidžiama.

Skirtumas tarp klasės ir sąsajos

Nors klasė ir sąsaja atrodo vienodos, tarp klasių ir sąsajos yra tam tikrų skirtumų. Pagrindiniai klasės ir sąsajos skirtumai paminėti toliau:

Įgyvendinimas: Norėdami įdiegti sąsają, naudojame raktinį žodį padargai

// 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 sąsajų pavyzdžiai

Panagrinėkime transporto priemonių, tokių kaip dviračiai, automobiliai, dviračiai ir kt., pavyzdį, jie turi bendrų funkcijų. Taigi sukuriame sąsają ir pateikiame visas šias įprastas funkcijas. Ir leidžia dviračiui, dviračiui, automobiliui ir tt įgyvendinti visas šias funkcijas savo klasėje savaip.

sąrašas java

Žemiau pateikiamas aukščiau pateiktos temos įgyvendinimas:

// 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“ sąsajų pranašumai

„Java“ sąsajų naudojimo pranašumai yra šie:

• Nesirūpindami dėl įgyvendinimo dalies, galime pasiekti diegimo saugumą.
• „Java“ neleidžiami keli paveldėjimai, tačiau galite naudoti sąsają, nes galite įdiegti daugiau nei vieną sąsają.

Daugkartinis „Java“ paveldėjimas naudojant sąsają

Keletas paveldėjimo yra OOP koncepcija, kurios negalima įdiegti Java naudojant klases. Tačiau „Java“ galime naudoti kelis paveldėjimus naudodami sąsają. patikrinkime tai pavyzdžiu.

Pavyzdys:

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

Naujos funkcijos, įtrauktos į JDK 8 sąsajas

Toliau nurodytose JDK 8 naujinimo sąsajose yra tam tikrų funkcijų:

1. Prieš JDK 8 sąsaja negalėjo apibrėžti diegimo. Dabar galime pridėti numatytąjį sąsajos metodų įgyvendinimą. Šis numatytasis diegimas yra specialiai naudojamas ir neturi įtakos sąsajų tikslams.

Tarkime, kad turime pridėti naują funkciją prie esamos sąsajos. Akivaizdu, kad senasis kodas neveiks, nes klasės neįdiegė tų naujų funkcijų. Taigi, naudodami numatytąjį diegimą, naujai pridėtoms funkcijoms suteiksime numatytąjį turinį. Tada senieji kodai vis tiek veiks.

Žemiau pateikiamas pirmiau minėto punkto įgyvendinimas:

// 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. Kita funkcija, kuri buvo pridėta JDK 8, yra ta, kad dabar galime apibrėžti statinius metodus sąsajose, kurias galima iškviesti nepriklausomai be objekto.

Pastaba: šie metodai nėra paveldimi.

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

Sąsajų išplėtimas

Viena sąsaja gali paveldėti kitą, naudodama raktinį žodį išplėsti. Kai klasė įgyvendina sąsają, kuri paveldi kitą sąsają, ji turi pateikti visų metodų, reikalingų sąsajos paveldėjimo grandinei, įgyvendinimą.

1 programa:

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 programa:

repl java

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>

Paprastu būdu sąsajoje yra keli abstrakčiai metodai, todėl įgyvendinimą parašykite įgyvendinimo klasėse. Jei įgyvendinimas negali pateikti visų abstrakčių metodų įgyvendinimo, tada deklaruokite įgyvendinimo klasę su abstrakčiu modifikatoriumi ir užbaikite likusį metodo įgyvendinimą kitose sukurtose antrinėse klasėse. Galima deklaruoti kelias vaikų klases, bet galiausiai baigėme įgyvendinti visus abstrakčius metodus.

javascript spausdinimas

Apskritai kūrimo procesas vyksta žingsnis po žingsnio:

1 lygis – Sąsajos: joje yra išsami paslaugos informacija.
2 lygis – abstrakčios klasės: yra dalinis įgyvendinimas.
3 lygis – diegimo klasės: Jame yra visi diegimai.
4 lygis – Galutinis kodas / pagrindinis metodas: turi prieigą prie visų sąsajų duomenų.

Pavyzdys:

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

Naujos funkcijos, įtrauktos į JDK 9 sąsajas

Nuo 9 versijos „Java“ sąsajose taip pat gali būti:

1. Statiniai metodai
2. Privatūs metodai
3. Privatūs statiniai metodai

Svarbūs „Java“ sąsajų punktai

Straipsnyje sužinome tam tikrus svarbius dalykus apie sąsajas, kaip nurodyta toliau:

• Negalime sukurti sąsajos egzemplioriaus (sąsaja negali būti pakartojama), bet galime padaryti nuorodą į ją, nurodant jos įgyvendinimo klasės objektą.
• Klasė gali įdiegti daugiau nei vieną sąsają.
• Sąsaja gali apimti kitą sąsają arba sąsają (daugiau nei vieną sąsają).
• Klasė, kuri įgyvendina sąsają, turi įdiegti visus sąsajos metodus.
• Visi metodai yra vieši ir abstraktūs. Ir visi laukai yra vieši, statiški ir galutiniai.
• Jis naudojamas norint pasiekti kelis paveldėjimus.
• Jis naudojamas norint pasiekti laisvą sujungimą.
• Sąsajos viduje neįmanoma deklaruoti egzempliorių kintamųjų, nes pagal numatytuosius nustatymus kintamieji yra viešas statinis finalas.
• Sąsajos viduje konstruktoriai neįleidžiami.
• Sąsajos viduje pagrindinis metodas neleidžiamas.
• Sąsajos viduje negalima deklaruoti statinių, galutinių ir privačių metodų.

Privaloma perskaityti

• Prieigos metodų specifikatorius sąsajose
• Pasiekite „Java“ klasių ar sąsajų specifikacijas
• Abstrakčios klasės Java
• „Java“ palyginimo sąsaja
• Java sąsajos metodai
• Įdėta sąsaja Java

Dažnai užduodami klausimai sąsajose

1. Kas yra žymeklis arba pažymėta sąsaja?

Pažymėtos sąsajos yra sąsajos be jokių metodų, kurios tarnauja kaip žymeklis be jokių galimybių.

2. Kiek tipų sąsajų yra Java?

Toliau pateikiami „Java“ sąsajų tipai:

1. Funkcinė sąsaja
2. Žymeklio sąsaja

3. Kodėl „Java“ klasėje nepalaikomas daugialypis paveldėjimas?

Daugkartinis paveldėjimas nepalaikomas Java klasėje, kad būtų išvengta tam tikrų iššūkių, tokių kaip dviprasmiškumas ir deimantų problemos.