Abstrakte Klassen können als Zwischenstufe zwischen konkreten Klassen und Schnittstellen-Klassen (Interfaces, siehe dazu Abschnitt 1.9) angesehen werden (jedes Interface ist auch implizit abstrakt). Wird von einer Klasse gesprochen ist normalerweise eine konkrete Klasse gemeint, von der mit Hilfe des bekannten new-Operators ein Objekt erzeugt werden kann. Als abstrakte Klassen werden Klassen bezeichnet, von denen keine Objekte erzeugt werden können. Für abstrakte Klassen und abstrakte Methoden gelten die folgenden Aussagen:

Bei der Deklaration einer abstrakten Methode folgt ein Semikolon direkt im Anschluss an die schließende Klammer ")", welche die Paramterliste der Methode abschließt.

MethodenModifiers_opt abstract ReturnTyp MethodenName(FormaleParameterListe_opt);

Eine abstrakte Klasse/Methode wird durch das Schlüsselwort abstract gekennzeichnet. Das folgende kurze Listing deklariert eine abstrakte Klasse, die neben einer konkreten Methode eine abstrakte Methode enthält.

/* AbstractExample.java */

public abstract class AbstractExample {

  String str = "Hello";
  
  public abstract void method1();
  
  public void method2() {
    System.out.println(str + " concrete method");
  }
}

Im Folgenden sollen zwei konkrete Klassen diese abstrakte Klasse erweitern. Bei der Bildung von Klassenhierarchien ist es sinnvoll abstrakte Superklassen zu bilden, die die gemeinsame Struktur der Subklassen beschreibt bzw. festlegt.

Abbildung 1.3. Klassendiagramm: Die Klassen AbstractExampleA und AbstractExampleB sind Subklassen der abstrakten Klasse AbstractExample.

Im Klassendiagramm ist der Name der abstrakten Klasse kursiv geschrieben, um die abstrakte Klasse als solche zu kennzeichnen. Die beiden erbenden Klassen implementieren die abstrakte Methode auf unterschiedliche Weise:

/* AbstractExampleA.java */

public class AbstractExampleA extends AbstractExample {
  
  public void method1() {
    System.out.println(str + " AbstractExampleA");
  }  
}

/* AbstractExampleB.java */

public class AbstractExampleB extends AbstractExample {
  
  public void method1() {
    System.out.println(str + " AbstractExampleB");
  }  
}

Die konkreten Klassen, die die abstrakte Klasse erweitern, haben ihre eigene Version (Implementierung) der Methode method1. Eine von einer abstrakten Klasse abgeleiteten Klasse ist jedoch nicht verpflichtet, geerbte abstrakte Methoden zu implementieren. In diesem Fall muss aber auch die Subklasse als abstrakt gekennzeichnet werden. Das folgende kleine Testprogramm gibt einmal "Hello AbstractExampleA" und zweimal "Hello AbstractExampleB" auf dem Bildschirm aus:

/* Test.java */

public class Test {
  
  public static void main(String[] args) {
    AbstractExampleA a = new AbstractExampleA();
    AbstractExampleB b = new AbstractExampleB();
    AbstractExample c = new AbstractExampleB();
    a.method1();
    b.method1();
    c.method1();
  }  
}

Die Objektvariable c ist vom Typ der abstrakten Klasse AbstractExample. Die enstprechende Anweisung könnte auch in mehrere Anweisungen aufgesplittet werden:

AbstractExample c = new AbstractExampleB();

AbstractExample c;
AbstractExampleB c2 = new AbstractExampleB();
c = c2;

Dabei wird deutlich, dass c und c2 zuweisungskompatibel sind. Soll also von der konkreten Klasse AbstractExampleB ein Objekt erzeugt werden, so kann der Typ der zugehörigen Objektvariablen auch der Klassentyp der abstrakten Superklasse dieser konkreten Klasse sein.

Statische Methoden und statische Felder in abstrakten Klassen

Abstrakte Klassen können Klassenmethoden (statische Methoden) und Klassenvariablen (statische Variablen) enthalten. Derartige Mitglieder der abstrakten Klasse sind mit Hilfe einer Klassenreferenz (Punktnotation) direkt ansprechbar.

/* AbstractExample2.java */

public abstract class AbstractExample2 {

  static String str = "Hello";
  
  public static void method1() {
    System.out.println("Hello static method!");
  }
}

Der folgende kurze Quelltext greift auf die statische Variable der abstrakten Klasse AbstractExample2 zu. Mit Hilfe der Punktnotation erfolgt auch der Aufruf der statischen Methode, was zu einer entsprechenden Bildschirmausgabe führt.

/* Test.java */

public class Test {
  
  public static void main(String args[]) {
    String str = AbstractExample2.str;
    System.out.println(str);
    
    AbstractExample2.method1();
  }
}

Eine mit dem Modifier abstract deklarierte Methode kann nicht zusätlich noch mit static deklariert werden (illegale Kombination von Modifiern). Dadurch wird sinngemäß der Aufruf von Klassenmethoden verhindert, für die keine Implementierung vorhanden ist.