TechCodeview

1. Interface
2. Eksempel på grænseflade
3. Multipel arv ved grænseflade
4. Hvorfor multipel nedarvning er understøttet i Interface, mens det ikke understøttes i tilfælde af klasse.
5. Markør grænseflade
6. Indlejret grænseflade

An grænseflade i Java er en plan for en klasse. Det har statiske konstanter og abstrakte metoder.

Grænsefladen i Java er en mekanisme at opnå abstraktion . Der kan kun være abstrakte metoder i Java-grænsefladen, ikke metodetekst. Det bruges til at opnå abstraktion og multiple arv i Java .

Med andre ord kan man sige, at grænseflader kan have abstrakte metoder og variabler. Det kan ikke have et metodelegeme.

Java Interface også repræsenterer IS-A-forholdet .

Det kan ikke instansieres ligesom den abstrakte klasse.

Siden Java 8, kan vi have standard og statiske metoder i en grænseflade.

Siden Java 9 kan vi have private metoder i en grænseflade.

Hvorfor bruge Java-grænseflade?

Der er hovedsageligt tre grunde til at bruge interface. De er angivet nedenfor.

strengmetoder i java

• Det bruges til at opnå abstraktion.
• Ved interface kan vi understøtte funktionaliteten af ​​multipel arv.
• Det kan bruges til at opnå løs kobling.

Hvordan erklærer man en grænseflade?

En grænseflade erklæres ved at bruge grænsefladenøgleordet. Det giver total abstraktion; betyder, at alle metoderne i en grænseflade er deklareret med den tomme krop, og alle felterne er offentlige, statiske og endelige som standard. En klasse, der implementerer en grænseflade, skal implementere alle de metoder, der er erklæret i grænsefladen.

Syntaks:

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

Java 8 Interface forbedring

Siden Java 8 , interface kan have standard og statiske metoder, som diskuteres senere.

Intern tilføjelse af compileren

Java-kompileren tilføjer offentlige og abstrakte nøgleord før grænseflademetoden. Desuden tilføjer den offentlige, statiske og endelige søgeord før datamedlemmer.

Med andre ord er grænsefladefelter som standard offentlige, statiske og endelige, og metoderne er offentlige og abstrakte.

Forholdet mellem klasser og grænseflader

Som vist i figuren nedenfor, udvider en klasse en anden klasse, en grænseflade udvider en anden grænseflade, men en klasse implementerer en grænseflade .

Eksempel på Java-grænseflade

I dette eksempel har den udskrivbare grænseflade kun én metode, og dens implementering findes 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(); } } 

Produktion:

 Hello 

Eksempel på Java-grænseflade: Drawable

I dette eksempel har Drawable-grænsefladen kun én metode. Dens implementering leveres af rektangel- og cirkelklasser. I et virkeligt scenarie er en grænseflade defineret af en anden, men dens implementering leveres af forskellige implementeringsudbydere. Desuden bruges den af ​​en anden. Implementeringsdelen er skjult af brugeren, der bruger grænsefladen.

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

Produktion:

 drawing circle 

Java Interface Eksempel: Bank

Lad os se et andet eksempel på java-grænseflade, som giver implementering af Bank-grænseflade.

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 

Multipel arv i Java ved interface

Hvis en klasse implementerer flere grænseflader, eller en grænseflade udvider flere grænseflader, er det kendt som multiple inheritance.

 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) Multipel nedarvning er ikke understøttet gennem klasse i java, men det er muligt ved en grænseflade, hvorfor?

Som vi har forklaret i arvskapitlet, understøttes multipel nedarvning ikke i tilfælde af klasse på grund af uklarhed. Det understøttes dog i tilfælde af en grænseflade, fordi der ikke er nogen tvetydighed. Det er fordi dens implementering leveres af implementeringsklassen. For eksempel:

centrale java-interviewspørgsmå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(); } } 

Produktion:

 Hello 

Som du kan se i ovenstående eksempel, har Printable og Showable interface de samme metoder, men dens implementering leveres af klassen TestTnterface1, så der er ingen tvetydighed.

Interface arv

En klasse implementerer en grænseflade, men en grænseflade udvider en anden grænseflade.

 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 standardmetode i grænseflade

Siden Java 8 kan vi have metodetekst i grænsefladen. Men vi er nødt til at gøre det til standardmetoden. Lad os 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(); }} 

Produktion:

 drawing rectangle default method 

Java 8 statisk metode i grænseflade

Siden Java 8 kan vi have statisk metode i grænsefladen. Lad os 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)); }} 

Produktion:

 drawing rectangle 27 

Q) Hvad er markør eller tagget grænseflade?

En grænseflade, som ikke har noget medlem, er kendt som en markør eller tagget grænseflade, f.eks. Serialiserbar , Klonbar, Remote osv. De bruges til at give nogle væsentlige oplysninger til JVM'en, så JVM kan udføre en nyttig handling.

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

Indlejret grænseflade i Java

Bemærk: En grænseflade kan have en anden grænseflade, der er kendt som en indlejret grænseflade. Vi vil lære det i detaljer i indlejrede klasser kapitel. For eksempel:

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