An Java-käyttöliittymä ohjelmointikieli määritellään abstraktiksi tyypiksi, jota käytetään määrittämään luokan käyttäytymistä. Java-käyttöliittymä on käyttäytymissuunnitelma. Java-käyttöliittymä sisältää staattisia vakioita ja abstrakteja menetelmiä.

Mitä ovat Java-rajapinnat?

Java-käyttöliittymä on a saavuttamismekanismi abstraktio . Java-rajapinnassa voi olla vain abstrakteja menetelmiä, ei metodin runkoa. Sitä käytetään saavuttamaan abstraktio ja useita perintöjä Javassa käyttöliittymän avulla . Toisin sanoen voidaan sanoa, että rajapinnoilla voi olla abstrakteja menetelmiä ja muuttujia. Sillä ei voi olla menetelmärunkoa. Myös Java-käyttöliittymä edustaa IS-A-suhdetta .

Kun päätämme entiteetin tyypistä sen käyttäytymisen perusteella, emme attribuutin perusteella, meidän tulee määritellä se käyttöliittymäksi.

Java-rajapintojen syntaksi

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

Voit määrittää rajapinnan käyttämällä käyttöliittymän avainsanaa. Sitä käytetään tarjoamaan täydellinen abstraktio. Tämä tarkoittaa, että kaikki käyttöliittymän menetelmät on ilmoitettu tyhjällä rungolla ja ne ovat julkisia ja kaikki kentät ovat julkisia, staattisia ja lopullisia oletusarvoisesti. Luokan, joka toteuttaa rajapinnan, tulee toteuttaa kaikki rajapinnassa ilmoitetut menetelmät. Toteuta käyttöliittymä käyttämällä implements-avainsanaa.

Java-rajapintojen käyttötavat

Java-rajapintojen käyttötavat on mainittu alla:

• Sitä käytetään saavuttamaan täydellinen abstraktio.
• Koska java ei tue useita perintöjä luokan tapauksessa, käyttöliittymää käyttämällä se voi saavuttaa useita perintöjä.
• Mikä tahansa luokka voi laajentaa vain 1 luokkaa, mutta mikä tahansa luokka toteuttaa äärettömän määrän rajapintoja.
• Sitä käytetään myös löysän liitoksen aikaansaamiseen.
• Rajapintoja käytetään abstraktion toteuttamiseen.

Joten herää kysymys, miksi käyttää rajapintoja, kun meillä on abstrakteja luokkia?

Syynä on se, että abstraktit luokat voivat sisältää ei-lopullisia muuttujia, kun taas käyttöliittymän muuttujat ovat lopullisia, julkisia ja staattisia.

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

Luokan ja käyttöliittymän välinen suhde

Luokka voi laajentaa toista luokkaa, joka on samanlainen kuin tämä, käyttöliittymä voi laajentaa toista rajapintaa. Mutta vain luokka voi ulottua toiseen käyttöliittymään, ja päinvastoin ei sallita.

Ero luokan ja käyttöliittymän välillä

Vaikka luokka ja käyttöliittymä vaikuttavat samalta, luokkien ja käyttöliittymän välillä on tiettyjä eroja. Tärkeimmät erot luokan ja käyttöliittymän välillä on mainittu alla:

Toteutus: Käyttöliittymän toteuttamiseksi käytämme avainsanaa toteuttaa

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

Esimerkkejä Java-liitännöistä

Tarkastellaanpa esimerkkiä ajoneuvoista, kuten polkupyöristä, autoista, polkupyöristä jne., niillä on yhteisiä toimintoja. Joten teemme käyttöliittymän ja laitamme kaikki nämä yhteiset toiminnot. Ja antaa polkupyörän, pyörän, auton jne. toteuttaa kaikki nämä toiminnot omassa luokassaan omalla tavallaan.

Alla on yllä olevan aiheen toteutus:

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

Java-rajapintojen käytön edut ovat seuraavat:

• Välitämättä toteutusosaan voimme saavuttaa toteutuksen turvallisuuden.
• Javassa useita perintöjä ei sallita, mutta voit käyttää sitä käyttöliittymän avulla, koska voit toteuttaa useamman kuin yhden rajapinnan.

Moniperintö Javassa käyttöliittymän avulla

Multiple Heritance on OOP-konsepti, jota ei voida toteuttaa Javassa luokkien avulla. Mutta voimme käyttää useita perintöjä Javassa käyttöliittymän avulla. tarkistetaan tämä esimerkin avulla.

Esimerkki:

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

Uusia ominaisuuksia lisätty käyttöliittymiin JDK 8:ssa

Alla mainittuihin JDK 8 -päivityksen liitäntöihin on lisätty tiettyjä ominaisuuksia:

1. Ennen JDK 8:aa käyttöliittymä ei voinut määrittää toteutusta. Voimme nyt lisätä oletustoteutuksen käyttöliittymämenetelmille. Tällä oletustoteutuksella on erityinen käyttötarkoitus, eikä se vaikuta rajapintojen taustalla olevaan tarkoitukseen.

Oletetaan, että meidän on lisättävä uusi toiminto olemassa olevaan käyttöliittymään. Ilmeisesti vanha koodi ei toimi, koska luokat eivät ole toteuttaneet näitä uusia toimintoja. Joten oletustoteutuksen avulla annamme oletusrungon äskettäin lisätyille funktioille. Silloin vanhat koodit toimivat edelleen.

Alla on yllä olevan kohdan toteutus:

java-tarkistus on tyhjä

// 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. Toinen JDK 8:aan lisätty ominaisuus on, että voimme nyt määrittää staattisia menetelmiä rajapinnoissa, joita voidaan kutsua itsenäisesti ilman objektia.

Huomautus: nämä menetelmät eivät ole periytyviä.

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

Liitäntöjen laajentaminen

Yksi käyttöliittymä voi periä toisen käyttämällä avainsanan laajennusta. Kun luokka toteuttaa rajapinnan, joka perii toisen rajapinnan, sen on tarjottava toteutus kaikille rajapinnan periytymisketjun vaatimille menetelmille.

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

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

Yksinkertaisella tavalla käyttöliittymä sisältää useita abstrakteja menetelmiä, joten kirjoita toteutus toteutusluokkiin. Jos toteutus ei pysty tarjoamaan kaikkien abstraktien menetelmien toteutusta, ilmoita toteutusluokka abstraktilla muokkaimella ja suorita loput menetelmän toteutukset seuraavissa luoduissa aliluokissa. On mahdollista ilmoittaa useita lapsiluokkia, mutta lopulta olemme toteuttaneet kaikki abstraktit menetelmät.

Yleensä kehitysprosessi on askel askeleelta:

Taso 1 – rajapinnat: Se sisältää palvelutiedot.
Taso 2 – abstraktit luokat: Se sisältää osittaisen toteutuksen.
Taso 3 – toteutusluokat: Se sisältää kaikki toteutukset.
Taso 4 – Lopullinen koodi / päämenetelmä: Sillä on pääsy kaikkiin rajapintojen tietoihin.

Esimerkki:

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

Uusia ominaisuuksia lisätty käyttöliittymiin JDK 9:ssä

Java 9:stä eteenpäin käyttöliittymät voivat sisältää myös seuraavat:

1. Staattiset menetelmät
2. Yksityiset menetelmät
3. Yksityiset staattiset menetelmät

Tärkeitä kohtia Java-rajapinnoissa

Artikkelissa opimme tiettyjä tärkeitä kohtia liitännöistä, kuten alla mainitaan:

• Emme voi luoda ilmentymää (rajapintaa ei voi ilmentää) käyttöliittymästä, mutta voimme tehdä siihen viittauksen, joka viittaa sen toteutusluokan objektiin.
• Luokka voi toteuttaa useamman kuin yhden käyttöliittymän.
• Liitäntä voi ulottua toiseen käyttöliittymään tai rajapintaan (useampaan kuin yhteen rajapintaan).
• Luokan, joka toteuttaa rajapinnan, tulee toteuttaa kaikki rajapinnan menetelmät.
• Kaikki menetelmät ovat julkisia ja abstrakteja. Ja kaikki kentät ovat julkisia, staattisia ja lopullisia.
• Sitä käytetään useiden perintöjen saavuttamiseen.
• Sitä käytetään löysän liitoksen aikaansaamiseen.
• Käyttöliittymän sisällä ei ole mahdollista ilmoittaa ilmentymämuuttujia, koska oletusarvoisesti muuttujat ovat julkinen staattinen finaali.
• Käyttöliittymän sisällä rakentajat eivät ole sallittuja.
• Käyttöliittymän sisällä päämenetelmä ei ole sallittu.
• Käyttöliittymän sisällä staattisten, lopullisten ja yksityisten menetelmien ilmoittaminen ei ole mahdollista.

Täytyy lukea

• Käyttöliittymien menetelmien määrittäjä
• Luokkien tai käyttöliittymien määritykset Javassa
• Abstraktit luokat Javassa
• Java-vertailuliittymä
• Java-rajapintamenetelmät
• Sisäkkäinen käyttöliittymä Javassa

Usein kysytyt kysymykset käyttöliittymissä

1. Mikä on merkintä tai merkitty käyttöliittymä?

Tagged Interfacet ovat rajapintoja ilman menetelmiä, ja ne toimivat merkkinä ilman mitään ominaisuuksia.

2. Kuinka monta tyyppistä rajapintaa Javassa?

Java-rajapintojen tyypit on mainittu alla:

1. Toiminnallinen käyttöliittymä
2. Merkin käyttöliittymä

3. Miksi moniperintöä ei tueta luokan kautta Javassa?

Useita perintöä ei tueta luokan kautta Javassa, jotta vältetään tietyt haasteet, kuten epäselvyys ja timanttiongelmat.