1. Koppel
2. Voorbeeld van interface
3. Meerdere overerving per interface
4. Waarom meervoudige overerving wordt ondersteund in Interface, terwijl dit niet wordt ondersteund in het geval van klasse.
5. Markerinterface
6. Geneste interface

Een interface in Java is een blauwdruk van een klasse. Het heeft statische constanten en abstracte methoden.

De interface in Java is een mechanisme om te bereiken abstractie . Er kunnen alleen abstracte methoden in de Java-interface voorkomen, geen methodebody. Het wordt gebruikt om abstractie en veelvoud te bereiken erfenis op Java .

vlc om youtube te downloaden

Met andere woorden, je kunt zeggen dat interfaces abstracte methoden en variabelen kunnen hebben. Het kan geen method body hebben.

Java-interface ook vertegenwoordigt de IS-A-relatie .

Het kan niet worden geïnstantieerd, net als de abstracte klasse.

Sinds Java 8 kunnen we dat hebben standaard en statische methoden in een interface.

Sinds Java 9 kunnen we dat hebben privé methoden in een interface.

Waarom een ​​Java-interface gebruiken?

Er zijn hoofdzakelijk drie redenen om de interface te gebruiken. Ze worden hieronder gegeven.

• Het wordt gebruikt om abstractie te bereiken.
• Via interface kunnen we de functionaliteit van meervoudige overerving ondersteunen.
• Het kan worden gebruikt om losse koppeling te bereiken.

Hoe een interface declareren?

Een interface wordt gedeclareerd met behulp van het interface-trefwoord. Het biedt totale abstractie; betekent dat alle methoden in een interface worden gedeclareerd met de lege hoofdtekst, en dat alle velden standaard openbaar, statisch en definitief zijn. Een klasse die een interface implementeert, moet alle methoden implementeren die in de interface zijn gedeclareerd.

Syntaxis:

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

Java 8-interfaceverbetering

Sinds Java 8 , kan de interface standaard- en statische methoden hebben, die later worden besproken.

Interne toevoeging door de compiler

De Java-compiler voegt openbare en abstracte trefwoorden toe vóór de interfacemethode. Bovendien worden openbare, statische en definitieve trefwoorden toegevoegd vóór de gegevensleden.

Met andere woorden: interfacevelden zijn standaard openbaar, statisch en definitief, en de methoden zijn openbaar en abstract.

De relatie tussen klassen en interfaces

Zoals weergegeven in de onderstaande afbeelding, breidt een klasse een andere klasse uit, een interface breidt een andere interface uit, maar a klasse implementeert een interface .

css-lijsten

Voorbeeld van een Java-interface

In dit voorbeeld heeft de Printable-interface slechts één methode en wordt de implementatie ervan geleverd in de klasse A6.

 interface printable{ void print(); } class A6 implements printable{ public void print(){System.out.println('Hello');} public static void main(String args[]){ A6 obj = new A6(); obj.print(); } } 

Uitgang:

 Hello 

Voorbeeld van Java-interface: tekenbaar

In dit voorbeeld heeft de Drawable-interface slechts één methode. De implementatie ervan wordt verzorgd door de klassen Rectangle en Circle. In een reëel scenario wordt een interface door iemand anders gedefinieerd, maar wordt de implementatie ervan verzorgd door verschillende implementatieproviders. Bovendien wordt het door iemand anders gebruikt. Het implementatiegedeelte wordt verborgen voor de gebruiker die de interface gebruikt.

Bestand: TestInterface1.java

 //Interface declaration: by first user interface Drawable{ void draw(); } //Implementation: by second user class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class Circle implements Drawable{ public void draw(){System.out.println('drawing circle');} } //Using interface: by third user class TestInterface1{ public static void main(String args[]){ Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable() d.draw(); }} 

Uitgang:

 drawing circle 

Java-interface Voorbeeld: Bank

Laten we nog een voorbeeld bekijken van een Java-interface die de implementatie van de Bank-interface biedt.

Bestand: TestInterface2.java

 interface Bank{ float rateOfInterest(); } class SBI implements Bank{ public float rateOfInterest(){return 9.15f;} } class PNB implements Bank{ public float rateOfInterest(){return 9.7f;} } class TestInterface2{ public static void main(String[] args){ Bank b=new SBI(); System.out.println('ROI: '+b.rateOfInterest()); }} 

Uitgang:

 ROI: 9.15 

Meerdere overerving in Java per interface

Als een klasse meerdere interfaces implementeert, of een interface meerdere interfaces uitbreidt, staat dit bekend als meervoudige overerving.

object tegen json in Java

 interface Printable{ void print(); } interface Showable{ void show(); } class A7 implements Printable,Showable{ public void print(){System.out.println('Hello');} public void show(){System.out.println('Welcome');} public static void main(String args[]){ A7 obj = new A7(); obj.print(); obj.show(); } } 

 Output:Hello Welcome 

V) Meervoudige overerving wordt niet ondersteund via klasse in Java, maar is wel mogelijk via een interface. Waarom?

Zoals we in het hoofdstuk overerving hebben uitgelegd, wordt meervoudige overerving niet ondersteund in het geval van klas vanwege onduidelijkheid. Het wordt echter ondersteund in het geval van een interface, omdat er geen dubbelzinnigheid bestaat. Dit komt omdat de implementatie ervan wordt verzorgd door de implementatieklasse. Bijvoorbeeld:

 interface Printable{ void print(); } interface Showable{ void print(); } class TestInterface3 implements Printable, Showable{ public void print(){System.out.println('Hello');} public static void main(String args[]){ TestInterface3 obj = new TestInterface3(); obj.print(); } } 

Uitgang:

 Hello 

Zoals je in het bovenstaande voorbeeld kunt zien, hebben de Printable en Showable interface dezelfde methoden, maar de implementatie ervan wordt verzorgd door de klasse TestTnterface1, dus er is geen dubbelzinnigheid.

Interface-overerving

Een klasse implementeert een interface, maar de ene interface breidt een andere interface uit.

 interface Printable{ void print(); } interface Showable extends Printable{ void show(); } class TestInterface4 implements Showable{ public void print(){System.out.println('Hello');} public void show(){System.out.println('Welcome');} public static void main(String args[]){ TestInterface4 obj = new TestInterface4(); obj.print(); obj.show(); } } 

Uitgang:

 Hello Welcome 

Java 8 Standaardmethode in interface

Sinds Java 8 kunnen we de body van de methode in de interface hebben. Maar we moeten er een standaardmethode van maken. Laten we een voorbeeld bekijken:

Bestand: TestInterfaceDefault.java

 interface Drawable{ void draw(); default void msg(){System.out.println('default method');} } class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class TestInterfaceDefault{ public static void main(String args[]){ Drawable d=new Rectangle(); d.draw(); d.msg(); }} 

Uitgang:

 drawing rectangle default method 

Java 8 Statische methode in interface

Sinds Java 8 kunnen we een statische methode in de interface hebben. Laten we een voorbeeld bekijken:

Bestand: TestInterfaceStatic.java

d flip-flop

 interface Drawable{ void draw(); static int cube(int x){return x*x*x;} } class Rectangle implements Drawable{ public void draw(){System.out.println('drawing rectangle');} } class TestInterfaceStatic{ public static void main(String args[]){ Drawable d=new Rectangle(); d.draw(); System.out.println(Drawable.cube(3)); }} 

Uitgang:

 drawing rectangle 27 

V) Wat is een marker- of getagde interface?

Een interface die geen lid heeft, staat bekend als een marker of getagde interface, bijvoorbeeld Serialiseerbaar , Cloneable, Remote, enz. Ze worden gebruikt om essentiële informatie aan de JVM te verstrekken, zodat JVM een nuttige bewerking kan uitvoeren.

 //How Serializable interface is written? public interface Serializable{ } 

Geneste interface in Java

Opmerking: Een interface kan een andere interface hebben die bekend staat als een geneste interface. We zullen het in detail leren in de geneste klassen hoofdstuk. Bijvoorbeeld:

 interface printable{ void print(); interface MessagePrintable{ void msg(); } }