TechCodeview

1. Gränssnitt
2. Exempel på gränssnitt
3. Multipelt arv genom gränssnitt
4. Varför multipelarv stöds i Interface medan det inte stöds i händelse av klass.
5. Markörgränssnitt
6. Kapslad gränssnitt

En gränssnitt i Java är en ritning av en klass. Den har statiska konstanter och abstrakta metoder.

Gränssnittet i Java är en mekanism att uppnå abstraktion . Det kan bara finnas abstrakta metoder i Java-gränssnittet, inte metodkroppen. Det används för att uppnå abstraktion och multipla arv i Java .

Med andra ord kan man säga att gränssnitt kan ha abstrakta metoder och variabler. Det kan inte ha en metodkropp.

Java-gränssnitt också representerar IS-A-relationen .

Det kan inte instansieras precis som den abstrakta klassen.

Sedan Java 8 kan vi ha standardmetoder och statiska metoder i ett gränssnitt.

java är lika med

Sedan Java 9 kan vi ha privata metoder i ett gränssnitt.

Varför använda Java-gränssnitt?

Det finns främst tre skäl att använda gränssnitt. De ges nedan.

• Det används för att uppnå abstraktion.
• Genom gränssnitt kan vi stödja funktionen för multipelt arv.
• Den kan användas för att uppnå lös koppling.

Hur deklarerar man ett gränssnitt?

Ett gränssnitt deklareras med hjälp av nyckelordet gränssnitt. Det ger total abstraktion; betyder att alla metoder i ett gränssnitt deklareras med den tomma kroppen, och alla fält är offentliga, statiska och slutgiltiga som standard. En klass som implementerar ett gränssnitt måste implementera alla metoder som deklareras i gränssnittet.

Syntax:

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

Java 8-gränssnittsförbättring

Eftersom Java 8 , kan gränssnittet ha standardmetoder och statiska metoder som diskuteras senare.

Internt tillägg av kompilatorn

Java-kompilatorn lägger till publika och abstrakta nyckelord före gränssnittsmetoden. Dessutom lägger den till offentliga, statiska och slutliga nyckelord före datamedlemmar.

Gränssnittsfält är med andra ord offentliga, statiska och slutgiltiga som standard, och metoderna är offentliga och abstrakta.

Relationen mellan klasser och gränssnitt

Som visas i figuren nedan utökar en klass en annan klass, ett gränssnitt utökar ett annat gränssnitt, men en klass implementerar ett gränssnitt .

Exempel på Java-gränssnitt

I det här exemplet har det utskrivbara gränssnittet bara en metod, och dess implementering tillhandahålls i klassen 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(); } } 

Produktion:

 Hello 

Exempel på Java-gränssnitt: Drawable

I det här exemplet har Drawable-gränssnittet bara en metod. Dess genomförande tillhandahålls av klasser rektangel och cirkel. I ett verkligt scenario definieras ett gränssnitt av någon annan, men dess implementering tillhandahålls av olika implementeringsleverantörer. Dessutom används den av någon annan. Implementeringsdelen döljs av användaren som använder gränssnittet.

Fil: TestInterface1.java

gjuta i sql

 //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(); }} 

Produktion:

linux felkoder

 drawing circle 

Java-gränssnitt Exempel: Bank

Låt oss se ett annat exempel på java-gränssnitt som tillhandahåller implementeringen av Bank-gränssnittet.

Fil: 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()); }} 

Produktion:

 ROI: 9.15 

Flera arv i Java genom gränssnitt

Om en klass implementerar flera gränssnitt, eller ett gränssnitt utökar flera gränssnitt, är det känt som multipelt arv.

 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 

F) Multipelarv stöds inte genom klass i java, men det är möjligt med ett gränssnitt, varför?

Som vi har förklarat i arvskapitlet stöds inte multipelt arv i fallet med klass på grund av oklarhet. Det stöds dock i händelse av ett gränssnitt eftersom det inte finns någon tvetydighet. Det beror på att dess implementering tillhandahålls av implementeringsklassen. Till exempel:

 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(); } } 

Produktion:

 Hello 

Som du kan se i exemplet ovan har utskrivbara och visningsbara gränssnitt samma metoder men dess implementering tillhandahålls av klassen TestTnterface1, så det finns ingen tvetydighet.

Gränssnittsarv

En klass implementerar ett gränssnitt, men ett gränssnitt utökar ett annat gränssnitt.

 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(); } } 

Produktion:

 Hello Welcome 

Java 8 standardmetod i gränssnitt

Sedan Java 8 kan vi ha metodkropp i gränssnittet. Men vi måste göra det till standardmetoden. Låt oss se ett exempel:

Fil: 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(); }} 

Produktion:

 drawing rectangle default method 

Java 8 statisk metod i gränssnitt

Sedan Java 8 kan vi ha statisk metod i gränssnittet. Låt oss se ett exempel:

Fil: TestInterfaceStatic.java

java hashset

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

Produktion:

 drawing rectangle 27 

F) Vad är markör eller taggat gränssnitt?

Ett gränssnitt som inte har någon medlem kallas en markör eller ett taggat gränssnitt, till exempel, Serialiserbar , Cloneable, Remote, etc. De används för att tillhandahålla viss viktig information till JVM så att JVM kan utföra någon användbar operation.

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

Kapslade gränssnitt i Java

Obs: Ett gränssnitt kan ha ett annat gränssnitt som är känt som ett kapslat gränssnitt. Vi kommer att lära oss det i detalj i kapslade klasser kapitel. Till exempel:

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