Enumerations

Enumerations sind eine spezielle Art von Datentypen in Java, die es ermöglichen, eine Gruppe von konstanten Werten zu definieren. Sie sind besonders nützlich, wenn Sie eine feste Menge von Werten haben, die sich nicht ändern sollen. In Java werden Enumerationen mit dem Schlüsselwort enum definiert.

1. Aufzählungstypen Studenten

Für die Studiengänge an der HNU sollen für unseren Kontext die folgenden Regelstudienzeiten gelten:

• DSM: 8 Semester

• DEM: 7 Semester

• Wirtschaftsinformatik: 6 Semester

• Systems Engineering: 5 Semester

• Betriebswirtschaft: 4 Semester

Wichtig

🚩 Bilden Sie diesen Sachverhalt durch einen Aufzählungstyp im Code ab.

Erstellen Sie eine Klasse Student mit den Attributen Name, Vorname, Matrikelnummer und Studiengang. Erstellen Sie weiterhin ein Testprogramm, darin 10 Objekte vom Typ Student, speichern diese in ein Array und geben die Inhalte des Arrays aus. Verwenden Sie für die Ausgabe eine entsprechende toString() -Methode der Klasse Student.

Lösung anzeigen

Studiengang.java

// Enum for available degree programs and their standard study duration.
public enum Studiengang {
    DSM(8),
    DEM(7),
    WIRTSCHAFTSINFORMATIK(6),
    SYSTEMS_ENGINEERING(5),
    BETRIEBSWIRTSCHAFT(4);

    // Number of semesters in the regular study plan.
    private final int regelstudienzeit;

    // Stores the duration for each enum value.
    Studiengang(int regelstudienzeit) {
        this.regelstudienzeit = regelstudienzeit;
    }

    // Returns the regular study duration in semesters.
    public int getRegelstudienzeit() {
        return regelstudienzeit;
    }
}

Student.java

// Represents one student with personal data and degree program.
public class Student {
    // Last name of the student.
    private String name;
    // First name of the student.
    private String vorname;
    // Unique student ID number.
    private int matrikelnummer;
    // Degree program the student is enrolled in.
    private Studiengang studiengang;

    // Creates a student with all required values.
    public Student(String name, String vorname, int matrikelnummer, Studiengang studiengang) {
        this.name = name;
        this.vorname = vorname;
        this.matrikelnummer = matrikelnummer;
        this.studiengang = studiengang;
    }

    // Returns a readable text output for printing student info.
    @Override
    public String toString() {
        return vorname + " " + name
                + " (Mat.-Nr.: " + matrikelnummer + ")"
                + " – " + studiengang
                + " (Regelstudienzeit: " + studiengang.getRegelstudienzeit() + " Semester)";
    }
}

StudentTest.java

// Simple test class to create and print sample students.
public class StudentTest {
    // Program entry point.
    public static void main(String[] args) {
        // Array with example students from different degree programs.
        Student[] studenten = {
                new Student("Müller",    "Anna",      10001, Studiengang.DSM),
                new Student("Schmidt",   "Ben",       10002, Studiengang.DEM),
                new Student("Weber",     "Clara",     10003, Studiengang.WIRTSCHAFTSINFORMATIK),
                new Student("Fischer",   "David",     10004, Studiengang.SYSTEMS_ENGINEERING),
                new Student("Wagner",    "Elena",     10005, Studiengang.BETRIEBSWIRTSCHAFT),
                new Student("Becker",    "Fabian",    10006, Studiengang.DSM),
                new Student("Hoffmann",  "Greta",     10007, Studiengang.DEM),
                new Student("Koch",      "Hannah",    10008, Studiengang.WIRTSCHAFTSINFORMATIK),
                new Student("Richter",   "Jonas",     10009, Studiengang.SYSTEMS_ENGINEERING),
                new Student("Klein",     "Katharina", 10010, Studiengang.BETRIEBSWIRTSCHAFT)
        };

        // Print each student using Student.toString().
        for (Student s : studenten) {
            System.out.println(s);
        }
    }
}

2. Waschmaschine

Erstellen Sie eine Klasse WashingMachine, mit der die grundlegenden Funktionen einer Waschmaschine simuliert werden. Verwenden Sie dazu drei Enums: State, Program und Temperature.

Anforderungen:

1. Zustand der Waschmaschine

Erstellen Sie ein enum State mit den Zuständen:

OFF, READY, RUNNING

Die Waschmaschine startet im Zustand OFF und soll in einem Attribut currentState ihren aktuellen Zustand speichern.

2. Waschprogramme

Erstellen Sie ein enum Program mit mindestens drei Programmen, zum Beispiel:

QUICK_WASH, NORMAL, DELICATE

Die Programme benötigen keine zusätzlichen Attribute.

3. Temperaturstufen

Erstellen Sie ein enum Temperature mit festen Temperaturwerten:

Zum Beispiel COLD (20°C), WARM (40°C), HOT (60°C)

Speichern Sie den Temperaturwert mithilfe eines Konstruktors im Enum.

4. Methoden in der Klasse WashingMachine

Implementieren Sie folgende Methoden:

• powerOn()

  Schaltet die Waschmaschine von OFF in den Zustand READY Gibt eine passende Meldung in der Konsole aus.

• selectProgram(Program program)

  Kann nur im Zustand READY aufgerufen werden Speichert das gewählte Programm und gibt es auf der Konsole aus

• setTemperature(Temperature temperature)

  Kann nur im Zustand READY aufgerufen werden Speichert die gewählte Temperatur und gibt sie auf der Konsole aus

• start()

  Kann nur aufgerufen werden, wenn sich die Maschine im Zustand READY befindet und sowohl ein Programm als auch eine Temperatur gewählt wurden. Gibt die gewählten Einstellungen aus, simuliert den Waschvorgang und setzt die Maschine anschließend wieder auf OFF.

Wichtig

🚩 Erstellen Sie ein Hauptprogramm, in dem: Die Waschmaschine eingeschaltet wird, ein Programm und eine Temperatur gewählt werden und der Waschvorgang gestartet wird.

Lösung anzeigen

State.java

// Describes the current operating state of the washing machine.
public enum State {
    // Machine is switched off.
    OFF,
    // Machine is on and waiting for settings.
    READY,
    // Machine is currently washing.
    RUNNING
}

Program.java

// Available wash programs.
public enum Program {
    // Short cycle for lightly dirty laundry.
    QUICK_WASH,
    // Standard everyday wash cycle.
    NORMAL,
    // Gentle cycle for sensitive fabrics.
    DELICATE
}

Temperature.java

// Available wash temperatures in degrees Celsius.
public enum Temperature {
    // Cold wash.
    COLD(20),
    // Warm wash.
    WARM(40),
    // Hot wash.
    HOT(60);

    // Numeric temperature value.
    private final int degrees;

    // Stores the degree value for each enum entry.
    Temperature(int degrees) {
        this.degrees = degrees;
    }

    // Returns the temperature in °C.
    public int getDegrees() {
        return degrees;
    }
}

WashingMachine.java

// Simulates a simple washing machine workflow.
public class WashingMachine {
    // Current machine state (OFF, READY, RUNNING).
    private State currentState;
    // Program chosen by the user.
    private Program selectedProgram;
    // Temperature chosen by the user.
    private Temperature selectedTemperature;

    // Creates a new machine that starts in OFF state.
    public WashingMachine() {
        this.currentState = State.OFF;
    }

    // Turns the machine on so settings can be selected.
    public void powerOn() {
        if (currentState == State.OFF) {
            currentState = State.READY;
            System.out.println("Waschmaschine wurde eingeschaltet. Zustand: " + currentState);
        } else {
            System.out.println("Waschmaschine ist bereits eingeschaltet.");
        }
    }

    // Selects the wash program (only possible in READY state).
    public void selectProgram(Program program) {
        if (currentState != State.READY) {
            System.out.println("Fehler: Programm kann nur im Zustand READY gewählt werden.");
            return;
        }
        this.selectedProgram = program;
        System.out.println("Programm gewählt: " + program);
    }

    // Selects the temperature (only possible in READY state).
    public void setTemperature(Temperature temperature) {
        if (currentState != State.READY) {
            System.out.println("Fehler: Temperatur kann nur im Zustand READY eingestellt werden.");
            return;
        }
        this.selectedTemperature = temperature;
        System.out.println("Temperatur eingestellt: " + temperature + " (" + temperature.getDegrees() + "°C)");
    }

    // Starts the wash cycle if all required settings are present.
    public void start() {
        if (currentState != State.READY) {
            System.out.println("Fehler: Waschmaschine ist nicht bereit.");
            return;
        }
        if (selectedProgram == null || selectedTemperature == null) {
            System.out.println("Fehler: Bitte zuerst Programm und Temperatur wählen.");
            return;
        }

        currentState = State.RUNNING;
        System.out.println("\n--- Waschvorgang gestartet ---");
        System.out.println("Programm:    " + selectedProgram);
        System.out.println("Temperatur:  " + selectedTemperature + " (" + selectedTemperature.getDegrees() + "°C)");
        System.out.println("Zustand:     " + currentState);

        // Waschvorgang simulieren
        System.out.println("Wäsche wird gewaschen...");
        System.out.println("--- Waschvorgang beendet ---\n");

        // Zurücksetzen
        currentState = State.OFF;
        selectedProgram = null;
        selectedTemperature = null;
        System.out.println("Waschmaschine wurde ausgeschaltet. Zustand: " + currentState);
    }
}

WashingMachineTest.java

// Test class that demonstrates normal and invalid usage flows.
public class WashingMachineTest {
    // Program entry point.
    public static void main(String[] args) {
        // Create one washing machine instance for the demo.
        WashingMachine waschmaschine = new WashingMachine();

        // Normaler Ablauf
        waschmaschine.powerOn();
        waschmaschine.selectProgram(Program.NORMAL);
        waschmaschine.setTemperature(Temperature.WARM);
        waschmaschine.start();

        System.out.println("========================================\n");

        // Zweiter Durchlauf mit anderem Programm
        waschmaschine.powerOn();
        waschmaschine.selectProgram(Program.DELICATE);
        waschmaschine.setTemperature(Temperature.COLD);
        waschmaschine.start();

        System.out.println("========================================\n");

        // Fehlerfälle testen
        System.out.println("--- Fehlerfälle ---");
        waschmaschine.selectProgram(Program.QUICK_WASH);   // Fehler: noch OFF
        waschmaschine.start();                              // Fehler: noch OFF

        waschmaschine.powerOn();
        waschmaschine.start();                              // Fehler: kein Programm/Temperatur
    }
}