Wat is interface in Java en hoe implementeer je het?

' Koppel is een geavanceerd niveau van het bereiken van abstractie in de programmeertaal Java. Java-interface helpt bij het vermindering van complexiteit in de code en vereenvoudigt de leesbaarheid . In dit artikel zal ik je de Java-interface uitleggen via de volgende rol.

hoe array in php

• Wat is een Java-interface?
• Waarom hebben we een interface nodig?
• Een Java-interface declareren: syntaxis
• Voorbeeld van een Java-interface
• De Java-interface nesten
• Verschil tussen klasse en interface
• Voordelen en nadelen van interface
• Belangrijkste punten op Java-interface

Wat is een Java-interface?

Computerinterface staat bekend als een grens die twee of meer systemen scheidt. Het wisselt gegevens uit tussen de componenten in een systeem die signalen, opdrachten of protocollen kunnen bevatten.

Java Abstraction biedt de functionaliteit van een bepaalde methode door de implementatielogica te verbergen die in de methode is geschreven. Evenzo is Java-interface ook een abstracte klasse die de methodeverklaring bevat, maar niet de definitie ervan. Een klas werktuigen een interface om de abstracte methoden te erven. Samen met abstracte methoden, een koppel kan ook bevatten constanten, statische methoden, geneste interfaces en standaard methoden.

Overeenkomsten tussen een klasse en een interface.

Een interface lijkt volledig op een normale klasse in Java. Een interface bevat de abstracte methoden en deze methoden zijn ontworpen om te worden geïmplementeerd. Dit proces is slechts gelijk aan overerving, wat normaal is als het gaat om klassen. We zullen meer bespreken over overeenkomsten.

• Net als een klasse, kan een interface ook zoveel methoden bevatten als nodig is.
• Net als bij klassen, is de interface ook geschreven met een .Java extension bestand.
• Verrassend genoeg zal de bytecode voor een interface zijn verschenen in een .klasse het dossier.
• Een interface wordt getoond in de vorm van een pakket en hun respectievelijke bytecode bevindt zich in een map die overeenkomt met de pakketnaam.

Waarom hebben we een interface nodig?

Java ondersteunt geen Meerdere erfenissen, waardoor, het zal niet toestaan ​​dat klassen meer dan één klasse per instantie uitbreiden. Kinderlessen kon de eigenschappen van niet erven meerdere bovenliggende klassen in één instantie, omdat het resulteert in Diamond probleem. Om dit probleem op te lossen, Koppel is voorgesteld. Laten we dit probleem aan de hand van een voorbeeld begrijpen.

Laten we aannemen dat we twee vliegtuigen hebben, die er maar één kan dragen passagiers, alleen de andere positie. Nu moeten we erven de eigenschappen van zowel het vrachtvliegtuig als het passagiersvliegtuig. Java zou deze oplossing niet ondersteunen als deze in dubbelzinnigheid tussen de twee vliegtuigen.

Maar als je het mogelijk kunt maken door Java het gevoel te geven dat het één vlak erft en implementeren de methoden die aanwezig zijn in het andere vlak. Het is als een commercieel vliegtuig dat zowel passagiers als vrachtbagage vervoert. De interface is als het maken van een groter vliegtuig dat beide taken zou kunnen uitvoeren zonder de componenten van elkaar te hinderen, in plaats daarvan de methoden van de Interfaceklasse.

// Klasse A-code

pakket meerdere klasse A {void msg () {System.out.println ('Hallo')}}

// Klasse B-code

pakket meerdere klasse B {void msg () {System.out.println ('Welkom')}}

Klasse C-code

pakket meerdere klasse C verlengt A, B {// Dit wordt niet geaccepteerd door Java, het genereert een fout en de code wordt niet uitgevoerd. public static void main (String args []) {C obj = nieuwe C () obj.msg ()}}

Uitgang:

Fout. Deze specifieke aanpak genereert een uitzondering. Java ondersteunt geen meerdere overervingen. Deze fout staat bekend als Diamond probleem 

Laten we een oplossing proberen door een interface te gebruiken, Kinderlessen heeft toegang tot de methoden van Meerdere ouders klassen in één instantie.

// Interfacecode

pakket MIS openbare interface-oplossing {public void Hallo () public void Welkom ()}

//Klassencode

pakket MIS public class classA implementeert oplossing {public void Hello () {java.lang.System.out.println ('Hallo wereld')} public void Welcome () {java.lang.System.out.println ('Welkom bij Edureka ')} public static void main (String [] args) {classA Edureka = new classA () Edureka.Hello () Edureka.Welcome ()}}

Uitgang:

Hallo Wereld

Welkom in Edureka

Een Java-interface declareren: syntaxis

interface interface_name {// declareer constante velden // declareer methodes () // standaard methodes}

Laten we een voorbeeld bekijken over Java-interface

Voorbeeld van een Java-interface

Laten we een eenvoudige rekenmachine maken op basis van Java-interface.

// Interfacecode

pakket basisbewerkingen openbare interface wiskunde {public void add () public void sub () public void mul () public void div ()}

//Klassencode

pakket basisbewerkingen import java.util.Scanner openbare klas student1 implementeert wiskunde {@Override public void add () {Scanner kb = nieuwe Scanner (System.in) System.out.println ('Voer twee gehele getallen in om optellen uit te voeren') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('Som van' + a + 'en' + b + 'is' + s)} @Override public void sub () {Scanner kb = nieuwe scanner (System.in) System.out.println ('Voer twee gehele getallen in om aftrekken uit te voeren') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('Verschil van' + a + 'en' + b + 'is' + s)} @Override public void mul () {Scanner kb = nieuwe scanner (System.in) System.out.println ('Enter elke twee vermenigvuldiging van gehele getallen ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' Product van '+ a +' en '+ b +' is '+ s)} @Override public void div () {Scanner kb = nieuwe scanner (System.in) System.out.println ('Voer een willekeurige divisie van twee gehele getallen in') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('Quotiënt van' + a + 'en' + b + 'is' + s)} public static void main (String [] args) {student1 Edureka1 = nieuwe student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

Uitgang:

Als we verder gaan, zullen we leren om een ​​Java-interface te nesten.

De Java-interface nesten

Interface nesten is een proces waarbij een interface binnen een andere wordt aangegeven Bestaande interface of het declareren van een interface binnen een Klasse. De geneste interface wordt ook wel een Innerlijke interface.

De geneste interface is niet toegankelijk direct . Daarom wordt nesten geïmplementeerd om de naamruimten op te lossen door ze te groeperen met hun verwante Interfaces en Klassen. Door deze procedure,we kunnen de Geneste interface door het Buitenste Klasse of Buitenste interface naam gevolgd door een punt (.) , en Interface naam.

Laten we enkele voorbeelden proberen op basis van Interface nesten. Laten we eerst proberen een Java-interface binnen een ander Java-interface zoals hieronder weergegeven:

// Interfacecode

pakket Nest openbare interface OuterInterface {void display () interface InnerInterface {void InnerMethod ()}}

//Klassencode

pakket Nest class NestedInterfaceDemo implementeert OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('First' + n + 'terms:') voor (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 ')} public static void main (String args []) {OuterInterface.InnerInterface obj = nieuw NestedInterfaceDemo () obj.InnerMethod ()}}

Uitgang:

Eerste 10 termen: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + Afdrukken vanuit de geneste InnerInterface-methode ...!

Laten we nu proberen een Java-interface binnen een Java-klasse.

// Interfacecode

pakket Nest2 openbare klasse EdurekaClass {interface EdurekaInterface {void NestedMethod ()}}

//Klassencode

pakket Nest2 klasse NestedInterfaceDemo2 implementeert EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' byte [] strAsByteArray = input.getBytes () byte [] resultaat = nieuwe byte [strAsByteArray.length] voor (int iByteArray.length] voor (int iByteArray.length] .length i ++) resultaat [i] = strAsByteArray [strAsByteArray.length-i-1] System.out.println (nieuwe String (resultaat))} public static void main (String args []) {EdurekaClass.EdurekaInterface obj = nieuwe NestedInterfaceDemo2 () obj.NestedMethod ()}}

Uitgang:

akerudE

Hoewel een interface er bijna hetzelfde uitziet als een klasse, zijn er enkele verschillen tussen beide. Laten we hun verschillen bespreken.

Verschil tussen Java Class en Java-interface

Voordelen en nadelen van Java-interface

Voordelen:

• Java-interface ondersteunt Meerdere overerving.
• Java-interface stelt programmeurs in staat om de complexe programmeerbenaderingen te doorbreken en de afhankelijkheden tussen de objecten.
• Java-interface maakt het data leden en methoden in een applicatie die losjes moet worden gekoppeld.

Nadelen:

• Het gebruik van Java-interface verlaagt het uitvoeringssnelheid van de aanvraag.
• Java-interfaces in de applicatie worden ofwel herhaaldelijk in grote mate of nauwelijks gebruikt.

Belangrijkste punten op Java-interface

• Geen van de methoden die in de interface zijn gedeclareerd, heeft een body waardoor het volledige abstractie biedt.
• Het is niet mogelijk om een ​​object van een interface te maken. Daarom is het instantiëren van een interface niet mogelijk.
• Een Klasse kan een interface implementeren door het sleutelwoord implementaties te gebruiken. Laten we dit aan de hand van een voorbeeld bekijken.

// Interfacecode

pakket extInterface openbare interface extInterface {public void method1 () public void method2 ()}

//Klassencode

pakket extInterface import java.util.Scanner klasse Edureka implementeert extInterface {public void method1 () {System.out.println ('implementatie van methode1') Scanner scanner = nieuwe Scanner (System.in) System.out.println ('Nummer invoeren om vierkantswortel in Java te vinden: ') double square = scanner.nextDouble () double squareRoot = Math.sqrt (vierkant) System.out.printf (' Vierkantswortel van getal:% f is:% f% n ', vierkant, squareRoot)} public void method2 () {System.out.println ('implementatie van method2')} public static void main (String arg []) {extInterface obj = new Edureka () obj.method1 ()}}

Uitgang:

implementatie van methode1 Voer een getal in om de vierkantswortel in Java te vinden: 16 Vierkantswortel van nummer: 16.0 is: 4.0

• Een klasse kan meerdere overervingen in één instantie implementeren. Laten we het begrijpen door middel van de volgende code.

// Interface 1-code

pakket ExtendInt public interface Interface1 {public void armstrong ()}

// Interface 2-code

package ExtendInt public interface Interface2 {public void prime ()} // Klasse Code pakket ExtendInt public class Edureka2 implementeert 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 nummer') anders System.out.println ('Not armstrong number') 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 + 'is geen priemgetal')} else {for (i = 2i & lt = mi ++) {if (n% i == 0) {System .out.println (n + 'is geen priemgetal') flag = 1 break}} if (flag == 0) {System.out.println (n + 'is priemgetal')}} System.out.println ('Extending to Interface 2 ')} public static void main (String args []) {Interface2 obj = nieuw Edureka2 () obj.prime () Interface1 obj1 = nieuw Edureka2 () obj1.armstrong ()}}

Uitgang:

3 is priemgetal Uitbreiding naar interface 2 armstrong-nummer Uitbreiding naar interface 1

• Java-interface vereist dat de gedeclareerde variabelen worden geïnitialiseerd op het moment van declaratie.
• Toegangsmodificatoren voor een interface zijn standaard ingesteld op openbaar statisch en definitief. Laten we dit aan de hand van een voorbeeld begrijpen

// Interfacecode

pakkettest openbare interface Probeer {// public int a = 10 // public static final int a = 10 // static int a = 0 // final int a = 10 // int a = 10}

• Alle bovenstaande verklaringen zijn waar en geldig binnen een interface.
• Java-interface is in staat om een ​​willekeurig aantal interfaces uit te breiden, maar kan er nooit een implementeren.
• Een Java-klasse kan een willekeurig aantal interfaces implementeren.
• Java Class kan geen interfaces implementeren met dezelfde methodenaam en een ander retourtype.
• Als er twee of meer methoden zijn met dezelfde methode naam, bestaan ​​in meerdere interfaces, dan is het voldoende om de methode één keer te implementeren. Laten we dit begrijpen met een praktisch voorbeeld.

// Interfacecode

pakket zelfde publieke interface A {public void display ()} // Interface Code pakket zelfde publieke interface B {public void display ()} // Klasse Code pakket zelfde klasse zelfde implementeert A, B {public void display () {System.out .println ('displaying data')} public static void main (String [] args) {same print = new same () print.display ()}}

Uitgang:

Welkom bij Edureka E-Learning

Hiermee komen we aan het einde van dit artikel. Ik hoop dat je het belang hebt begrepen van interface, syntaxis, functionaliteit, interface-nesten, kernpunten van de Java-interface en bewerkingen die ermee worden uitgevoerd.

Nu u de basisprincipes van Java begrijpt, kunt u het door Edureka, een vertrouwd online leerbedrijf met een netwerk van meer dan 250.000 tevreden leerlingen verspreid over de hele wereld. De training- en certificeringcursus Java J2EE en SOA van Edureka is bedoeld voor studenten en professionals die Java-ontwikkelaar willen worden. De cursus is ontworpen om u een voorsprong te geven in het programmeren van Java en u te trainen in zowel kern- als geavanceerde Java-concepten, samen met verschillende Java-frameworks zoals Hibernate & De lente .

Heeft u een vraag voor ons? Vermeld het in het opmerkingengedeelte van deze 'Java Interface' -blog en we nemen zo snel mogelijk contact met u op.