Programmieren in Java - Interfaces und Abstrakte Methoden

Bild Referenz: https://lifebeginsatfortyblog.wordpress.com/2016/07/10/the-java-tutorials-interfaces/

Intro

    Hallo, ich bin's wieder @drifter2! Der heutige Artikel ist an meinem englischen Artikel "Java Interfaces" basiert. Das bedeutet das wir über Interfaces und dessen Abstrakte Methoden reden werden.Zusätzlich solltet ihr euch den vorherigen Artikel der Serie anschauen, wenn ihr es noch nicht gemacht habt! Also, fangen wir dann mal direkt an!

---

Interface

    Ein Interface, oder auch Schnittstelle gennant, wird bei einer speziellen Form der Vererbung verwendet. Dabei gibt es einen sehr wichtigen Unterschied. Ein Interface ist keine Klasse (class), sondern ein anderer Typ von Objekt der mit dem "interface" Schlüsselwort definiert wird. Ein solches Interface besteht aus statischen Daten (static data) und Abstrakten Methoden (abstract methods). Ein Interface kann von einem anderen Interface erben mit Hilfe von "extends", welches eine ganz normale Vererbung andeutet. Eine Klasse kann auch von einem Interface erben indem wir das Schlüsselwort "implements" verwenden, welches natürlich "implementiert" bedeutet. Dabei enthält dann die Klasse alle statischen Daten des Interfaces und muss alle Abstrakten Methoden definieren! Also der riesige Unterschied zwischen der Vererbung einer Klasse von einer Klasse oder einem Interfaces, welche beide Abstrakte Methoden enthalten, ist das wir beim Fall des Interfaces alle Abstrakten Methoden definieren müssen, etwas das bei Abstrakten Klassen nicht notwendig ist!

Die Definition eines Interfaces sieht wie folgend aus:

public interface interfaceName{ 
    // Statische Daten
    // Abstrakte Methoden
}

Die Vererbung des Interfaces von einer Klasse ist dann:

public class klassenName implements interfaceName{
    // Daten (welches auch die Statischen Daten des Interfaces enthalten)
    // Methoden (welche die Implementationen der Abstrakten Methoden
    // und anderer Funktionen enthalten)
}

---

Abstrakte Methoden

    Aber wie deklarieren und implementieren wir eine Abstrakte Methode? Ähnlich wie bei Abstrakten Klassen müssen wir nur das Schlüsselwort "abstract" verwenden. Die Definition der Methode enthält dann den Rückgabe-Typ und Namen der Methode und zusätzlich noch die Parameter die diese Methode bekommen soll. Da es noch keinen Code für die Funktion gibt werden wir nur ein ';' nach dieser ganzen Deklaration packen und keinen "{ }" Block. In Code sieht das also wie folgend aus:

public abstract RueckgabeTyp MethodenName( /*Parameter*/ );

    Um diese Methode dann zu implementieren müssen wir dann den selben Rückgabe-Typ und Namen, und natürlich auch die selben Parameter benutzen. Anstatt ';' kommt dann auch der richtige Code für diese Methode. Ihr könnt auch den Überschreibungs-Befehl "@Override" verwenden um diese Methode dann zu überschreiben. Da es aber keine vorherige Implementation dieser Methode gibt (wie es z.B. bei "toString" und "equals" der Fall ist) ist es nicht notwendig diesen Befehl zu verwenden! In Code sieht die Implementation der Methode dann wie folgend aus:

@Override
public RueckgabeTyp MethodenName( /*Parameter*/ ){
    // Code der Methode
}

---

Beispielprogramm

    Um das ganze noch besser zu verstehen sollten wir in ein kleines aber feines Beispielprogramm eingehen! Sagen wir mal wir wollen ein Interface erstellen für die Implementation der Sortierung eines Ganzzahl Feldes (int array). Es wird keine statische Variablen geben. Da man in zwei Wegen sortieren kann, werden wir eine Funktion für jeden Typen enthalten. Also wird es eine "absteigende" und eine "aufsteigende" Sortierungs-Methode geben! Unsere Hauptklasse "Driver" die dieses Interface mit dem Namen "Sortieren" implementiert (oder erbt) wird ein Ganzzahl-Feld von einer Größe von 20 Elementen mit zufälligen Zahlen füllen und dann zufällig eine der zwei Methoden abrufen. Natürlich müssen wir ja auch diese Methoden implementieren! Nach dem die Sortierung zu Ende ist, werden wir zuletzt noch das sortierte Feld bei der Konsole ausdrucken.

    Da wir diese Methoden bei keinen Objekt haben, sondern bei der Main Klasse des Programms, müssen wir beim ausführen der Methoden jedes mal eine neue "Instance" der "Driver"-Klasse erstellen, so das ein Anonymes Object von diesem Typ diese Methoden ausführen kann! Das geht ganz leicht mit Hilfe vom "new" Modifizierer und Konstruktor der Klasse Driver, wenn man bei dem kein Objekt als "Zielobjekt" definiert und einfach die Methode direkt ausführt! Also mit "new KlassenName().Methode()".

Fangen wir dann mal mit dem Interface an:

Sortierungs-Interface

public interface Sortieren { // Sortieren.java           
    // wir haben keine statische Variablen

    // Abstrakte Methoden
    public abstract void AbsteigendeSortierung(int[] nums);
    public abstract void AufsteigendeSortierung(int[] nums);
}

Driver-Klasse

public class Driver implements Sortieren { // Driver.java
    public static void main(String args[]) {
        int[] nums = new int[20];
        int r;
        // Mit zufaelligen Nummern fuellen
        for (int i = 0; i < nums.length; i++) {
            nums[i] = 1 + (int) (Math.random() * 100); // 1...100
        }
        r = (int) (Math.random()*2); // 0 oder 1
        if(r == 0){// Aufsteigend
            // Methode mit einer neuen Instance ausfuehren
            new Driver().AufsteigendeSortierung(nums);  
            // Feld ausdruecken
            for (int i = 0; i < nums.length; i++) {
                System.out.println(nums[i]);
            }
            System.out.println();
        }
        else{ // Absteigend
            // Methode mit einer neuen Instance ausfuehren
            new Driver().AbsteigendeSortierung(nums);
            // Feld ausdruecken
            for (int i = 0; i < nums.length; i++) {
                System.out.println(nums[i]);
            }
            System.out.println();
        }       
    }
    // Methoden implementieren
    public void AbsteigendeSortierung(int nums[]) {
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (nums[i] > nums[j]) {
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                }
            }
        }
    }
    public void AufsteigendeSortierung(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (nums[i] < nums[j]) {
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                }
            }
        }
    }
}

    Beim ausführen dieses Programms ist die Ausgabe zufällig! Eine solche Ausgabe sieht aber wie folgend aus:

---

Referenzen:

1. http://www.programmierenlernenhq.de/interfaces-in-java/
2. https://www.java-tutorial.org/interfaces.html
3. https://steemit.com/programming/@drifter1/programming-java-interfaces

    Der Artikel ist zu 90% eine Übersetzung von meinen englischen Artikel, aber enthält ein paar zusätzliche Informationen. Die Referenzen haben dabei geholfen die richtigen deutschen Begriffe zu finden und zu verwenden, da ich nicht Deutsch bin und Programmieren in Englisch gelernt habe.

---

Vorherige Artikel

• Von C nach Java -> Ähnlichkeiten mit C, OOP, Ein- und Ausgabe über die Konsole, Array-Feld Objekt, C-like Beispielprogramm
• Klassen und Methoden -> Klassen-Aufbau, Main Klasse, Objekt Klassen und Konstruktoren, Getters und Setters, toString(), Methoden generell, Komplettes Beispielprogramm
• Assoziation, Komposition und ArrayList -> Assoziation, Komposition, ArrayList und ein komplettes Beispielprogramm
• Vererbung zwischen Klassen -> Vererbung, Oberklassen, Abstrakte Klassen und ein komplettes Beispielprogramm

---

Schlusswort

    Und das war's dann auch mit dem heutigen Artikel und ich hoffe euch hat dieser Artikel gefallen! Beim nächsten Artikel werden wir über Ausnahmen (Exceptions) reden.


Keep on drifting! ;)