Java-Grundlagen und objektorientierte Programmierung

int i = 5;
int a = i++;   // a = 5, danach i = 6
int b = ++i;   // i wird zuerst auf 7 erhöht, b = 7

public static int quadrat(int zahl) {
    return zahl * zahl;
}

Drei überladene Methoden: unterschiedliche Signaturen trotz gleichen Namens

static int summe(int a, int b) { return a + b; }
static double summe(double a, double b) { return a + b; }
static int summe(int a, int b, int c) { return a + b + c; }

static int fakultaet(int n) {
    if (n == 0) {          // Basisfall
        return 1;
    }
    return n * fakultaet(n - 1);  // Rekursionsschritt
}

Allgemeines Backtracking-Schema: probieren, rekursiv weitermachen, bei Bedarf zurücknehmen

static boolean platziere(int[] belegung, int position) {
    if (position == belegung.length) {
        return true;              // Basisfall: alle Positionen belegt
    }
    for (int wert = 1; wert <= belegung.length; wert++) {
        if (istErlaubt(belegung, position, wert)) {
            belegung[position] = wert;
            if (platziere(belegung, position + 1)) {
                return true;
            }
            belegung[position] = 0;    // zurückverfolgen
        }
    }
    return false;                  // keine gültige Belegung an dieser Stelle
}

int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
int wert = matrix[2][1];   // Zeile 2, Spalte 1 -> 10

int[] original = {1, 2, 3};
int[] referenz = original;      // zeigt auf dasselbe Array
int[] kopie = Arrays.copyOf(original, original.length);

referenz[0] = 99;
System.out.println(original[0]); // 99
System.out.println(kopie[0]);    // 1

String a = "Hallo";
String b = "Hallo";
String c = new String("Hallo");

System.out.println(a == b);       // true (beide aus dem String-Pool)
System.out.println(a == c);       // false (c ist ein neues Objekt)
System.out.println(a.equals(c));  // true (gleicher Inhalt)

Klasse Fahrrad mit zwei Attributen und einer Methode

public class Fahrrad {
    private int gang;
    private double geschwindigkeit;

    public void schalte(int neuerGang) {
        this.gang = neuerGang;
    }
}

public class Lagerplatz {
    private int bestand;
    private static int anzahlLagerplaetze = 0;

    public Lagerplatz() {
        anzahlLagerplaetze++;
    }
}

public class Punkt {
    private double x;
    private double y;

    public Punkt() {
        this(0, 0);        // ruft den anderen Konstruktor auf
    }

    public Punkt(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

public class Lagerplatz {
    private int bestand;

    public void setBestand(int bestand) {
        if (bestand >= 0) {
            this.bestand = bestand;
        }
    }

    public int getBestand() {
        return bestand;
    }
}

public class Fahrzeug {
    protected int hoechstgeschwindigkeit;

    public Fahrzeug(int hoechstgeschwindigkeit) {
        this.hoechstgeschwindigkeit = hoechstgeschwindigkeit;
    }
}

public class Rennwagen extends Fahrzeug {
    private boolean spoiler;

    public Rennwagen(int hoechstgeschwindigkeit, boolean spoiler) {
        super(hoechstgeschwindigkeit);
        this.spoiler = spoiler;
    }
}

public class Fahrzeug {
    public String gibLaut() {
        return "...";
    }
}

public class Motorrad extends Fahrzeug {
    @Override
    public String gibLaut() {
        return "Vroom";
    }
}

Fahrzeug[] flotte = { new Motorrad(), new Rennwagen(280, false) };
for (Fahrzeug f : flotte) {
    System.out.println(f.gibLaut());
}

public abstract class Form {
    public abstract double flaecheninhalt();
}

public interface Zeichenbar {
    void zeichne();
}

public class Kreis extends Form implements Zeichenbar {
    private double radius;

    public double flaecheninhalt() {
        return Math.PI * radius * radius;
    }

    public void zeichne() { /* ... */ }
}

Integer a = 100;
Integer b = 100;
Integer c = 200;
Integer d = 200;

System.out.println(a == b);  // true (Integer-Cache)
System.out.println(c == d);  // false (außerhalb des Caches)

try {
    int ergebnis = 10 / divisor;
    System.out.println(ergebnis);
} catch (ArithmeticException e) {
    System.out.println("Division durch 0 nicht erlaubt");
} finally {
    System.out.println("Berechnung abgeschlossen");
}

public class NichtGenugBestandException extends RuntimeException {
    public NichtGenugBestandException(String nachricht) {
        super(nachricht);
    }
}

Knoten einer einfach verketteten Liste

public class Knoten {
    int wert;
    Knoten naechster;

    public Knoten(int wert) {
        this.wert = wert;
    }
}

Binärbaum-Knoten und rekursive Inorder-Traversierung

public class Knoten {
    int wert;
    Knoten links;
    Knoten rechts;

    public Knoten(int wert) {
        this.wert = wert;
    }
}

static void inorder(Knoten k) {
    if (k == null) return;
    inorder(k.links);
    System.out.println(k.wert);
    inorder(k.rechts);
}