Java-interface

In deze zelfstudie leren we over Java-interfaces. Aan de hand van voorbeelden leren we hoe we interfaces moeten implementeren en wanneer we ze in detail moeten gebruiken.

Een interface is een volledig abstracte klasse. Het bevat een groep abstracte methoden (methoden zonder hoofdtekst).

We gebruiken de interface trefwoord om een interface in Java te maken. Bijvoorbeeld,

interface Language {
  public void getType();

  public void getVersion();
}

Hier,

Taal is een interface.
Het bevat abstracte methoden:getType() en getVersion() .

Een interface implementeren

Net als abstracte klassen kunnen we geen objecten of interfaces maken.

Om een interface te gebruiken, moeten andere klassen deze implementeren. We gebruiken de implements trefwoord om een interface te implementeren.

Voorbeeld 1:Java-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) {
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

Uitvoer

The area of the rectangle is 30

In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam Polygon . De interface bevat een abstracte methode getArea() .

Hier, de Rechthoek klasse implementeert Polygoon . En, zorgt voor de implementatie van de getArea() methode.

Voorbeeld 2: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

Programming Language: Java

In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam Taal . De interface bevat een abstracte methode getName() .

Hier, de ProgrammingLanguage class implementeert de interface en zorgt voor de implementatie van de methode.

Meerdere interfaces implementeren

In Java kan een klasse ook 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. De extends trefwoord wordt gebruikt voor het uitbreiden van interfaces. Bijvoorbeeld,

interface Line {
  // members of Line interface
}

// extending interface
interface Polygon extends Line {
  // members of Polygon interface
  // members of Line interface
}

Hier, de Polygoon interface verlengt de Lijn koppel. Nu, als een klasse Polygon implementeert , het zou implementaties moeten bieden voor alle abstracte methoden van zowel Line en Veelhoek .

Meerdere interfaces uitbreiden

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 eens kijken waarom interfaces in Java worden gebruikt.

Net als bij abstracte klassen, helpen interfaces ons om abstractie in Java te bereiken .

Hier kennen we getArea() berekent de oppervlakte van polygonen, maar de manier waarop de oppervlakte wordt berekend is verschillend voor verschillende polygonen. Vandaar dat de implementatie van getArea() is onafhankelijk van elkaar.
Interfaces geven specificaties dat een klasse (die het implementeert) moet volgen.

In ons vorige voorbeeld hebben we getArea() . gebruikt als een specificatie in de interface Polygon . Dit is hetzelfde als het instellen van een regel dat we de oppervlakte van elke polygoon moeten kunnen krijgen.

Nu elke klasse die de Polygon . implementeert interface moet een implementatie bieden voor de getArea() methode.
Interfaces worden ook gebruikt om meervoudige overerving in Java te realiseren. Bijvoorbeeld,
```
interface Line {
…
}

interface Polygon {
…
}

class Rectangle implements Line, Polygon {
…
}
```
Hier, de klasse Rechthoek implementeert twee verschillende interfaces. Dit is hoe we meervoudige overerving in Java bereiken.

Opmerking :Alle methoden binnen een interface zijn impliciet public en alle velden zijn impliciet public static final . Bijvoorbeeld,

interface Language {
  
  // by default public static final
  String type = "programming language";

  // by default public
  void getName();
}

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 de default trefwoord. 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 zouden implementeren, 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 de standaardmethoden beter te begrijpen.

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

The area of the rectangle is 30
I have 4 sides.
The area of the square is 25
I can get sides of a polygon.

In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam Polygon . Het heeft een standaardmethode getSides() en een abstracte methode getArea() .

Hier hebben we twee klassen gemaakt Rechthoek en Vierkant die Polygoon . implementeren .

De Rechthoek class zorgt voor de implementatie van de getArea() methode en overschrijft de getSides() methode. Echter, het Vierkant class biedt alleen de implementatie van de getArea() methode.

Nu, terwijl u de getSides() . aanroept methode met behulp van de Rechthoek object, wordt de overschreven methode aangeroepen. In het geval van het Vierkant object, wordt de standaardmethode aangeroepen.

privé en statische methoden in interface

De Java 8 heeft ook een andere functie toegevoegd om statische methoden in een interface op te nemen.

Net als bij een klasse, hebben we toegang tot statische methoden van een interface met behulp van de verwijzingen. Bijvoorbeeld,

// create an interface
interface Polygon {
  staticMethod(){..}
}

// access static method
Polygon.staticMethod();

Opmerking :Met de release van Java 9 worden privémethoden ook ondersteund in interfaces.

We kunnen geen objecten van een interface maken. Daarom worden privémethoden gebruikt als hulpmethoden die ondersteuning bieden aan andere methoden in interfaces.

Praktisch voorbeeld van interface

Laten we een meer praktisch voorbeeld van Java-interface bekijken.

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

Uitvoer

Area: 2.9047375096555625
Perimeter: 9

In het bovenstaande programma hebben we een interface gemaakt met de naam Polygon . Het bevat een standaardmethode getPerimeter() en een abstracte methode getArea() .

We kunnen de omtrek van alle polygonen op dezelfde manier berekenen, dus hebben we de hoofdtekst van getPerimeter() geïmplementeerd in Veelhoek .

Nu, alle polygonen die Polygon . implementeren kan getPerimeter() . gebruiken om de omtrek te berekenen.

De regel voor het berekenen van het gebied is echter verschillend voor verschillende polygonen. Vandaar, getArea() is inbegrepen zonder implementatie.

Elke klasse die Polygon . implementeert moet een implementatie van getArea() . bieden .

Java abstracte klasse en abstracte methoden Java-polymorfisme

Java