In deze tutorial leren we over Java-interfaces. Aan de hand van voorbeelden zullen we leren hoe u interfaces implementeert en wanneer u ze in detail gebruikt.
Een interface is een volledig abstracte klasse die een groep methoden zonder body bevat.
In Java definieert een interface een set specificaties die andere klassen moeten implementeren. Bijvoorbeeld,
interface Language ( public void getName(); )
Hier hebben we het interfacetrefwoord gebruikt om een interface met de naam Language te maken. De taalinterface definieert een specificatie getName().
Nu zou elke klasse die deze interface gebruikt, de getName()specificatie moeten implementeren .
Voorbeeld: Java-interface
// create an interface interface Language ( void getName(String name); ) // class implements interface class ProgrammingLanguage implements Language ( // implementation of abstract method public void getName(String name) ( System.out.println("Programming Language: " + name); ) ) class Main ( public static void main(String() args) ( ProgrammingLanguage language = new ProgrammingLanguage(); language.getName("Java"); ) )
Uitvoer
Programmeertaal: Java
In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam Language. De interface bevat een abstracte methode getName().
Hier implementeert de klasse ProgrammingLanguage de interface en zorgt voor de implementatie voor de methode.
Het is niet verplicht om een abstracttrefwoord te gebruiken bij het declareren van abstracte methoden binnen een interface. Het is omdat een interface alleen abstracte methoden bevat en geen reguliere methoden.
Opmerking : alle methoden in een interface zijn impliciet publicen alle velden zijn impliciet public static final. Bijvoorbeeld,
interface Language ( // by default public static final String type = "programming language"; // by default public void getName(); )
Een interface implementeren
Net als abstracte klassen kunnen we geen objecten van een interface maken. We kunnen echter een interface implementeren.
We gebruiken het implementstrefwoord om een interface te implementeren. Bijvoorbeeld,
// create an interface interface Polygon ( void getArea(int length, int breadth); ) // implement the Polygon interface class Rectangle implements Polygon ( // implementation of abstract method public void getArea(int length, int breadth) ( System.out.println("The area of the rectangle is " + (length * breadth)); ) ) class Main ( public static void main(String() args) ( // create an object Rectangle r1 = new Rectangle(); r1.getArea(5, 6); ) )
Uitvoer
De oppervlakte van de rechthoek is 30
In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam Polygon. De interface bevat een abstracte methode getArea().
Hier implementeert de klasse Rectangle Polygon. En zorgt voor de implementatie van de getArea()methode.
Opmerking : een klasse kan meerdere interfaces implementeren. Bijvoorbeeld,
interface A ( // members of A ) interface B ( // members of B ) class C implements A, B ( // abstract members of A // abstract members of B )
Een interface uitbreiden
Net als bij klassen, kunnen interfaces andere interfaces uitbreiden. Het extendssleutelwoord wordt gebruikt om interfaces uit te breiden. Bijvoorbeeld,
interface Line ( // members of Line interface ) // extending interface interface Polygon extends Line ( // members of Polygon interface // members of Line interface )
Hier breidt de Polygon-interface de Line-interface uit. Als een klasse Polygon implementeert, zou het implementaties moeten bieden voor alle abstracte methoden van zowel Line als Polygon.
Opmerking : een interface kan meerdere interfaces uitbreiden. Bijvoorbeeld,
interface A (… ) interface B (… ) interface C extends A, B (… )
Voordelen van interface in Java
Nu we weten wat interfaces zijn, gaan we kijken waarom interfaces in Java worden gebruikt.
- Interfaces bieden specificaties die een klasse (die deze implementeert) moet volgen.
In ons vorige voorbeeld hebben wegetArea()als specificatie binnen de interface Polygon gebruikt. Dit is hetzelfde als het instellen van een regel dat we in staat zouden moeten zijn om de oppervlakte van elke polygoon te krijgen.
Nu moet elke klasse die de Polygon-interface implementeert, een implementatie voor degetArea()methode bieden. - Net als bij abstracte klassen, helpen interfaces ons om abstractie te bereiken in Java .
Hier weten we datgetArea()de oppervlakte van polygonen wordt berekend, maar de manier waarop de oppervlakte wordt berekend, verschilt voor verschillende polygonen. Daarom is de implementatie vangetArea()onafhankelijk van elkaar. - Interfaces worden ook gebruikt om meervoudige overerving in Java te bereiken. Bijvoorbeeld,
interface Line (… ) interface Polygon (… ) class Rectangle implements Line, Polygon (… )
Hier implementeert de klasse Rectangle twee verschillende interfaces. Dit is hoe we meervoudige overerving in Java bereiken.
standaardmethoden in Java-interfaces
Met de release van Java 8 kunnen we nu methoden toevoegen met implementatie in een interface. Deze methoden worden standaardmethoden genoemd.
Om standaardmethoden binnen interfaces te declareren, gebruiken we het defaulttrefwoord. Bijvoorbeeld,
public default void getSides() ( // body of getSides() )
Waarom standaardmethoden?
Laten we een scenario nemen om te begrijpen waarom standaardmethoden in Java worden geïntroduceerd.
Stel dat we een nieuwe methode in een interface moeten toevoegen.
We kunnen de methode eenvoudig in onze interface toevoegen zonder implementatie. Dat is echter niet het einde van het verhaal. Al onze klassen die die interface implementeren, moeten een implementatie voor de methode bieden.
Als een groot aantal klassen deze interface implementeerde, moeten we al deze klassen volgen en er wijzigingen in aanbrengen. Dit is niet alleen vervelend maar ook foutgevoelig.
Om dit op te lossen heeft Java standaardmethoden geïntroduceerd. Standaardmethoden worden overgeërfd zoals gewone methoden.
Laten we een voorbeeld nemen om een beter begrip te krijgen van standaardmethoden.
Voorbeeld: standaardmethode in Java-interface
interface Polygon ( void getArea(); // default method default void getSides() ( System.out.println("I can get sides of a polygon."); ) ) // implements the interface class Rectangle implements Polygon ( public void getArea() ( int length = 6; int breadth = 5; int area = length * breadth; System.out.println("The area of the rectangle is " + area); ) // overrides the getSides() public void getSides() ( System.out.println("I have 4 sides."); ) ) // implements the interface class Square implements Polygon ( public void getArea() ( int length = 5; int area = length * length; System.out.println("The area of the square is " + area); ) ) class Main ( public static void main(String() args) ( // create an object of Rectangle Rectangle r1 = new Rectangle(); r1.getArea(); r1.getSides(); // create an object of Square Square s1 = new Square(); s1.getArea(); s1.getSides(); ) )
Uitvoer
De oppervlakte van de rechthoek is 30. Ik heb 4 zijden. De oppervlakte van het vierkant is 25. Ik kan zijden van een veelhoek krijgen.
In the above example, we have created an interface named Polygon. It has a default method getSides() and an abstract method getArea().
Here, we have created two classes Rectangle and Square that implement Polygon.
The Rectangle class provides the implementation of the getArea() method and overrides the getSides() method. However, the Square class only provides the implementation of the getArea() method.
Now, while calling the getSides() method using the Rectangle object, the overridden method is called. However, in the case of the Square object, the default method is called.
private and static Methods in Interface
The Java 8 also added another feature to include static methods inside an interface.
Similar to a class, we can access static methods of an interface using its references. For example,
// create an interface interface Polygon ( staticMethod()(… ) ) // access static method Polygon.staticMethod();
Note: With the release of Java 9, private methods are also supported in interfaces.
We cannot create objects of an interface. Hence, private methods are used as helper methods that provide support to other methods in interfaces.
Practical Example of Interface
Let's see a more practical example of Java Interface.
// To use the sqrt function import java.lang.Math; interface Polygon ( void getArea(); // calculate the perimeter of a Polygon default void getPerimeter(int… sides) ( int perimeter = 0; for (int side: sides) ( perimeter += side; ) System.out.println("Perimeter: " + perimeter); ) ) class Triangle implements Polygon ( private int a, b, c; private double s, area; // initializing sides of a triangle Triangle(int a, int b, int c) ( this.a = a; this.b = b; this.c = c; s = 0; ) // calculate the area of a triangle public void getArea() ( s = (double) (a + b + c)/2; area = Math.sqrt(s*(s-a)*(s-b)*(s-c)); System.out.println("Area: " + area); ) ) class Main ( public static void main(String() args) ( Triangle t1 = new Triangle(2, 3, 4); // calls the method of the Triangle class t1.getArea(); // calls the method of Polygon t1.getPerimeter(2, 3, 4); ) )
Output
Area: 2.9047375096555625 Perimeter: 9
In the above program, we have created an interface named Polygon. It includes a default method getPerimeter() and an abstract method getArea().
We can calculate the perimeter of all polygons in the same manner so we implemented the body of getPerimeter() in Polygon.
Now, all polygons that implement Polygon can use getPerimeter() to calculate perimeter.
De regel voor het berekenen van de oppervlakte is echter verschillend voor verschillende polygonen. Daarom getArea()is inbegrepen zonder implementatie.
Elke klasse die Polygon implementeert, moet een implementatie van getArea().
