Programmieren mit Java: Zusammenfassung – Informatik Klasse 9

Von Python zu Java

Abschnitt 1.1: Java wird vorab übersetzt, jede Variable hat einen festen Typ, Blöcke stehen in geschweiften Klammern.

Übersetzen und ausführen

javac übersetzt die ganze Datei vorab in Bytecode (.class).
Die JVM führt den Bytecode aus — auf jedem Betriebssystem.
Dateiname = Klassenname, main ist der Startpunkt.
Compilerfehler: nichts startet. Laufzeitfehler: Abbruch während des Laufs.

Rakete.java → javac → Rakete.class → java Rakete

Statische Datentypen

Typ steht fest und wird vor dem Start geprüft.
int, double, boolean, char ('B'), String ("Luna").
int / int schneidet ab, % liefert den Rest.
(int) 3.9 → 3; final macht eine Konstante.

int stufen = 3;
double tank = 72.5;
int a = 7 / 2;       // 3
int r = 7 % 2;       // 1
double d = 7.0 / 2;  // 3.5

Verzweigungen und Schleifen

Bedingung in ( ), Block in { }.
&& und, || oder, ! nicht.
Texte mit .equals(…) vergleichen.
for: Start; Bedingung; Schritt.

// Python: for i in range(2, 10, 3):
for (int i = 2; i < 10; i += 3) {
    System.out.print(i + " ");
}
// 2 5 8

Methoden

Parameter immer mit Typ.
Rückgabetyp vor dem Namen, void = keine Rückgabe.
return beendet die Methode sofort.
Lokale Variablen gibt es nur in ihrer Methode.

public static double mittel(double a, double b) {
    return (a + b) / 2;
}
// mittel(3, 4) liefert 3.5

Das Grundgerüst jedes Programms

public class Name { public static void main(String[] args) { … } }

Jede Anweisung endet mit ;. Groß- und Kleinschreibung zählt: System.out.println, nicht system.out.println. println macht danach einen Zeilenumbruch, print nicht.

Objektorientiert denken

Abschnitt 1.2: Eine Klasse ist der Bauplan, Objekte sind Exemplare mit eigenen Werten.

Klassen und Objekte

Klasse: Attribute (was es weiß) + Methoden (was es kann).
new erzeugt ein Objekt und ruft den Konstruktor auf.
Die Variable verweist auf das Objekt.
Methodenaufruf mit Punkt: ändert nur dieses Objekt.

Fahrstuhl f = new Fahrstuhl(12);
f.setStockwerk(7);
int s = f.getStockwerk();   // 7

Klassendiagramm

Drei Fächer: Name · Attribute · Konstruktor und Methoden.
- privat, + öffentlich, c Konstruktor.
Typ nach dem Doppelpunkt, deutsch: Ganzzahl, Fließkommazahl, Wahrheitswert, Zeichen, Zeichenkette.

Fahrstuhl

- stockwerk: Ganzzahl
- hoechstes: Ganzzahl

c Fahrstuhl(hoechstes: Ganzzahl)
+ getStockwerk(): Ganzzahl
+ setStockwerk(s: Ganzzahl)

Attribute und Konstruktor

Attribute stehen in der Klasse, außerhalb der Methoden.
Standardwerte: 0, 0.0, false, null.
Konstruktor: Name der Klasse, kein Rückgabetyp.
this.x = Attribut, x = Parameter.
Eigener Konstruktor da → kein Standardkonstruktor mehr.

public Fahrstuhl(int hoechstes) {
    this.hoechstes = hoechstes;
    stockwerk = 0;
}

Kapselung mit get und set

Attribute private, Zugriff über Methoden.
Getter getX() (bei boolean: istX()) liefert den Wert.
Setter setX(…) ist void und weist ungültige Werte ab.
Kein Setter → nur lesbar.

public void setStockwerk(int stockwerk) {
    if (stockwerk >= 0 && stockwerk <= hoechstes) {
        this.stockwerk = stockwerk;
    }
}

Vom Diagramm zum Java-Code

- → private · + → public · Typ nach vorn

- stockwerk: Ganzzahl wird private int stockwerk;, + getStockwerk(): Ganzzahl wird public int getStockwerk(), + setStockwerk(s: Ganzzahl) wird public void setStockwerk(int s). Nur der Konstruktor hat gar keinen Rückgabetyp.

Mit Objekten arbeiten

Abschnitt 1.3: Viele Werte in Arrays und Listen, gemeinsame Teile per Vererbung, ein kleines Projekt Schritt für Schritt.

Arrays

Feste Länge, gleicher Typ für alle Plätze.
Indizes 0 bis length − 1.
Zu großer Index → ArrayIndexOutOfBoundsException.

int[] tore = {2, 0, 3, 1, 4};
int summe = 0;
for (int i = 0; i < tore.length; i++) {
    summe = summe + tore[i];
}
// summe = 10

ArrayList

import java.util.ArrayList;
Wächst und schrumpft: add, get, set, remove, size().
Für Zahlen Integer statt int.
Durchlauf mit for-each.

ArrayList<String> gaeste = new ArrayList<>();
gaeste.add("Ida");
gaeste.add("Noah");
gaeste.remove(0);
for (String g : gaeste) {
    System.out.println(g);   // Noah
}

Vererbung

extends: Unterklasse „ist ein“ Oberklasse und erbt Attribute und Methoden.
super(…) als erste Zeile im Konstruktor.
@Override: gleiche Signatur, eigene Umsetzung.
Private Attribute der Oberklasse nur über Getter.

public class Trommel extends Instrument {
    private int groesse;

    public Trommel(String name, int groesse) {
        super(name);
        this.groesse = groesse;
    }

    @Override
    public String klang() {
        return "Bumm";
    }
}

Projekt: Verwaltung

Planen: Klassendiagramm mit zwei Klassen und Assoziation.
Liste als Attribut: - rezepte: Liste vom Typ Rezept.
Suche: for-each, equals, return null erst nach der Schleife.
Nach jedem Schritt testen.

Lineare Suche bei n Einträgen: höchstens n Vergleiche, im Mittel (n + 1) / 2

Array oder ArrayList?

tore.length · gaeste.size()

Array: feste Länge, Zugriff mit tore[i], auch für int. ArrayList: variable Länge, Zugriff mit gaeste.get(i), Typ in spitzen Klammern — bei Zahlen ArrayList<Integer>.

Die Regeln, an denen die Punkte hängen

Die meisten Punkte gehen nicht durch schwere Aufgaben verloren, sondern durch kleine, immer gleiche Ungenauigkeiten.

Regel 1 — Typen ernst nehmen

Vor jede Variable und jeden Parameter gehört ein Typ. int / int rechnet ganzzahlig, eine Kommazahl passt nicht in int, und eine Methode mit Rückgabetyp braucht auf jedem Weg ein return.

Regel 2 — Klasse sauber bauen

Attribute private, Konstruktor ohne Rückgabetyp mit this., Setter mit Prüfung. Objekte immer mit new. Im Diagramm deutsche Typen hinten, in Java englische Typen vorn.

Regel 3 — Grenzen prüfen

Schleifen über Arrays mit i < length, Texte mit equals. Bei der Suche erst nach der Schleife return null, in der Unterklasse zuerst super(…).

1AFB I — Reproduzieren10 Aufgaben› ?Selbsttest40 Fragen mit Auswertung›