Abstract

Aus Wiklet

Definiert eine Klasse oder Methode als abstrakt. Eine abstrakte Klasse kann nicht instantiiert werden, für eine abstrakte Methode wird keine Implementierung definiert. Eine abstrakte Klasse kann gleichzeitig abstrakte und nicht abstrakte Methoden haben. Eine Klasse muss als abstrakt deklariert sein, wenn sie abstrakte Methoden enthält. Prinzipiell ist es auch möglich, dass eine abstrakte Klasse keine abstrakten Methoden keine abstrakten Methoden beinhaltet. Dann sollte aber hinterfragt werden, warum die Klasse abstrakt sein soll. Im Allgemeinen ist das nicht sinnvoll.

Beispiel:

public abstract class Animal {
    private String name;
 
    public Animal(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public abstract String speak();
}

Von der abstrakten Klasse Animal können keine Instanzen erzeugt werden. Die Klassen Dog und Cat, die von Animal erben können eine Implementierung für die abstrakte Methode speak bieten.

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
 
    public String speak() {
        return "wuff";
    }
}
 
public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
 
    public String speak() {
        return "miau";
    }
}

In Instanzen beider Klassen, Dog und Cat, können die implementierten Methoden der Basisklasse benutzt werden.

Beispiel

Animal dog = new Dog("Waldi");
Animal cat = new Cat("Felix");
 
System.out.println(dog.getName() + " sagt: " + dog.speak());
System.out.println(cat.getName() + " sagt: " + cat.speak());

Als Augabe erhält man

Waldi sagt: wuff 
Felix sagt: miau

Man beachte, dass dog und cat Referenzen auf Animals sind, nicht Dog- und Catreferenzen. Der Vorteil wird klar, wenn man getrennte Kompilationseinheiten hat:

import java.util.*;
public class Zoo {
    private List<Animal> animals = new ArrayList <Animal> ();
 
    public void add (Animal a) {
                animals.add (a);
    }
 
    public void palaver () {
        for (Animal animal : animals) {
	    System.out.println (animal.speak ());
        }
    }
}

public class ZooTest {
    public static void main (String args[]) {
        Zoo zoo = new Zoo ();
        zoo.add (new Dog ("Struppi"));
        zoo.add (new Cat ("Mitzi"));
        zoo.add (new Cat ("Joshua"));
        zoo.palaver ();
    }
}

Die Abstraktion erlaubt ein flexibles Design. Um ein lustiges Palaver zu veranstalten muss nicht jedes Detail des Tieres bekannt sein - lediglich eine Methode speak muss implementiert sein. Das Modell ist leicht um weitere Tiere zu erweitern, die ebenfalls speak implementieren müssen, um am Palaver teilnehmen zu können.

Beispiel:

public class Parrot extends Animal {
    public Parrot(String name) {
        super(name);
    }
 
    public String speak() {
        return getName() + " will einen Keks";
    }
}

Objekte dieser neuen Klasse können nun einfach dem Zoo hinzugefügt werden, obwohl bei der Erstellung noch niemand an Papageien gedacht hat. Magisch!

Beispiel:

public class ZooTest {
    public static void main (String args[]) {
        Zoo zoo = new Zoo ();
        zoo.add (new Dog ("Struppi"));
        zoo.add (new Cat ("Mitzi"));
        zoo.add (new Cat ("Joshua"));
        zoo.add (new Parrot ("Coco"));
        zoo.palaver ();
    }
}

Die abstrakte Methode ist eine Art Versprechen, das garantiert, dass es diese Methode geben wird und man sie nutzen kann, ohne die konkrete Implementierung zu kennen.