Java - Interfaces

Een interface is een referentietype in Java. Het is vergelijkbaar met klasse. Het is een verzameling abstracte methoden. Een klasse implementeert een interface, waardoor de abstracte methoden van de interface worden geërfd.

Naast abstracte methoden kan een interface ook constanten, standaardmethoden, statische methoden en geneste typen bevatten. Methode-teksten bestaan alleen voor standaardmethoden en statische methoden.

Het schrijven van een interface is vergelijkbaar met het schrijven van een klasse. Maar een klasse beschrijft de kenmerken en het gedrag van een object. En een interface bevat gedragingen die een klasse implementeert.

Tenzij de klasse die de interface implementeert abstract is, moeten alle methoden van de interface in de klasse worden gedefinieerd.

Een interface lijkt op de volgende manieren op een klasse −

Een interface kan een willekeurig aantal methoden bevatten.
Een interface is geschreven in een bestand met een .java extensie, waarbij de naam van de interface overeenkomt met de naam van het bestand.
De bytecode van een interface verschijnt in een .class bestand.
Interfaces verschijnen in pakketten en het bijbehorende bytecodebestand moet zich in een directorystructuur bevinden die overeenkomt met de pakketnaam.

Een interface verschilt echter op verschillende manieren van een klasse, waaronder −

U kunt geen interface instantiëren.
Een interface bevat geen constructors.
Alle methoden in een interface zijn abstract.
Een interface kan geen instantievelden bevatten. De enige velden die in een interface kunnen verschijnen, moeten zowel statisch als definitief worden verklaard.
Een interface wordt niet uitgebreid met een klasse; het wordt geïmplementeerd door een klasse.
Een interface kan meerdere interfaces uitbreiden.

Interfaces declareren

De interface trefwoord wordt gebruikt om een interface te declareren. Hier is een eenvoudig voorbeeld om een interface te declareren −

Voorbeeld

Hieronder volgt een voorbeeld van een interface −

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

public interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations\
}

Interfaces hebben de volgende eigenschappen −

Een interface is impliciet abstract. U hoeft de abstracte . niet te gebruiken zoekwoord terwijl u een interface declareert.
Elke methode in een interface is ook impliciet abstract, dus het abstracte trefwoord is niet nodig.
Methoden in een interface zijn impliciet openbaar.

Voorbeeld

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

Interfaces implementeren

Wanneer een klasse een interface implementeert, kun je de klasse beschouwen als het ondertekenen van een contract, waarin wordt overeengekomen om het specifieke gedrag van de interface uit te voeren. Als een klasse niet alle gedragingen van de interface uitvoert, moet de klasse zichzelf als abstract verklaren.

Een klasse gebruikt de implementeert trefwoord om een interface te implementeren. Het sleutelwoord implements verschijnt in de klassedeclaratie na het uitgebreide gedeelte van de declaratie.

Voorbeeld

/* File name : MammalInt.java */
public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Dit levert het volgende resultaat op −

Uitvoer

Mammal eats
Mammal travels

Bij het overschrijven van methoden die zijn gedefinieerd in interfaces, zijn er verschillende regels die moeten worden gevolgd −

Aangevinkte uitzonderingen mogen niet worden gedeclareerd op andere implementatiemethoden dan degene die zijn aangegeven door de interfacemethode of subklassen van degene die zijn gedeclareerd door de interfacemethode.
De handtekening van de interfacemethode en hetzelfde retourtype of subtype moeten behouden blijven bij het overschrijven van de methoden.
Een implementatieklasse zelf kan abstract zijn en als dat zo is, hoeven interfacemethoden niet te worden geïmplementeerd.

Bij implementatie-interfaces zijn er verschillende regels −

Een klasse kan meer dan één interface tegelijk implementeren.
Een klasse kan slechts één klasse uitbreiden, maar veel interfaces implementeren.
Een interface kan een andere interface uitbreiden, op dezelfde manier als een klasse een andere klasse kan uitbreiden.

Interfaces uitbreiden

Een interface kan een andere interface uitbreiden op dezelfde manier als een klasse een andere klasse kan uitbreiden. De verlengt trefwoord wordt gebruikt om een interface uit te breiden, en de onderliggende interface erft de methoden van de bovenliggende interface.

De volgende sportinterface is uitgebreid met hockey- en voetbalinterfaces.

Voorbeeld

// Filename: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

De Hockey-interface heeft vier methoden, maar er zijn er twee van Sports; dus een klasse die Hockey implementeert, moet alle zes methoden implementeren. Evenzo moet een klasse die Football implementeert de drie methoden van Football en de twee methoden van Sports definiëren.

Meerdere interfaces uitbreiden

Een Java-klasse kan slechts één bovenliggende klasse uitbreiden. Meervoudige overerving is niet toegestaan. Interfaces zijn echter geen klassen en een interface kan meer dan één bovenliggende interface uitbreiden.

Het trefwoord extends wordt één keer gebruikt en de bovenliggende interfaces worden gedeclareerd in een door komma's gescheiden lijst.

Als de Hockey-interface bijvoorbeeld zowel Sport als Evenement zou uitbreiden, zou het worden gedeclareerd als −

Voorbeeld

public interface Hockey extends Sports, Event

Tagging-interfaces

Het meest voorkomende gebruik van uitbreidingsinterfaces vindt plaats wanneer de bovenliggende interface geen methoden bevat. Bijvoorbeeld, de MouseListener-interface in het pakket java.awt.event breidde java.util.EventListener uit, dat is gedefinieerd als −

Voorbeeld

package java.util;
public interface EventListener
{}

Een interface zonder methoden wordt een tagging . genoemd koppel. Er zijn twee fundamentele ontwerpdoelen voor het taggen van interfaces −

Maakt een gemeenschappelijke ouder − Net als bij de EventListener-interface, die is uitgebreid met tientallen andere interfaces in de Java API, kunt u een tagging-interface gebruiken om een gemeenschappelijk bovenliggend element te maken tussen een groep interfaces. Wanneer een interface bijvoorbeeld EventListener uitbreidt, weet de JVM dat deze specifieke interface zal worden gebruikt in een scenario voor het delegeren van gebeurtenissen.

Voegt een gegevenstype toe aan een klas − Deze situatie is waar de term tagging vandaan komt. Een klasse die een tagging-interface implementeert, hoeft geen methoden te definiëren (aangezien de interface er geen heeft), maar de klasse wordt een interfacetype door polymorfisme.

Java - Inkapseling Java - Pakketten

Java