Java-interfaces

1. Overzicht

In deze tutorial gaan we het hebben over interfaces in Java. We zullen ook zien hoe Java ze gebruikt om polymorfisme en meerdere overervingen te implementeren.

2. Wat zijn interfaces in Java?

In Java is een interface een abstract type dat een verzameling methoden en constante variabelen bevat. Het is een van de kernconcepten in Java en is gebruikt om abstractie, polymorfisme en meerdere overervingen te bereiken.

Laten we een eenvoudig voorbeeld bekijken van een interface in Java:

openbare interface Elektronische {// Constante variabele String LED = "LED"; // Abstracte methode int getElectricityUse (); // Statische methode statische boolean isEnergyEfficient (String electtronicType) {if (electtronicType.equals (LED)) {return true; } return false; } // Standaardmethode default void printDescription () {System.out.println ("Elektronische beschrijving"); }} 

We kunnen een interface in een Java-klasse implementeren door de werktuigen trefwoord.

Laten we vervolgens ook een Computer klasse die de Elektronisch interface die we zojuist hebben gemaakt:

openbare klasse Computer implementeert Electronic {@Override public int getElectricityUse () {return 1000; }} 

2.1. Regels voor het maken van interfaces

In een interface mogen we gebruiken:

  • constanten variabelen
  • abstracte methoden
  • statische methoden
  • standaard methoden

We moeten ook onthouden dat:

  • we kunnen interfaces niet rechtstreeks instantiëren
  • een interface kan leeg zijn, zonder methodes of variabelen
  • we kunnen de laatste woord in de interfacedefinitie, omdat dit zal resulteren in een compilatiefout
  • alle interface-declaraties zouden de openbaar of standaard toegangsmodificator; de abstract modifier wordt automatisch toegevoegd door de compiler
  • een interfacemethode kan dat niet zijn privaat, beschermd, of laatste
  • interfacevariabelen zijn openbaar, statisch, en laatste per definitie; we mogen hun zichtbaarheid niet veranderen

3. Wat kunnen we bereiken door ze te gebruiken?

3.1. Gedragsfunctionaliteit

We gebruiken interfaces om bepaalde gedragsfunctionaliteit toe te voegen die kan worden gebruikt door niet-gerelateerde klassen. Bijvoorbeeld, Vergelijkbaar, Comparator, en Te klonen zijn Java-interfaces die kunnen worden geïmplementeerd door niet-gerelateerde klassen. Hieronder ziet u een voorbeeld van de Comparator koppeldat wordt gebruikt om twee instanties van de Werknemer klasse:

openbare klasse Werknemer {privé dubbel salaris; openbare dubbele getSalary () {salaris teruggeven; } public void setSalary (dubbel salaris) {this.salary = salaris; }} public class EmployeeSalaryComparator implementeert Comparator {@Override public int Compare (Employee employeeA, Employee employeeB) {if (employeeA.getSalary () employeeB.getSalary ()) {return 1; } else {return 0; }}} 

Ga voor meer informatie naar onze tutorial over Comparator en Vergelijkbaar in Java.

3.2. Meerdere erfenissen

Java-klassen ondersteunen enkelvoudige overerving. Door interfaces te gebruiken, kunnen we echter ook meerdere overervingen implementeren.

In het onderstaande voorbeeld zien we bijvoorbeeld dat de Auto klasseimplementeert het Vlieg en Transformeren interfaces. Door dit te doen, erft het de methoden vlieg en transformeren:

openbare interface Transformeren {void transform (); } openbare interface Fly {void fly (); } public class Car implementeert Fly, Transform {@Override public void fly () {System.out.println ("I can Fly !!"); } @Override public void transform () {System.out.println ("Ik kan transformeren !!"); }} 

3.3. Polymorfisme

Laten we beginnen met de vraag: wat is polymorfisme? Het is de mogelijkheid voor een object om tijdens runtime verschillende vormen aan te nemen. Om meer specifiek te zijn, is het de uitvoering van de override-methode die tijdens runtime gerelateerd is aan een specifiek objecttype.

In Java kunnen we polymorfisme bereiken met behulp van interfaces. Bijvoorbeeld de Vorm interface kan verschillende vormen aannemen - het kan een Cirkel of een Plein.

Laten we beginnen met het definiëren van de Vorm koppel:

openbare interface Shape {String naam (); } 

Laten we nu ook het Cirkel klasse:

public class Circle implementeert Shape {@Override public String name () {return "Circle"; }} 

En ook de Plein klasse:

public class Square implementeert Shape {@Override public String name () {return "Square"; }} 

Eindelijk is het tijd om polymorfisme in actie te zien met behulp van onze Vorm interface en de implementaties ervan. Laten we wat instantiëren Vorm objecten, voeg ze toe aan een Lijst, en tenslotte, print hun namen in een lus:

Lijstvormen = nieuwe ArrayList (); Shape circleShape = nieuwe Circle (); Vorm squareShape = nieuw Vierkant (); shapes.add (circleShape); shapes.add (vierkante vorm); voor (Shape shape: shapes) {System.out.println (shape.name ()); } 

4. Standaardmethoden in interfaces

Traditionele interfaces in Java 7 en lager bieden geen achterwaartse compatibiliteit.

Dit betekent dat als je oude code hebt geschreven in Java 7 of eerder, en je besluit een abstracte methode toe te voegen aan een bestaande interface, dan moeten alle klassen die die interface implementeren de nieuwe abstracte methode overschrijven. Anders breekt de code.

Java 8 loste dit probleem op door de standaardmethode te introduceren dat is optioneel en kan op interfaceniveau worden geïmplementeerd.

5. Regels voor interface-overerving

Om meerdere overervingen via interfaces te bereiken, moeten we een paar regels onthouden. Laten we deze in detail bespreken.

5.1. Interface die een andere interface uitbreidt

Wanneer een interface strekt zich uit een andere interface, het erft alle abstracte methoden van die interface. Laten we beginnen met het maken van twee interfaces, HasColor en Vorm:

openbare interface HasColor {String getColor (); } openbare interface Box breidt HasColor uit {int getHeight ()} 

In het bovenstaande voorbeeld, Doos erft van HasColor met behulp van het trefwoord strekt zich uit. Door dit te doen, kan het Doos interface erft getColor. Als gevolg hiervan is het Doos interface heeft nu twee methoden: getColor en getHeight.

5.2. Abstracte klasse die een interface implementeert

Wanneer een abstracte klasse een interface implementeert, erft het al zijn abstracte en standaardmethoden. Laten we eens kijken naar de Transformeren interface en de abstract klasse Voertuig die het implementeert:

openbare interface Transformeren {void transform (); default void printSpecs () {System.out.println ("Transform Specification"); }} openbare abstracte klasse Voertuig implementeert Transform {} 

In dit voorbeeld is de Voertuig klasse erft twee methoden: de abstract transformeren methode en de standaard printSpecs methode.

6. Functionele interfaces

Java heeft sinds het begin veel functionele interfaces gehad, zoals Vergelijkbaar (sinds Java 1.2) en Runnable (sinds Java 1.0).

Java 8 introduceerde nieuwe functionele interfaces zoals Predikaat, Klant, en Functie. Voor meer informatie hierover, bezoek onze tutorial over functionele interfaces in Java 8.

7. Conclusie

In deze tutorial gaven we een overzicht van Java-interfaces, en we spraken over hoe je ze kunt gebruiken om polymorfisme en meerdere overervingen te bereiken.

Zoals altijd zijn de volledige codevoorbeelden beschikbaar op GitHub.