Lernmaterialien

Object Array

Ohne Array

Die School Klasse ohne Verwendung von Arrays.

public class School {
    private String name;
    private Student student0;
    private Student student1;
    private Student student2;

Die Temperatur Klasse mit Array aber ohne Objektreferenzen.

public class Temperatur {
    private double[] temp;
    private int anzahl;

Mit Array

Eigenschaften

Wir kombinieren beide Klassen.

public class School {
    private String name;
    private Student[] students;
    private int anzahl;

• private Student[] students;
  → Die Schule speichert mehrere Studenten in einem Array.
  Student[] bedeutet: ein Feld mit Objekten vom Typ Student.

• private int anzahl;
  → Hier wird die Anzahl der aktuell gespeicherten Schüler/Studenten abgelegt.

Konstruktor

    public School(String name) {
        setName(name);
        students = new Student[3];
        anzahl = 0;
    }

Das ist der Konstruktor der Klasse School.

Er macht beim Erzeugen einer neuen Schule Folgendes:

• übernimmt den übergebenen Namen

• setzt den Namen mit setName(name)

• legt ein Studenten-Array mit 3 Plätzen an

• setzt anzahl auf 0, also sind anfangs noch keine Studenten eingetragen

Methoden

    public int anzahlStudent() {
        return anzahl;
    }

Die Methode gibt die aktuelle Anzahl der Studenten zurück.

return anzahl; bedeutet: Der Wert der Variable anzahl (das sind die gültigen Objektreferenzen) wird zurückgegeben.

    public void aufnehmen(Student wer) {
        if (wer != null) {
            if (wer.getSchool() == null) {
                if (anzahl < students.length) {
                    wer.setSchool(this);
                    students[anzahl] = wer;
                    anzahl++;
                }
                else {
                    System.out.println("Fehler: kein Platz!");
                }
            }
            else {
                System.out.println("Fehler: schon in einer Schule!");
            }
        }
        else {
            System.out.println("Fehler: kein Student!");
        }
    }

Die Methode aufnehmen(Student wer) fügt einen Studenten in die Schule ein.

Sie prüft dabei Schritt für Schritt:

• wer != null
  Es wird geprüft, ob überhaupt ein Student übergeben wurde.
  Sonst: "Fehler: kein Student!"

• wer.getSchool() == null
  Es wird geprüft, ob der Student noch keiner Schule zugeordnet ist.
  Sonst: "Fehler: schon in einer Schule!"

• anzahl < students.length
  Es wird geprüft, ob im Array noch Platz ist.
  Sonst: "Fehler: kein Platz!"

Wenn alles in Ordnung ist:

• wer.setSchool(this);
  → Der Student wird dieser Schule zugeordnet.

• students[anzahl] = wer;
  → Der Student wird im Array gespeichert.

• anzahl++;
  → Die Anzahl der Studenten wird um 1 erhöht.

    public int jungsterStudent() {
        int min;

        min = 999;
        for (int i=0; i<anzahl; i++) {
            if (students[i].getAlter() < min) {
                min = students[i].getAlter();
            }
        }
        if (min == 999) {
            System.out.println("Fehler: kein Student!");
        }
        return min;
    }

Die Methode sucht das kleinste Alter aller aufgenommenen Studenten.

Ablauf:

• min = 999;
  → Startwert für das bisher kleinste Alter - sehr hoher Wert

• for (int i=0; i<anzahl; i++)
  → alle vorhandenen Studenten werden durchlaufen

• if (students[i].getAlter() < min)
  → wenn ein Student jünger ist als der bisher jüngste,
  wird min auf dieses Alter gesetzt

• if (min == 999)
  → Falls gar kein Student vorhanden war, bleibt min unverändert
  und es wird "Fehler: kein Student!" ausgegeben

• return min;
  → gibt das kleinste gefundene Alter zurück

    public Student jungsterStudent2() {
        int min;
        Student minStudent;

        min = 999;
        minStudent = null;
        for (int i=0; i<anzahl; i++) {
            if (students[i].getAlter() < min) {
                min = students[i].getAlter();
                minStudent = students[i];
            }
        }
        return minStudent;
    }

int min;

• Hier wird das bisher kleinste gefundene Alter gespeichert.

Student minStudent;

• Hier wird der Student gespeichert, der dieses kleinste Alter hat.

min = 999;

• Startwert für das minimale Alter.

• Die Idee: Jedes echte Studentenalter ist kleiner als 999, also wird der erste Student sicher übernommen.

minStudent = null;

• Anfangs gibt es noch keinen jüngsten Studenten.

• null bedeutet: noch kein Objekt gespeichert.

for (int i=0; i<anzahl; i++)

• Schleife über alle Studenten von Index 0 bis anzahl - 1.

if (students[i].getAlter() < min)

• Prüft: Ist das Alter des aktuellen Studenten kleiner als das bisher kleinste Alter?