Vad är gränssnitt i Java och hur man implementerar det?

' Gränssnitt är en avancerad nivå för att uppnå abstraktion i Java Programming Language. Java-gränssnitt hjälper till i minskning av komplexiteten i koden och förenklar läsbarhet . I den här artikeln kommer jag att förklara Java-gränssnittet genom följande docket.

• Vad är ett Java-gränssnitt?
• Varför behöver vi ett gränssnitt?
• Förklara ett Java-gränssnitt: syntax
• Exempel på Java-gränssnitt
• Häckar Java-gränssnittet
• Skillnad mellan klass och gränssnitt
• Fördelar och nackdelar med gränssnitt
• Nyckelpunkter på Java-gränssnittet

Vad är ett Java-gränssnitt?

Datorgränssnitt är känd som en gräns som separerar två eller flera system. Det utbyter data mellan komponenterna i ett system som kan signaler, kommandon eller protokoll.

Java Abstraction tillhandahåller funktionaliteten hos en viss metod genom att dölja implementeringslogiken skriven i metoden. På samma sätt är Java-gränssnitt också en abstrakt klass som innehåller metoddeklarationen men inte dess definition. En klass redskap ett gränssnitt för att ärva de abstrakta metoderna. Tillsammans med abstrakta metoder, en gränssnitt kan också inkludera konstanter, statiska metoder, kapslade gränssnitt och standardmetoder.

Likheter mellan en klass och ett gränssnitt.

Ett gränssnitt liknar helt en vanlig klass i Java. Ett gränssnitt innehåller abstrakta metoder och dessa metoder är utformade för att implementeras. Denna process är bara lika med arv, vilket är normalt när det gäller klasser. Vi kommer att diskutera mer om likheter.

• Samma som en klass, ett gränssnitt kan också innehålla så många metoder som krävs.
• I likhet med klasser skrivs gränssnittet också med a .java filtillägg.
• Överraskande nog kommer bytkoden för ett gränssnitt att ha dykt upp i en .klass fil.
• Ett gränssnitt visas i form av ett paket och deras respektive bytkod finns i en katalog som matchar paketnamnet.

Varför behöver vi ett gränssnitt?

Java stöder inte Flera arv, på grund av vilket, Det tillåter inte klasser att förlänga mer än en klass i en instans. Barnklasser kunde inte ärva egenskaperna hos flera föräldraklasser i en enda instans, eftersom det resulterar i Diamantproblem. För att övervinna denna fråga, Gränssnitt införs. Låt oss förstå detta problem genom ett exempel.

vad är en buffradläsare java

Låt oss anta att vi har två plan, en kan bara bära passagerare, bara den andra placera. Nu måste vi ärva egenskaperna hos både lastplanet och passagerarplanet. Java stöder inte den här lösningen eftersom den hamnar i tvetydighet mellan de två planen.

Men om du kan göra det möjligt genom att Java känner att det ärver ett plan och genomförande metoderna som finns i det andra planet. Det är som ett kommersiellt flygplan som tar både passagerare och bagage. Gränssnittet är som att skapa ett större plan som kan göra båda uppgifterna utan att störa varandras komponenter, istället bara låna metoderna från Gränssnittsklass.

// Klass A-kod

paket flera klass A {void msg () {System.out.println ('Hej')}}

// Klass B-kod

paket multipel klass B {void msg () {System.out.println ('Välkommen')}}

Klass C-kod

paket multipel klass C sträcker sig A, B {// Detta accepteras inte av Java, det kommer att kasta ett fel och koden kommer inte att köras. public static void main (String args []) {C obj = new C () obj.msg ()}}

Produktion:

Fel. Det här tillvägagångssättet ger ett undantag. Java stöder inte flera arv. Detta fel kallas Diamantproblem 

Låt oss prova en lösning med hjälp av ett gränssnitt, Barnklasser kan komma åt metoderna från Flera föräldrar klasser i en enda instans.

// Gränssnittskod

paket MIS offentliga gränssnittslösning {public void Hello () public void Welcome ()}

// Klasskod

paket MIS public class classA implementerar lösning {public void Hello () {java.lang.System.out.println ('Hello world')} public void Welcome () {java.lang.System.out.println ('Welcome to Edureka ')} public static void main (String [] args) {classA Edureka = new classA () Edureka.Hello () Edureka.Welcome ()}}

Produktion:

Hej världen

Välkommen till Edureka

Förklara ett Java-gränssnitt: syntax

gränssnitt gränssnittsnamn {// deklarera konstanta fält // deklarera metoder () // standardmetoder}

Låt oss gå igenom ett exempel på Java Interface

Exempel på Java-gränssnitt

Låt oss skapa en enkel kalkylator baserad på Java-gränssnitt.

// Gränssnittskod

paket basoperationer offentligt gränssnitt matematik {public void add () public void sub () public void mul () public void div ()}

// Klasskod

paket basoperationer importera java.util.Scanner public class student1 implementerar matematik {@Override public void add () {Scanner kb = new Scanner (System.in) System.out.println ('Ange två heltal för att utföra tillägg') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('Summan av' + a + 'och' + b + 'är' + s)} @ Override public void sub () {Scanner kb = new Scanner (System.in) System.out.println ('Enter any two integer values ​​to perform substraction') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('Skillnaden mellan' + a + 'och' + b + 'är' + s)} @Override public void mul () {Scanner kb = new Scanner (System.in) System.out.println ('Enter valfri två heltal värderingsmultiplikation ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' Produkt av '+ a +' och '+ b +' är '+ s)} @Override public void div () {Scanner kb = new Scanner (System.in) System.out.println ('Enter any two helgetals division') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('Kvotient av' + a + 'och' + b + 'är' + s)} offentligt statiskt tomrum huvud (String [] args) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

Produktion:

När vi går vidare kommer vi att lära oss att bygga ett Java-gränssnitt.

Häckar Java-gränssnittet

Gränssnitt häckande är en process för att deklarera ett gränssnitt i en annan Befintligt gränssnitt eller förklarar ett gränssnitt inuti en Klass. Det kapslade gränssnittet är också känt som en Inre gränssnitt.

print_r till sträng

Det kapslade gränssnittet kan inte nås direkt . Därför implementeras häckning för att lösa namnytorna genom att gruppera dem med deras relaterade Gränssnitt och Klasser. Genom denna procedur,vi kan ringa Kapslat gränssnitt genom Yttre klass eller Yttre gränssnitt namn följt av a punkt (.) och Gränssnittsnamn.

Låt oss prova några exempel baserade på Gränssnitt häckande. Låt oss först försöka häcka en Java-gränssnitt inuti en annan Java-gränssnitt enligt nedanstående:

// Gränssnittskod

paket Nest offentligt gränssnitt OuterInterface {void display () interface InnerInterface {void InnerMethod ()}}

// Klasskod

paket Nest-klass NestedInterfaceDemo implementerar OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('First' + n + 'terms:') för (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int sum = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nPrinting from Nested InnerInterface method ...! n ')} offentligt statiskt tomrum huvud (String args []) {OuterInterface.InnerInterface obj = new NestedInterfaceDemo () obj.InnerMethod ()}}

Produktion:

De första 10 termerna: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + Utskrift från Nested InnerInterface-metoden ...!

Nu, låt oss försöka bo en Java-gränssnitt inuti en Java-klass.

// Gränssnittskod

paket Nest2 public class EdurekaClass {interface EdurekaInterface {void NestedMethod ()}}

// Klasskod

paket Nest2-klass NestedInterfaceDemo2 implementerar EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' byte [] strAsByteArray = input.getBytes () byte [] resultat = ny byte [strAsByteArray.length] för (int i = 0 .längd i ++) resultat [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 ()}}

Produktion:

akerudE

Även om ett gränssnitt ser nästan ut som en klass, finns det vissa skillnader mellan dem. Låt oss diskutera deras skillnader.

Skillnad mellan Java Class och Java Interface

Fördelar och nackdelar med Java Interface

Fördelar:

java gjutna sträng hittills

• Java-gränssnitt stöder Flera arv.
• Java Interface gör det möjligt för programmerare att bryta upp komplexa programmeringsmetoder och förenkla beroenden mellan föremålen.
• Java Interface gör datamedlemmar och metoder i en applikation som ska kopplas löst.

Nackdelar:

• Användning av Java-gränssnitt minskar körhastighet av ansökan.
• Java-gränssnitt i applikationen används antingen upprepade gånger i stor utsträckning eller används knappast alls.

Nyckelpunkter på Java-gränssnittet

• Ingen av metoderna som deklareras i gränssnittet har en kropp som gör att den ger fullständig abstraktion.
• Det är inte möjligt att skapa ett objekt i ett gränssnitt. Instantiering av ett gränssnitt är därför inte möjligt.
• En klass kan implementera ett gränssnitt med hjälp av nyckelordet. Låt oss se detta genom ett exempel.

// Gränssnittskod

paket extInterface offentligt gränssnitt extInterface {public void method1 () public void method2 ()}

// Klasskod

paket extInterface import java.util.Scanner klass Edureka implementerar extInterface {public void method1 () {System.out.println ('implementering av metod1') Scanner scanner = ny Scanner (System.in) System.out.println ('Ange nummer för att hitta kvadratrot i Java: ') dubbel kvadrat = scanner.nextDouble () dubbel kvadratRoot = Math.sqrt (kvadrat) System.out.printf (' Kvadratrot av tal:% f är:% f% n ', kvadrat, squareRoot)} public void method2 () {System.out.println ('implementering av method2')} public static void main (String arg []) {extInterface obj = new Edureka () obj.method1 ()}}

Produktion:

implementering av metod1 Ange nummer för att hitta kvadratrot i Java: 16 Kvadratrot av nummer: 16.0 är: 4.0

• En klass kan implementera flera arv i en enda instans. Låt oss förstå det genom följande kod.

// Kod för gränssnitt 1

paket ExtendInt offentligt gränssnitt Interface1 {public void armstrong ()}

// Kod för gränssnitt 2

paket ExtendInt offentligt gränssnitt Interface2 {public void prime ()} // Klasskodspaket ExtendInt public class Edureka2 implementerar Interface1, Interface2 {public void armstrong () {int c = 0, a, temp int n = 153 // input temp = n medan (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} om (temp == c) System.out.println ('armstrong number') annat System.out.println ('Inte armstrong nummer') System.out.println ('Extending to Interface 1')} public void prime () {int i, m = 0, flag = 0 int n = 3 // input m = n / 2 if (n == 0 || n == 1) {System.out.println (n + 'är inte primtal')} annat {för (i = 2i & lt = mi ++) {if (n% i == 0) {System .out.println (n + 'är inte primtal') flagga = 1 bryt}} om (flagga == 0) {System.out.println (n + 'är primtal')}} System.out.println ('Extending till gränssnitt 2 ')} offentlig statisk ogiltig huvud (String args []) {Interface2 obj = new Edureka2 () obj.prime () Interface1 obj1 = new Edureka2 () obj1.armstrong ()}}

Produktion:

3 är primtal Utökat till gränssnitt 2 armstrong nummer Utökat till gränssnitt 1

• Java Interface kräver att deklarerade variablerna initialiseras vid tidpunkten för deklarationen.
• Åtkomstmodifierare för ett gränssnitt är som standard offentliga statiska och slutliga. Låt oss förstå detta genom ett exempel

// Gränssnittskod

paket test offentligt gränssnitt Prova {// public int a = 10 // public static final int a = 10 // static int a = 0 // final int a = 10 // int a = 10}

• Alla ovanstående deklarationer är sanna och giltiga i ett gränssnitt.
• Java-gränssnittet kan utöka ett antal gränssnitt, men kan aldrig implementera en.
• En Java-klass kan implementera valfritt antal gränssnitt.
• Java Class kan inte implementera gränssnitt med samma metodnamn och annan returtyp.
• Om det finns två eller flera metoder med samma metodnamn finns i flera gränssnitt är det tillräckligt att implementera metoden en gång. Låt oss förstå detta med ett praktiskt exempel.

// Gränssnittskod

paket samma offentliga gränssnitt A {public void display ()} // Interface Code package same public interface B {public void display ()} // Class Code package same class same implement A, B {public void display () {System.out .println ('displaying data')} public static void main (String [] args) {same print = new same () print.display ()}}

Produktion:

Välkommen till Edureka E-Learning

Med detta kommer vi till ett slut på den här artikeln. Jag hoppas att du har förstått vikten av gränssnitt, syntax, funktionalitet, gränssnitts nestning, nyckelpunkter i Java-gränssnittet och operationer som utförs med dem.

Nu när du har förstått grunderna i Java, kolla in av Edureka, ett pålitligt inlärningsföretag online med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen. Edurekas Java J2EE- och SOA-utbildning och certifieringskurs är utformad för studenter och yrkesverksamma som vill vara Java-utvecklare. Kursen är utformad för att ge dig ett försprång till Java-programmering och träna dig för både kärn- och avancerade Java-koncept tillsammans med olika Java-ramverk som Hibernate & Vår .

Har du en fråga till oss? Nämn det i kommentarsektionen på denna 'Java Interface' -blogg så återkommer vi till dig så snart som möjligt.