Referenz

public static final int MAX_GROESSE = 100;

public abstract class Form {
 
    protected String bezeichnung;
 
    public Form(String pBezeichnung) {
        bezeichnung = pBezeichnung;
    }
 
    /** Muss von jeder konkreten Unterklasse festgelegt werden. */
    public abstract double flaeche();
 
    /** Kann von allen Unterklassen unverändert benutzt werden. */
    public String beschreibung() {
        return bezeichnung + " mit Fläche " + flaeche();
    }
}

public interface Bezahlbar {
    double betrag();
    String bezeichnung();
}
 
public class Angestellter extends Mitarbeiter implements Bezahlbar {
    ...
}

Konto k = new Girokonto("Alan", 500.0);
k.hebeAb(400.0);        // die Fassung aus Girokonto greift
// k.getDispolimit();   // Fehler: Konto kennt diese Methode nicht

int[][] gitter = new int[3][4];   // 3 Zeilen, 4 Spalten
gitter[1][2] = 7;                 // erst Zeile, dann Spalte
gitter.length                     // Anzahl der Zeilen
gitter[0].length                  // Anzahl der Spalten in Zeile 0
 
for (int z = 0; z < gitter.length; z++) {
    for (int s = 0; s < gitter[z].length; s++) {
        ...
    }
}

public class Behaelter<T> {
 
    private T[] inhalt;
 
    public Behaelter(int pMax) {
        inhalt = new T[pMax];
    }
 
    public T gib(int pI) {
        return inhalt[pI];
    }
}
 
Behaelter<String> b = new Behaelter<String>(5);

int fakultaet(int pN) {
    if (pN <= 1) {       // Basisfall
        return 1;
    }
    return pN * fakultaet(pN - 1);   // Rekursionsschritt
}

boolean loese(Zustand):
    wenn Lösung:   gib true zurück
    wenn ungültig: gib false zurück
    für jede Entscheidung:
        treffe sie
        wenn loese(neuer Zustand): gib true zurück
        nimm sie zurück
    gib false zurück

List<ContentType>

Stack<ContentType>

Queue<ContentType>

BinaryTree<ContentType>

BinarySearchTree<ContentType extends ComparableContent<ContentType>>

public interface ComparableContent<ContentType> {
    boolean isGreater(ContentType pContent);
    boolean isLess(ContentType pContent);
    boolean isEqual(ContentType pContent);
}

@Test
class RechnerTest {
 
    @Test
    void testMaximum() {
        Rechner r = new Rechner();
        assertEquals(9, r.maximum(3, 9), "maximum(3, 9) muss 9 sein.");
        assertTrue(r.istGerade(4), "4 ist gerade.");
        assertFalse(r.istGerade(5), "5 ist ungerade.");
    }
}

public class Zaehler implements Runnable {
    public void run() { ... }
}
 
Thread t = new Thread(new Zaehler());
t.start();      // nicht run() aufrufen!

private Semaphore schloss = new Semaphore(1);
 
public void zahleEin() {
    schloss.acquire();
    stand = stand + 1;      // kritischer Abschnitt
    schloss.release();
}