I den här handledningen lär vi oss om Java-gränssnitt. Vi lär oss hur man implementerar gränssnitt och när man använder dem i detalj med hjälp av exempel.
Ett gränssnitt är en helt abstrakt klass som innehåller en grupp metoder utan kropp.
I Java definierar ett gränssnitt en uppsättning specifikationer som andra klasser måste implementera. Till exempel,
interface Language ( public void getName(); )
Här har vi använt interfacenyckelordet för att skapa ett gränssnitt med namnet Språk. Språkgränssnittet definierar en specifikation getName().
Nu ska varje klass som använder detta gränssnitt implementera getName()specifikationen.
Exempel: Java-gränssnitt
// 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"); ) )
Produktion
Programmeringsspråk: Java
I exemplet ovan har vi skapat ett gränssnitt med namnet Språk. Gränssnittet innehåller en abstrakt metod getName().
Här implementerar klassen ProgrammingLanguage gränssnittet och tillhandahåller implementeringen av metoden.
Det är inte obligatoriskt att använda abstractnyckelord när man förklarar abstrakta metoder i ett gränssnitt. Det beror på att ett gränssnitt endast innehåller abstrakta metoder inte vanliga metoder.
Obs! Alla metoder i ett gränssnitt är implicit publicoch alla fält är implicit public static final. Till exempel,
interface Language ( // by default public static final String type = "programming language"; // by default public void getName(); )
Implementering av ett gränssnitt
Som abstrakta klasser kan vi inte skapa objekt i ett gränssnitt. Vi kan dock implementera ett gränssnitt.
Vi använder implementsnyckelordet för att implementera ett gränssnitt. Till exempel,
// 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); ) )
Produktion
Rektangelns yta är 30
I exemplet ovan har vi skapat ett gränssnitt som heter Polygon. Gränssnittet innehåller en abstrakt metod getArea().
Här implementerar rektangelklassen Polygon. Och ger implementeringen av getArea()metoden.
Obs! En klass kan implementera flera gränssnitt. Till exempel,
interface A ( // members of A ) interface B ( // members of B ) class C implements A, B ( // abstract members of A // abstract members of B )
Utöka ett gränssnitt
I likhet med klasser kan gränssnitt utöka andra gränssnitt. Den extendsnyckelord används för att utvidga gränssnitt. Till exempel,
interface Line ( // members of Line interface ) // extending interface interface Polygon extends Line ( // members of Polygon interface // members of Line interface )
Här utökar Polygon-gränssnittet Line-gränssnittet. Nu, om någon klass implementerar Polygon, ska den ge implementeringar för alla abstrakta metoder för både Line och Polygon.
Obs! Ett gränssnitt kan utöka flera gränssnitt. Till exempel,
interface A (… ) interface B (… ) interface C extends A, B (… )
Fördelar med gränssnitt i Java
Nu när vi vet vad gränssnitt är, låt oss lära oss om varför gränssnitt används i Java.
- Gränssnitt ger specifikationer som en klass (som implementerar den) måste följa.
I vårt tidigare exempel har vi använtgetArea()som en specifikation inuti gränssnittet Polygon. Det här är som att ställa in en regel om att vi ska kunna få området för varje polygon.
Nu måste varje klass som implementerar Polygon-gränssnittet ge en implementering avgetArea()metoden. - I likhet med abstrakta klasser hjälper gränssnitt oss att uppnå abstraktion i Java .
Här vet vi attgetArea()beräknar området för polygoner men hur ytan beräknas skiljer sig åt för olika polygoner. Därför är implementeringen avgetArea()oberoende av varandra. - Gränssnitt används också för att uppnå flera arv i Java. Till exempel,
interface Line (… ) interface Polygon (… ) class Rectangle implements Line, Polygon (… )
Här implementerar klassen Rektangel två olika gränssnitt. Så här uppnår vi flera arv i Java.
standardmetoder i Java-gränssnitt
Med lanseringen av Java 8 kan vi nu lägga till metoder med implementering i ett gränssnitt. Dessa metoder kallas standardmetoder.
För att förklara standardmetoder i gränssnitt använder vi defaultnyckelordet. Till exempel,
public default void getSides() ( // body of getSides() )
Varför standardmetoder?
Låt oss ta ett scenario för att förstå varför standardmetoder introduceras i Java.
Antag att vi måste lägga till en ny metod i ett gränssnitt.
Vi kan enkelt lägga till metoden i vårt gränssnitt utan implementering. Men det är inte slutet på historien. Alla våra klasser som implementerar det gränssnittet måste ge en implementering av metoden.
Om ett stort antal klasser implementerade detta gränssnitt måste vi spåra alla dessa klasser och göra ändringar i dem. Detta är inte bara tråkigt men också felaktigt.
För att lösa detta introducerade Java standardmetoder. Standardmetoder ärvs som vanliga metoder.
Låt oss ta ett exempel för att få en bättre förståelse för standardmetoder.
Exempel: Standardmetod i Java-gränssnitt
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(); ) )
Produktion
Rektangelns yta är 30 jag har fyra sidor. Området på torget är 25 Jag kan få sidor av en polygon.
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.
Regeln för beräkning av området är dock annorlunda för olika polygoner. Följaktligen getArea()ingår utan genomförande.
Varje klass som implementerar Polygon måste ge en implementering av getArea().
