TechCodeview

1. Grensesnitt
2. Eksempel på grensesnitt
3. Multippel arv etter grensesnitt
4. Hvorfor multippel arv støttes i grensesnitt mens det ikke støttes i tilfelle klasse.
5. Markørgrensesnitt
6. Nestet grensesnitt

An grensesnitt i Java er en blåkopi av en klasse. Den har statiske konstanter og abstrakte metoder.

Grensesnittet i Java er en mekanisme å oppnå abstraksjon . Det kan bare være abstrakte metoder i Java-grensesnittet, ikke metodekroppen. Det brukes til å oppnå abstraksjon og multiple arv i Java .

Med andre ord kan du si at grensesnitt kan ha abstrakte metoder og variabler. Den kan ikke ha en metodekropp.

Java-grensesnitt også representerer IS-A-forholdet .

Det kan ikke instansieres akkurat som den abstrakte klassen.

Siden Java 8 kan vi ha standard og statiske metoder i et grensesnitt.

Siden Java 9 kan vi ha private metoder i et grensesnitt.

Hvorfor bruke Java-grensesnitt?

Det er hovedsakelig tre grunner til å bruke grensesnitt. De er gitt nedenfor.

strengmetoder i java

• Det brukes til å oppnå abstraksjon.
• Ved grensesnitt kan vi støtte funksjonaliteten til multippel arv.
• Den kan brukes for å oppnå løs kobling.

Hvordan erklære et grensesnitt?

Et grensesnitt er deklarert ved å bruke grensesnittnøkkelordet. Det gir total abstraksjon; betyr at alle metodene i et grensesnitt er deklarert med den tomme kroppen, og alle feltene er offentlige, statiske og endelige som standard. En klasse som implementerer et grensesnitt må implementere alle metodene som er deklarert i grensesnittet.

Syntaks:

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

Java 8 grensesnittforbedring

Siden Java 8 , kan grensesnittet ha standard og statiske metoder som diskuteres senere.

Intern tillegg av kompilatoren

Java-kompilatoren legger til offentlige og abstrakte nøkkelord før grensesnittmetoden. Dessuten legger den til offentlige, statiske og endelige nøkkelord før datamedlemmer.

Med andre ord er grensesnittfelt som standard offentlige, statiske og endelige, og metodene er offentlige og abstrakte.

Forholdet mellom klasser og grensesnitt

Som vist i figuren nedenfor, utvider en klasse en annen klasse, et grensesnitt utvider et annet grensesnitt, men en klasse implementerer et grensesnitt .

Eksempel på Java-grensesnitt

I dette eksemplet har det utskrivbare grensesnittet bare én metode, og implementeringen er gitt i A6-klassen.

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

Produksjon:

 Hello 

Eksempel på Java-grensesnitt: Drawable

I dette eksemplet har Drawable-grensesnittet bare én metode. Implementeringen leveres av rektangel- og sirkelklasser. I et reelt scenario er et grensesnitt definert av noen andre, men implementeringen leveres av forskjellige implementeringsleverandører. Dessuten brukes den av noen andre. Implementeringsdelen skjules av brukeren som bruker grensesnittet.

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

Produksjon:

 drawing circle 

Java-grensesnitt Eksempel: Bank

La oss se et annet eksempel på java-grensesnitt som gir implementering av Bank-grensesnitt.

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

Produksjon:

 ROI: 9.15 

Multippel arv i Java etter grensesnitt

Hvis en klasse implementerer flere grensesnitt, eller et grensesnitt utvider flere grensesnitt, er det kjent som multippel 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 

Q) Multippel arv støttes ikke gjennom klasse i java, men det er mulig med et grensesnitt, hvorfor?

Som vi har forklart i arvskapitlet, støttes ikke multippel arv i tilfelle av klasse på grunn av tvetydighet. Imidlertid støttes det i tilfelle et grensesnitt fordi det ikke er noen tvetydighet. Det er fordi implementeringen leveres av implementeringsklassen. For eksempel:

kjerne java intervju spørsmål

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

Produksjon:

 Hello 

Som du kan se i eksemplet ovenfor, har Utskrivbare og Visbare grensesnitt de samme metodene, men implementeringen leveres av klassen TestTnterface1, så det er ingen tvetydighet.

Interface arv

En klasse implementerer et grensesnitt, men ett grensesnitt utvider et annet grensesnitt.

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

Produksjon:

 Hello Welcome 

Java 8 standardmetode i grensesnitt

Siden Java 8 kan vi ha metodekropp i grensesnittet. Men vi må gjøre den til standardmetoden. La oss se et eksempel:

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

Produksjon:

 drawing rectangle default method 

Java 8 statisk metode i grensesnitt

Siden Java 8 kan vi ha statisk metode i grensesnittet. La oss se et eksempel:

Fil: TestInterfaceStatic.java

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

Produksjon:

 drawing rectangle 27 

Sp) Hva er markør eller tagget grensesnitt?

Et grensesnitt som ikke har noe medlem er kjent som en markør eller merket grensesnitt, for eksempel, Serialiserbar , Klonbar, Remote, etc. De brukes til å gi noe viktig informasjon til JVM slik at JVM kan utføre noen nyttige operasjoner.

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

Nestet grensesnitt i Java

Merk: Et grensesnitt kan ha et annet grensesnitt som er kjent som et nestet grensesnitt. Vi vil lære det i detalj i nestede klasser kapittel. For eksempel:

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