Interface in Java

Interface in Java is een van de kernconcepten. Java Interface is een essentieel onderdeel van de Java-programmeertaal en wordt veel gebruikt, niet alleen in JDK maar ook in Java-ontwerppatronen. De meeste frameworks maken uitgebreid gebruik van Java-interface.

Interface in Java

Interface in Java biedt een manier om abstractie te bereiken. Java-interface wordt ook gebruikt om het contract te definiëren dat de subklassen moeten implementeren. Bijvoorbeeld, stel dat we een tekening willen maken bestaande uit meerdere vormen. Hier kunnen we een interface Shape maken en alle methoden definiëren die verschillende soorten vormobjecten zullen implementeren. Voor eenvoud kunnen we slechts twee methoden behouden – draw() om de vorm te tekenen en getArea() die het gebied van de vorm retourneert.

Voorbeeld van Java Interface

Op basis van bovenstaande vereisten zal onze Shape-interface er als volgt uitzien. Shape.java

package com.journaldev.design;

public interface Shape {

	//impliciet openbaar, statisch en definitief
	public String LABLE="Shape";
	
	//interfacemethoden zijn impliciet abstract en openbaar
	void draw();
	
	double getArea();
}

Belangrijke punten over Interface in Java

1. interface is de code die wordt gebruikt om een interface in Java te creëren.

2. We kunnen geen instantie maken van een interface in Java.

3. Interface biedt absolute abstractie, in de laatste post hebben we geleerd over abstracte klassen in Java om abstractie te bieden, maar abstracte klassen kunnen methodenimplementaties hebben, terwijl een interface dat niet kan.

4. Interfaces kunnen geen constructeurs hebben omdat we ze niet kunnen instantiëren, en interfaces kunnen geen methoden met een lichaam hebben.

5. Standaard is elk attribuut van een interface publiek, statisch en definitief, dus we hoeven geen toegangsmodificatoren voor de attributen op te geven, maar als we dat doen, klaagt de compiler er ook niet over.

6. Standaard zijn interfacemethoden impliciet abstract en publiek, het is logisch omdat de methode geen lichaam heeft en zodat subklassen de methodimplementatie kunnen leveren.

7. Een interface kan geen klasse uitbreiden, maar het kan een andere interface uitbreiden. public interface Vorm extends Cloneable{} is een voorbeeld van een interface die een andere interface uitbreidt. Eigenlijk biedt Java meervoudige overerving in interfaces, wat betekent dat een interface meerdere interfaces kan uitbreiden.

8. implements sleutelwoord wordt gebruikt door klassen om een interface te implementeren.

9. Een klasse die een interface implementeert, moet implementaties bieden voor al haar methoden, tenzij het een abstracte klasse is. Bijvoorbeeld, we kunnen de bovenstaande interface implementeren in een abstracte klasse zoals dit: ShapeAbs.java

   package com.journaldev.design;
   
   public abstract class ShapeAbs implements Shape {
   
   	@Override
   	public double getArea() {
   		// TODO Auto-generated method stub
   		return 0;
   	}
   
   }
   

10. We moeten altijd proberen programma’s te schrijven in termen van interfaces in plaats van implementaties, zodat we van tevoren weten dat implementatieklassen altijd de implementatie zullen bieden en in de toekomst, als er een betere implementatie komt, we gemakkelijk kunnen overschakelen.

Java Interface-implementatievoorbeeld

Latens eens kijken naar een aantal implementaties van onze Shape-interface in java. Circle.java

package com.journaldev.design;

public class Circle implements Shape {

	private double radius;

	public Circle(double r){
		this.radius = r;
	}
	
	@Override
	public void draw() {
		System.out.println("Drawing Circle");
	}
	
	@Override
	public double getArea(){
		return Math.PI*this.radius*this.radius;
	}

	public double getRadius(){
		return this.radius;
	}
}

Merk op dat de Circle-klasse alle methoden heeft geïmplementeerd die gedefinieerd zijn in de interface, en het heeft ook enkele eigen methoden zoals getRadius(). De interface-implementaties kunnen meerdere soorten constructors hebben. Laten we nog een andere interface-implementatie voor de Shape-interface bekijken. Rectangle.java

package com.journaldev.design;

public class Rectangle implements Shape {

	private double width;
	private double height;
	
	public Rectangle(double w, double h){
		this.width=w;
		this.height=h;
	}
	@Override
	public void draw() {
		System.out.println("Drawing Rectangle");
	}

	@Override
	public double getArea() {
		return this.height*this.width;
	}

}

Let op het gebruik van de override-annotatie, leer over annotaties in Java en waarom we altijd de override-annotatie moeten gebruiken bij het overschrijven van een methode in Java. Hier is een testprogramma dat laat zien hoe te coderen in termen van interfaces en niet van implementaties. ShapeTest.java

package com.journaldev.design;

public class ShapeTest {

	public static void main(String[] args) {
		
		// programmeren voor interfaces en niet voor implementaties
		Shape shape = new Circle(10);
		
		shape.draw();
		System.out.println("Area="+shape.getArea());
		
		// eenvoudig overschakelen van de ene implementatie naar de andere
		shape=new Rectangle(10,10);
		shape.draw();
		System.out.println("Area="+shape.getArea());
		}

}

De uitvoer van het bovenstaande Java-interfacevoorbeeldprogramma is:

Drawing Circle
Area=314.1592653589793
Drawing Rectangle
Area=100.0

Voordelen van Java-interface

1. Interface biedt een contract voor alle implementatieklassen, dus het is goed om te coderen in termen van interfaces omdat implementatieklassen de methoden die we gebruiken niet kunnen verwijderen.
2. Interfaces zijn goed als startpunt om een Type te definiëren en een hiërarchie op hoog niveau te creëren in onze code.
3. Aangezien een Java-klasse meerdere interfaces kan implementeren, is het in de meeste gevallen beter om interfaces als superklasse te gebruiken.

Nadelen van Java-interface

Hoewel interfaces veel voordelen bieden, hebben ze ook enkele nadelen.

1. We moeten interface-methoden zeer zorgvuldig kiezen bij het ontwerpen van ons project, omdat we geen methoden aan de interface kunnen toevoegen of verwijderen op een later tijdstip, dit zal leiden tot compilatiefouten voor alle implementatieklassen. Soms leidt dit ertoe dat we veel interfaces hebben die de basisklasse uitbreiden in onze code, wat moeilijk te onderhouden wordt.

2. Als de implementatieklassen hun eigen methoden hebben, kunnen we ze niet direct in onze code gebruiken omdat het type Object een interface is die deze methoden niet heeft. Bijvoorbeeld, in de bovenstaande code krijgen we een compilatiefout voor de code shape.getRadius(). Om dit te overwinnen, kunnen we typecasting gebruiken en de methode als volgt gebruiken:

   Circle c = (Circle) shape;
   c.getRadius();
   

   Hoewel class typecasting zijn eigen nadelen heeft.

Dat is alles wat ik heb over interfaces in Java. Aangezien we vaak gebruikmaken van Java-interfaces, moeten we op de hoogte zijn van hun kenmerken. Zorg ervoor dat je interfaces gebruikt bij het ontwerpen van het systeem en als een contract tussen de client en de subklassen die de interfaces implementeren. Update: Java 8 heeft de definitie van interfaces gewijzigd met de introductie van standaardmethoden en statische methoden-implementatie. Voor meer details, lees alsjeblieft Java 8-interface.