Überladene Methoden sind Methoden mit gleichem Namen aber unterschiedlicher Parameterliste. Sie besitzen also unterschiedliche Signaturen. Sie werden oft verwendet, um dieselbe Funktionalität mit unterschiedlichen Datentypen zu realisieren. Mehr dazu findest du in unserer FAQ hier.

Überladene Methoden können zur Beschreibung von Methoden mit unterschiedlichem Differenzierungsgrad verwendet werden.
Beispiel:

public void drawPixel(int x, int y) {
    // ...
}

public void drawPixel(int x, int y, Color c) {
    // ...
}

Die erste Methode zeichnet einen Punkt in der aktuellen Vordergrundfarbe.
Die zweite Methode besitzt einen zusätzlichen Parameter c, der angibt, in welcher Farbe der Punkt dargestellt wird.

Eine wesentliche Idee der objektorientierten Programmierung ist, dass Programmabläufe mit Hilfe von Objekten modelliert werden. Objekte bestehen aus Daten und den zur Verarbeitung der Daten notwendigen Methoden. Über Vererbung können Objekte durch neuen Eigenschaften ergänzt werden.

Java verfügt über elementare Datentypen wie int, double, boolean, …. Ist also nicht 100% objektorientiert.

Interfaces werden verwendet, um Software zu schreiben, die unabhängig von einer konkreten Implementierung ist. Im Interface wird lediglich eine Schnittstelle vereinbart. Diese Schnittstelle beschreibt, wie eine Klasse zu verwenden ist.

In Java ist eine Mehrfachvererbung nicht möglich. Mit Hilfe von Interfaces kann trotzdem gewährleistet werden, dass Klassen die nicht in einer gemeinsamen Vererbungshierachie sind, bestimmte Eigenschaften und Methoden besitzen.

Beispiel aus der Java-Klassenbibliothek:
Abgesehen von Object sind die Klassen String und Integer in keiner gemeinsamen Vererbungshierachie. Trotzdem implementieren beide Klassen das Comparable-Interface – müssen also eine konkrete Implementierung der Methode compareTo() anbieten. Objekte der Klasse String können also genauso wie Objekte der Kasse Integer miteinander verglichen und damit auch sortiert werden.

Interface

Ein Interface definiert Methoden. Diese Methoden müssen von allen abgeleiteten Klassen, die nicht abstrakt sind, implementiert werden. Neben den Signaturen für die zu implementierenden Methoden kann ein Interface Konstanten und Enumerationen haben.

Interfaces werden verwendet, um Software zu schreiben, die unabhängig von einer konkreten Implementierung ist. Festgelegt wird im Interface lediglich eine Schnittstelle. Diese Schnittstelle beschreibt, wie eine Klasse zu verwenden ist.

Beispiel aus der Java-Klassenbibliothek:
Alle nicht abstrakten Klassen, die das Comparable-Interface implementieren, müssen eine konkrete Implementierung der Methode compareTo() anbieten.

Abstrakte Klasse

Eine abstrakte Klasse kann im Unterschied zum Interface neben abstrakten Methoden auch konkrete Implementierungen von Methoden haben. Außerdem kann sie auch Instanz- und Klassenvariablen besitzen. Eine abstrakte Methode legt – genauso wie eine Interface-Methode – eine Signatur für die zu implementierende Methode fest.

Bei der Verwendung von abstrakten Klassen ist zu beachten, dass eine Klasse von höchstens einer abstrakten Klasse abgeleitet werden kann. Im Gegensatz dazu kann eine Klasse beliebig viele Interfaces implementieren.

Instanzvariablen:

Instanzvariablen gehören zu einer Instanz einer Klasse – also einem Objekt. Jedes Objekt verfügt über seine eigenen Instanzvariablen. Auf eine Instanzvariable v kann mit this.v zugegriffen werden. Falls keine Verwechslungsmöglichkeit mit einer lokalen Variable gleichen Namens besteht, kann man this auch weglassen.

Klassenvariablen:

Klassenvariablen gehören zu einer Klasse. Unabhängig von der Anzahl der von dieser Klasse erzeugten Objekte existieren sie genau ein Mal. Klassenvariablen werden auch als statische Variablen bezeichnet (Schlüsselwort: static).

Beispiel:

class Person {
    private static int count; // Klassenvariable
    private String name;      // Instanzvariable

    Person(String name) {
        this.name = name;
        count++;
    }

    String getName() {
        return name;
    }

    int getCount() {
        return count;
    }
}

class Test {
    public static void main(String[] args) {
        Person p1 = new Person("Anna");
        Person p2 = new Person("Berta");
        Person p3 = new Person("Caesar");

        System.out.println(p3.getCount());  // Ausgabe: 3
    }
}

Jedes Mal wenn eine Instanz angelegt wird, wird die statische Variable count im Konstruktor inkrementiert. Am Ende des Programmlaufs hat count den Wert 3.

Der Einsatz von static-Klassen ist sinnvoll für Sammlungen von Methoden, die keinen Zustand haben. Die Methoden bekommen Daten übergeben, verarbeiten diese und geben das Resultat zurück. Es besteht eine Ähnlichkeit zu Funktionen in der Mathematik.

In der Klassenbibliothek von Java ist die Klasse java.lang.Math ein Musterbeispiel für eine statische Klasse. Diese Klasse implementiert verschiedene mathematische Funktionen (sin(), cos(), log(), …), die keine gemeinsamen Zustände haben.

Die im folgenden Beispiel vorgestellte Klasse ArrayUtils zeigt die Umsetzung einer statischen Klasse mit Hilfsmethoden für Arrays. Auch diese Methoden haben keine gemeinsamen Zustände. Die statischen Methoden der Klasse ArrayUtils bekommen ein Array übergeben, verarbeiten die Werte des Arrays und geben ein Ergebnis zurück.

public class ArrayUtils {

    private ArrayUtils() {
    }

    public static double sum(double[] a) {
        double result = 0.0;
        for (double ai : a) {
            result += ai;
        }
        return result;
    }

    public static double average(double[] a) {
        return sum(a) / a.length;
    }
}

// Verwendung:
double[] a = {1.2, 3.4, 5.6};
double avg = ArrayUtils.average(a);

Um zu erzwingen, dass eine Klasse nur in einem statischen Kontext verwendet wird, kann ein privater Konstruktor implementiert (Zeile 3) werden. Damit wird verhindert, dass Instanzen der Klasse mittels new erzeugt werden können.

Ja. Eine Klasse kann mehrere Interfaces implementieren.

Interfaces werden verwendet, um Software zu schreiben, die unabhängig von einer konkreten Implementierung ist. Im Interface werden lediglich Schnittstellen vereinbart, die dann in der konkreten Implementierung umgesetzt werden müssen.

Das Implementieren mehrerer Interfaces kann sinnvoll sein, wenn eine Klasse A verschiedene Verhalten besitzen soll. Sollen die Objekte einer Klasse sortierbar und serialisierbar sein, dann wird diese Klasse die Interfaces Comparable und Serializable implementieren. Bei der Verwendung der Klasse A hat man die Zusicherung, dass alle Methoden der beiden Interfaces implementiert sind.

Nein. Im Unterschied zu anderen Sprachen wie C++ ist die Mehrfachvererbung in Java nicht möglich.

In Java kann eine Klasse nur von einer Klasse mit extends abgeleitet werden.

Um die Implementierung weiterer Schnittstellen sicher zu stellen, kann eine Klasse mehrere Interfaces implementieren. Mehr dazu findest du im Artikel “Darf eine Klasse mehrere Interfaces implementieren?” in unserer FAQ.

Enumerationen sind spezielle Klassen. Sie dienen zum Speichern von konstanten Objekten. Die konstanten Objekte sind von java.lang.Enum abgeleitet und besitzen unter anderem folgende Methoden:

• public final int ordinal() – gibt die Ordinalzahl (eine laufende Nummer, beginnend bei 0) des Enum-Objekts zurück
• public final String name() – gibt den Namen des Enum-Objekts zurück
• public final String toString() – gibt – genauso wie die Methode name() – den Namen des Enum-Objekts zurück
• public final int compareTo(E other) – vergleicht das Enum-Objekt mit einem anderen Enum-Objekt vom Typ E anhand der Ordinalzahl.

Zusätzlich werden vom Compiler für eine Enumeration vom Typ E folgende Methoden generiert:

• public static final E[] values() – gibt ein Array mit allen Enum-Objekten zurück
• public static E valueOf(String s) – gibt das Enum-Objekt mit dem Namen s zurück

In einer Enumeration können eigene Instanzvariablen und Methoden definiert werden.

Eine Enumeration ist ein Aufzählungstyp. Das heißt, ihre Elemente sind geordnet, können also mit der Methode compareTo() verglichen werden. Das Vergleichskriterium ist die Ordinalzahl des Enum-Objekts. Die Ordinalzahl eines Enum-Objekts entspricht – wenn nicht anders definiert – der Position, an der der Name des Objekts in der enum angeführt ist. Im untenstehenden Beispiel hat ROT die Ordinalzahl 0, GRÜN die Ordinalzahl 1 und BLAU die Ordinalzahl 2.

Einfaches Beispiel für eine Enumeration:

enum Farbe {
    ROT, GRÜN, BLAU
}

// Verwendung:
        
Farbe f = Farbe.GRÜN;
System.out.println(f.ordinal());  // Ausgabe: 1
System.out.println(f.name());     // Ausgabe: GRÜN

Komplexeres Beispiel mit einer Enumeration:

public class EnumTest {
    enum Wochentag {
        MONTAG("Mo"), DIENSTAG("Di"), MITTWOCH("Mi"), DONNERSTAG("Do"), FREITAG("Fr"), SAMSTAG("Sa"), SONNTAG("So");

        private final String shortName;

        Wochentag(String shortName) {
            this.shortName = shortName;
        }
        
        String getShortName() {
            return shortName;
        }

        boolean isWerktag() {
            return Wochentag.SONNTAG.compareTo(this) != 0;
        }
    }

    public static void main(String[] args) {
        System.out.println(Wochentag.MITTWOCH.isWerktag());
        System.out.println(Wochentag.SONNTAG.isWerktag());
        for (Wochentag w : Wochentag.values()) {
            System.out.printf("%d %-5b %-10s %s\n", w.ordinal(), w.isWerktag(), w.name(), w.getShortName());
        }
    }
}

// Ausgabe:
//
// 0 true  MONTAG     Mo
// 1 true  DIENSTAG   Di
// 2 true  MITTWOCH   Mi
// 3 true  DONNERSTAG Do
// 4 true  FREITAG    Fr
// 5 true  SAMSTAG    Sa
// 6 false SONNTAG    So

Die Enum-Objekte von Wochentag haben ein zusätzliches Attribut shortName, das die Kurzbezeichnung des Wochentags speichert. Beim Initialisieren der Enumeration wird für jedes Objekt der Aufzählung der Konstruktor in Zeile 7 mit dem Kurznamen als Argument aufgerufen.

Die Methode isWerktag() vergleicht das Objekt, in dem diese Methode aufgerufen wird, mit dem Objekt SONNTAG. Liefert der Vergleich einen Wert ungleich 0, handelt es sich um einen Werktag. Ansonsten handelt es sich um einen Sonntag.

In einem Interface können Methoden deklariert aber nicht implementiert werden.

Die in einem Interface deklarierten Methoden müssen von allen abgeleiteten Klassen, die nicht abstrakt sind, implementiert werden. Neben den Signaturen für die zu implementierenden Methoden kann ein Interface Konstanten und Enumerationen haben.

Mehr dazu findest du in den Artikeln “Wann ist ein Interface sinnvoll? Wozu braucht man Interfaces?” und “Was ist der Unterschied zwischen einer abstrakten Klasse und einem Interface?” in unserer FAQ.

Extends verwendet man für die Vererbung von Klassen. Leitet man eine Unterklasse B mit extends von der Oberklasse A ab, übernimmt die Klasse B alle nicht privaten Eigenschaften und Methoden von A. In der Unterklasse können zusätzliche Eigenschaften und Methoden implementiert werden.
In Java kann mit extends nur von einer Klasse geerbt werden.

Extends kann auch verwendet werden, um Interfaces zu erweitern.

Beispiel:

interface A {
    void m1();
}

interface B extends A {
    void m2();
}

class C implements B {

    @Override
    public void m1() {
        // TODO Auto-generated method stub
    }

    @Override
    public void m2() {
        // TODO Auto-generated method stub
    }
}

Das Interface B erweitert Interface A um die Methode m2(). Klasse C implementiert das Interface B, muss also die Methoden m1() und m2() implementieren.

Implements verwendet man für die Implementierung von Interfaces. Alle im Interface definierten Methoden müssen von der abgeleiteten Klasse implementiert werden, außer die abgeleitete Klasse ist mit dem Schlüsselwort abstract versehen. In diesem Fall müssen die Methoden nicht implementiert werden.
In Java kann mit implements von mehreren Interfaces geerbt werden.

Sind keine Modifikatoren (public, private, protected) angegeben, ist die Sichtbarkeit der Attribute, Methoden und Klassen package private. Das heißt, sie sind nur innerhalb des Pakets sichtbar.

Die folgende Tabelle zeigt eine Übersicht über die Modifikatoren und ihre Auswirkung auf die Sichtbarkeit von Attributen, Methoden und Klassen.