Interfaces in Java

Einführung

Interfaces sind ein wesentlicher Bestandteil der objektorientierten Programmierung in Java. Sie bieten eine Struktur, die Konsistenz und die Implementierung essenzieller Methoden in verschiedenen Klassen gewährleistet.

• Die Rolle von Interfaces
• Warum Interfaces Verwenden?
• Design Patterns und Interfaces
• Unterschied zwischen Interfaces und Abstrakten Klassen
• Veranschaulichung mit Code

Die Rolle von Interfaces

In Java fungieren Interfaces als Verträge. Sie legen eine Reihe von Methoden fest, die eine Klasse implementieren muss. Sie haben keine eigene Implementierung; sie stellen lediglich die Methodensignaturen bereit.

Warum Interfaces Verwenden?

1. Polymorphismus: Interfaces fördern den Polymorphismus. Jedes Objekt einer Klasse, die ein Interface implementiert, kann als Objekt dieses Interfaces referenziert werden.
2. Flexibilität: Interfaces machen das System erweiterbar. Sie ermöglichen es, den Code weiterzuentwickeln, ohne Klassen zu brechen, die bereits bestehende Interfaces verwenden.
3. Sicherheit: Sie legen einen strikten Vertrag fest, den die Klasse einhalten muss, und stellen sicher, dass bestimmte Methoden implementiert werden.

Design Patterns und Interfaces

Viele Design Patterns in Java nutzen Interfaces aufgrund ihrer Flexibilität. Das Adapter-Pattern verwendet Interfaces beispielsweise, um inkompatible Interfaces kompatibel zu machen, und das Factory-Pattern kann Interfaces nutzen, um eine Erstellungsmethode zu definieren.

Unterschied zwischen Interfaces und Abstrakten Klassen

Obwohl beide ein Mittel bieten, um Klassen zur Einhaltung eines bestimmten Vertrags zu zwingen, gibt es grundlegende Unterschiede:

• Klassen können mehrere Interfaces implementieren, aber nur von einer abstrakten Klasse erben.
• Interfaces haben keine Zustandsvariablen; abstrakte Klassen können welche haben.
• Interface-Methoden sind standardmäßig public und abstract. In abstrakten Klassen hat man mehr Flexibilität hinsichtlich Sichtbarkeit und Implementierung.

Veranschaulichung mit Code

Interfaces werden verwendet, um die Implementierung bestimmter Methoden sicherzustellen:

package com.caffeinealgorithm.programaremjava;

public class Interfaces {
  public void Run() {
    var fahrzeug = new Fahrzeug("Nissan", "Juke", "Vorne", "Manuell", "Diesel", 1461, 175, 110, 25070);
    fahrzeug.info();

    /*
      Marke: Nissan
      Modell: Juke
      Motorposition: Vorne
      Getriebe: Manuell
      Kraftstoff: Diesel
      Hubraum: 1461 cc
      Höchstgeschwindigkeit: 175 km/h
      Maximalleistung: 110 PS
      Preis: 25070.00 Euro
    */
  }
}

class Fahrzeug implements IFahrzeug {
  private String marke, modell, motorPosition, getriebe, kraftstoff;
  private int hubraum, hoechstgeschwindigkeit, maximalLeistung;
  private double preis;

  public Fahrzeug(String marke, String modell, String motorPosition, String getriebe, String kraftstoff,
                  int hubraum, int hoechstgeschwindigkeit, int maximalLeistung, double preis) {
    this.marke = marke;
    this.modell = modell;
    this.motorPosition = motorPosition;
    this.getriebe = getriebe;
    this.kraftstoff = kraftstoff;
    this.hubraum = hubraum;
    this.hoechstgeschwindigkeit = hoechstgeschwindigkeit;
    this.maximalLeistung = maximalLeistung;
    this.preis = preis;
  }

  public void info() {
    System.out.printf("Marke: %s\n", marke);
    System.out.printf("Modell: %s\n", modell);
    System.out.printf("Motorposition: %s\n", motorPosition);
    System.out.printf("Getriebe: %s\n", getriebe);
    System.out.printf("Kraftstoff: %s\n", kraftstoff);
    System.out.printf("Hubraum: %d cc\n", hubraum);
    System.out.printf("Höchstgeschwindigkeit: %d km/h\n", hoechstgeschwindigkeit);
    System.out.printf("Maximalleistung: %d PS\n", maximalLeistung);
    System.out.printf("Preis: %.2f Euro", preis);
  }
}

interface IFahrzeug {
  void info();
}

In diesem Beispiel implementiert die Klasse Fahrzeug das Interface IFahrzeug und stellt damit die Existenz der Methode info() sicher.

Fazit

Interfaces in Java sind unverzichtbare Werkzeuge, die viele Vorteile hinsichtlich Polymorphismus, Flexibilität und Sicherheit bieten. Sie sind grundlegend für den Aufbau erweiterbarer und wartbarer Systeme. Die Möglichkeit, Interfaces in Verbindung mit Design Patterns zu verwenden, macht sie zu einem unschätzbaren Teil des Werkzeugkastens eines jeden Java-Entwicklers.

Happy coding!