Mi az interfész a Java-ban és hogyan lehet azt megvalósítani?

' Felület az absztrakció elérésének fejlett szintje a Java programozási nyelvben. A Java felület segít a a komplexitás csökkentése a kódban, és leegyszerűsíti a olvashatóság . Ebben a cikkben elmagyarázom neked a Java felületet a következő aljzaton keresztül.

• Mi az a Java interfész?
• Miért van szükségünk interfészre?
• Java-felület deklarálása: Szintaxis
• Java interfész példa
• A Java interfész beágyazása
• Különbség az osztály és az interfész között
• Az interfész előnyei és hátrányai
• A Java felület legfontosabb pontjai

Mi az a Java interfész?

Számítógépes interfész két vagy több rendszert elválasztó határként ismert. Adatokat cserél a rendszer alkatrészei között, amelyek jeleket, parancsokat vagy protokollokat küldhetnek.

A Java Abstraction egy adott módszer funkcionalitását biztosítja a módszer belsejébe írt megvalósítási logika elrejtésével. Hasonlóképpen, a Java interfész is egy absztrakt osztály, amely tartalmazza a Method deklarációt, de nem a definícióját. Osztály megvalósítja interfész az absztrakt módszerek örökléséhez. Az elvont módszerekkel együtt egy felület tartalmazhat konstansok, statikus módszerek, beágyazott interfészek és alapértelmezett módszerek.

Az osztály és az interfész hasonlóságai.

Egy felület teljesen hasonlít a Java normál osztályához. Egy interfész tartalmazza az absztrakt módszereket, és ezeket a módszereket megvalósításra tervezték. Ez a folyamat pusztán az örökléssel egyenlő, ami normális, ha osztályokról van szó. Még többet fogunk megvitatni a hasonlóságokról.

• Az osztály ugyanúgy, mint egy osztály, a szükséges számú metódust is tartalmazhatja.
• Az osztályokhoz hasonlóan a felületet is a-val írják .Jáva kiterjesztés fájl.
• Meglepő módon egy interfész bájtkódja megjelenik a .osztály fájl.
• Az interfész csomag formájában jelenik meg, és a hozzájuk tartozó bájtkód egy könyvtárban található, amely megegyezik a csomag nevével.

Miért van szükségünk interfészre?

A Java nem támogatja Több örökség, aminek következtében nem engedélyezi az osztályok számára, hogy egy példánynál egynél több osztályt bővítsenek. Gyermekosztályok nem örökölhette a tulajdonságait több szülő osztály egyetlen példányban, aminek eredményeként Gyémántprobléma. A probléma leküzdése érdekében Felület kerül bevezetésre. Értsük meg ezt a problémát egy példán keresztül.

Tegyük fel, hogy két gépünk van, az egyik csak szállítható utasok, csak a másikat pozíció. Most meg kell örököl a teherszállító repülőgép és az utasszállító repülőgép tulajdonságai. A Java nem támogatja ezt a megoldást, mivel végül kétértelműség a két sík között.

De ha ezt lehetővé teszi azáltal, hogy a Java úgy érzi, hogy egy síkot örököl és végrehajtása a másik síkon jelenlévő módszerek. Olyan, mint egy kereskedelmi repülőgép, amely az utasokat és a csomagokat is elszállítja. Az interfész olyan, mint egy nagyobb sík készítése, amely mindkét feladatot megteheti anélkül, hogy beavatkozna egymás komponenseibe, ehelyett csak kölcsön kéri a módszereket a Interfész osztály.

// A osztályú kód

több A osztályú csomag csomagolása {void msg () {System.out.println ('Hello')}}

// B osztályú kód

csomag több B osztály {void msg () {System.out.println ('Welcome')}}

C osztály kód

A C osztály többszörös kiterjesztése A, B kiterjesztésű {// Ezt a Java nem fogadja el, hibát fog okozni, és a kód nem kerül végrehajtásra. public static void main (String args []) {C obj = new C () obj.msg ()}}

Kimenet:

Hiba. Ez a sajátos megközelítés kivételt jelent. A Java nem támogatja a többszörös öröklést. Ez a hiba néven ismert Gyémántprobléma 

Próbálja ki a megoldást egy felület használatával, Gyermekosztályok innen érheti el a módszereket Többszörös szülő osztályok egyetlen példányban.

logisztikai regresszió python példában

// Interfészkód

csomag MIS nyilvános felület megoldás {public void Hello () public void Welcome ()}

// Osztálykód

csomag MIS public class classA megoldást valósít meg {public void Hello () {java.lang.System.out.println ('Hello world')} public void Welcome () {java.lang.System.out.println ('Üdvözöljük az Edureka oldalán ')} public static void main (String [] érvel) {classA Edureka = new classA () Edureka.Hello () Edureka.Welcome ()}}

Kimenet:

Helló Világ

Üdvözöljük az Edurekában

Java-felület deklarálása: Szintaxis

felület interfész_neve {// állandó mezők deklarálása // módszerek deklarálása () // alapértelmezett módszerek}

Nézzünk át egy példát a Java felületen

Java interfész példa

Hozzunk létre egy egyszerű számológépet, amely a Java felületen alapul.

// Interfészkód

csomag alapműveletek nyilvános felület matematika {public void add () public void sub () public void mul () public void div ()}

// Osztálykód

package basicoperations import java.util.Scanner public class student1 matematikát valósít meg {@Orride public void add () {Scanner kb = new Scanner (System.in) System.out.println ('Adjon meg két egész értéket az összeadás végrehajtásához') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('A' + a + 'és' + b + 'összege' + s összege)} @Orride public void sub () {Szkenner kb = új Szkenner (System.in) System.out.println ('Bármely két egész értéket adjon meg a szubsztrakció végrehajtásához') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('A' + a + 'és' + b + 'különbsége' + s)} @Orride public void mul () {Scanner kb = new Scanner (System.in) System.out.println ('Enter bármely két egész érték szorzása ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' A '+ a + és' + b + 'szorzata' + s)} @Orride public void div () {Szkenner kb = new Szkenner (System.in) System.out.println ('Adjon meg bármelyik két egész érték osztást') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('A' + a + és '+ b +' hányadosa a '+ s)} public static void main (String [] args) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

Kimenet:

Tovább haladva megtanuljuk fészkelni a Java felületet.

A Java interfész beágyazása

Interfész fészkelése az Interface deklarálása egy másikban Meglévő interfész vagy az Interface deklarálása a Osztály. A beágyazott felület an néven is ismert Belső felület.

A beágyazott felület nem érhető el közvetlenül . Ezért a fészkelést a névterek feloldása érdekében valósítják meg, csoportosítva őket a hozzájuk tartozó területekkel Interfészek és Osztályok. Ezzel az eljárássalhívhatjuk a Beágyazott felület keresztül Külső osztály vagy Külső interfész név, amelyet a pont (.) , és Interfész neve.

Próbáljunk ki néhány példát ezek alapján Interfész fészkelése. Először próbáljuk meg fészkelni a Java interfész belül egy másik Java interfész az alábbiak szerint:

// Interfészkód

csomag Nest nyilvános felület OuterInterface {void display () interfész InnerInterface {void InnerMethod ()}}

// Osztálykód

A Nest osztály NestedInterfaceDemo végrehajtja az OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('Első' + n + 'kifejezések:') for (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int összeg = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nNyomtatás a beágyazott InnerInterface módszerből ...! n ')} public static void main (String args []) {OuterInterface.InnerInterface obj = new NestedInterfaceDemo () obj.InnerMethod ()}}

Kimenet:

Az első 10 kifejezés: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + Nyomtatás a beágyazott InnerInface felületről ...!

Most próbáljuk meg fészkelni a Java interfész belül a Java osztály.

// Interfészkód

csomag Nest2 nyilvános osztály EdurekaClass {felület EdurekaInterface {void NestedMethod ()}}

// Osztálykód

csomag Nest2 osztály NestedInterfaceDemo2 megvalósítja az EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' bájt [] strAsByteArray = input.getBytes () byte [] eredmény = új bájt [strAsByteArray.lengthByte] az (int iA 0 i .length i ++) result [i] = strAsByteArray [strAsByteArray.length-i-1] System.out.println (new String (result))} public static void main (String args []) {EdurekaClass.EdurekaInterface obj = new NestedInterfaceDemo2 () obj.NestedMethod ()}}

Kimenet:

akerudE

Bár egy interfész szinte hasonlít egy osztályhoz, vannak köztük néhány különbségek, Beszéljük meg a különbségeiket.

hozzon létre egy tömb objektumot

Különbség a Java osztály és a Java interfész között

A Java felület előnyei és hátrányai

Előnyök:

• Java interfész támogatja Többszörös öröklés.
• A Java Interface lehetővé teszi a programozók számára, hogy szétbontják a komplex programozási megközelítéseket és egyszerűsítsék a függőségek a tárgyak között.
• A Java interfész teszi a adattagok és mód lazán összekapcsolható alkalmazásban.

Hátrányok:

• A Java felület használata csökkenti a végrehajtási sebesség az alkalmazás.
• Az alkalmazás Java interfészeit vagy ismételten használják, vagy alig használják.

A Java felület legfontosabb pontjai

• Az interfészen deklarált módszerek egyike sem rendelkezik olyan testtel, amely teljes absztrakciót biztosítana.
• Nem lehet objektumot létrehozni egy felületről. Ennélfogva az interfész azonnali létrehozása nem lehetséges.
• Az osztály megvalósíthatja a felületet a kulcsszóeszközök használatával. Lássuk ezt egy példán keresztül.

// Interfészkód

csomag extInterface nyilvános felület extInterface {public void módszer1 () public void módszer2 ()}

// Osztálykód

csomag extInterface import java.util.Scanner osztály Az Edureka implementálja az extInterface {public void method1 () {System.out.println ('method1 megvalósítása') Scanner scanner = új Scanner (System.in) System.out.println ('Szám megadása négyzetgyök kereséséhez a Java-ban: ') double square = scanner.nextDouble () double squareRoot = Math.sqrt (square) System.out.printf (' A (z)% f négyzetgyöke:% f% n ', négyzet, squareRoot)} public void method2 () {System.out.println ('method2 végrehajtása')} public static void main (String arg []) {extInterface obj = new Edureka () obj.method1 ()}}

Kimenet:

A method1 megvalósítása Írja be a számot a négyzetgyök megtalálásához a Java-ban: 16 A négyzetgyök négyzetgyöke: 16.0: 4.0

• Egy osztály egyszerre több örökséget valósíthat meg. Értsük meg a következő kód segítségével.

// 1. interfész kódja

csomag ExtendInt public interface 1. interfész {public void armstrong ()}

// 2. interfész kódja

csomag ExtendInt public interface Interface2 {public void prime ()} // Osztálykód csomag ExtendInt public class Edureka2 implementálja az Interface1, Interface2 {public void armstrong () {int c = 0, a, temp int n = 153 // input temp = n while (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} if (temp == c) System.out.println ('armstrong number') else System.out.println ('Nem önálló szám') System.out.println ('Kiterjesztés az 1. interfészre')} public void prime () {int i, m = 0, flag = 0 int n = 3 // bemenet m = n / 2, ha (n == 0 || n == 1) {System.out.println (n + 'nem prímszám')} else {for (i = 2i & lt = mi ++) {if (n% i == 0) {Rendszer .out.println (n + 'nem prímszám') flag = 1 break}} if (flag == 0) {System.out.println (n + 'prímszám')}} System.out.println ('Kiterjesztés a 2. interfészhez ')} public static void main (String args []) {Interface2 obj = new Edureka2 () obj.prime () Interface1 obj1 = new Edureka2 () obj1.armstrong ()}}

Kimenet:

3 a prímszám Kiterjesztés a 2. interfészre Armstrong szám Kiterjesztés az 1. interfészre

• A Java Interface megköveteli a deklarált változók inicializálását a deklaráláskor.
• Az interfész hozzáférés-módosítói alapértelmezés szerint nyilvános statikusak és véglegesek. Értsük meg ezt egy példával

// Interfészkód

csomag teszt nyilvános felület Próbálja ki: {// public int a = 10 // public static final int a = 10 // static int a = 0 // final int a = 10 // int a = 10}

• Az összes fenti nyilatkozat igaz és érvényes egy interfészen belül.
• A Java Interface képes bármilyen interfész kiterjesztésére, de soha nem tudja megvalósítani.
• A Java osztály tetszőleges számú interfészt képes megvalósítani.
• A Java osztály nem képes azonos metódusnévvel és eltérő visszatérési típussal rendelkező interfészeket megvalósítani.
• Ha két vagy több metódus van ugyanazzal a metódusnévvel, több interfészen léteznek, akkor elegendő a módszer egyszeri végrehajtása. Értsük meg ezt egy gyakorlati példával.

// Interfészkód

csomag ugyanazon nyilvános felület A {public void display ()} // Interface Code package same public interface B {public void display ()} // Osztálykód csomag ugyanazon osztály azonos eszközei A, B {public void display () {System.out .println ('adatok megjelenítése')} public static void main (String [] args) {same print = new same () print.display ()}}

Kimenet:

Üdvözöljük az Edureka E-Learning webhelyen

Ezzel a cikk végére értünk. Remélem, megértette az interfész, a szintaxis, a funkcionalitás, az interfész fészkelése, a Java interfész legfontosabb pontjai és az ezek használatával végzett műveletek fontosságát.

Most, hogy megértette a Java alapjait, nézze meg a az Edureka, egy megbízható online tanulási vállalat, amelynek több mint 250 000 elégedett tanulóval rendelkező hálózata elterjedt az egész világon. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát olyan hallgatók és szakemberek számára tervezték, akik Java fejlesztők szeretnének lenni. A tanfolyamot úgy tervezték, hogy előrelépést nyújtson a Java programozásban, és betanítson mind az alapvető, mind a fejlett Java koncepciókra, különféle Java keretrendszerekkel együtt, mint például a Hibernate & Tavaszi .

Van egy kérdésünk? Említse meg ennek a „Java Interface” blognak a megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.