Lege eine neue Klasse Radio an.

Gib dem Radio die folgenden Objektvariablen:

Welche Variablentypen sind sinnvoll? Achte darauf, dass die Objektvariablen nicht statisch sind!

Schreibe zusätzlich eine Klasse Application, die ein Radio-Objekt in ihrer main(…​)-Methode aufbaut. Belege und erfrage zum Test die Variablen.

Ergänze folgende nichtstatische Methoden:

In der main(…​)-Methode der Klasse Application können die Objektmethoden des Radios zum Beispiel so getestet werden:

Radio grandmasOldRadio = new Radio();
System.out.println( grandmasOldRadio.isOn() );     // false
grandmasOldRadio.on();
System.out.println( grandmasOldRadio.isOn() );     // true
System.out.println( grandmasOldRadio.volume );     // 0
grandmasOldRadio.volumeUp();
grandmasOldRadio.volumeUp();
grandmasOldRadio.volumeDown();
grandmasOldRadio.volumeUp();
System.out.println( grandmasOldRadio.volume );     // 2
System.out.println( grandmasOldRadio.toString() ); // Radio[volume=2, is on]
System.out.println( grandmasOldRadio );            // Radio[volume=2, is on]
grandmasOldRadio.off();

Mache alle Objektvariablen aus Radio privat.

Überlege, ob die Methoden public werden können.

Gibt es interne Methoden, die private sein sollten?

Implementiere in die Klasse Radio eine statische Methode double stationNameToFrequency(String), die einem Sender als Zeichenkette eine Frequenz zuordnet (zum Beispiel hat der bekannte Piratensender »Walking the Plank« die Frequenz 98.3).

Wird der Methode null übergeben, dann soll die Rückgabe 0.0 sein. Auch bei unbekannten Sendernamen soll die Rückgabe 0.0 sein.

Im Hauptprogramm können wir schreiben:

System.out.println( Radio.stationNameToFrequency( "Walking the Plank" ) ); // 98.3

Deklariere einen neuen Aufzählungstyp Modulation mit den Werten AM und FM als eigene Datei.

Füge in Radio eine private Objektvariable Modulation modulation ein, in der sich das Radio die Modulation merkt.

Setze die Modulation über eine neue Radio-Methode void setModulation(Modulation modulation) um, einen Getter kann es auch geben.

Passe die toString()-Methode in Radio an.

Langwelle: 148,5 kHz bis 283,5 kHz

Mittelwelle: 526,5 kHz bis 1606,5 kHz

Kurzwelle: Kurzwellenrundfunk nutzt mehrere Bänder zwischen 3,2 MHz und 26,1 MHz.

Ultrakurzwelle (UKW): 87,5 MHz bis 108 MHz

Füge zwei neue private Objektvariablen ein:

Beim Aufruf von setModulation(Modulation) sollen die Objektvariablen minFrequency und maxFrequency auf ihre minimalen und maximalen Wertebereiche gesetzt werden, nämlich für AM 148,5 kHz bis 26,1 MHz und für FM 87,5 MHz bis 108 MHz.

Schreibe einen Konstruktor für die Klasse Radio, sodass man ein Radio mit einer Frequenz (double) initialisieren kann. Man sollte Radios aber immer noch mit dem parameterlosen Konstruktor anlegen können!

Alternativ soll ein Radio-Objekt mit einem Sender (als String) initialisiert werden können (nutze dazu intern stationNameToFrequency(…​)). Der Sendername wird nicht gespeichert, nur die Frequenz.

Wie können wir die Konstruktorweiterschaltung mit this(…​) nutzen?

Implementiere für Radio einen Copy-Konstruktor.

Es gibt prinzipiell Konstruktoren, aber die sind privat, und folglich können Außenstehende keine Instanzen erzeugen.

Damit Objekte aufgebaut werden können, gibt es statische Methoden, die intern den Konstruktor aufrufen und die Instanz zurückgeben.

Lege eine neue Klasse TV an.

Das Fernsehgerät soll Methoden on()/off() bekommen, die kurze Meldungen auf die Konsole schreiben (eine Objektvariable ist für das Beispiel erst einmal nicht nötig).

Lege in der main(…​)-Methode von Application ein TV an.

Lege eine neue Klasse MonitorTube (Bildröhre) an.

Ein TV soll eine MonitorTube über eine private Objektvariable referenzieren. Wie kann das in Java Quellcode aussehen?

Wenn das Fernsehgerät ein-/ausgeschaltet wird, so soll auch die Bildröhre ein-/ausgeschaltet werden.

Optional: Wie können wir eine bidirektionale Beziehung implementieren? Wo könnte ein Problem lauern?

Setze in der Klasse ElectronicDevice eine statische Methode:

public static int numberOfElectronicDevicesSwitchedOn( ElectronicDevice... devices ) {
  // Liefert die Anzahl eingeschalteter Geräte zurück,
  // die der Methode übergeben wurden
}

Wenn etwa r1 und r2 zwei eingeschaltete Radios sind und ice eine ausgeschaltete Eismaschine, kann in main(…​) zum Beispiel stehen:

int switchedOn =
  ElectronicDevice.numberOfElectronicDevicesSwitchedOn( r1, ice, r2 );
System.out.println( switchedOn ); // 2

Wenn der Hinzufügemethode load(…​) ein Radio übergeben wird, dann soll geprüft werden, ob es die Lautstärke 0 hat; in dem Fall soll es nicht in die Datenstruktur aufgenommen werden.

Wenn ein Radio hinzugefügt wird, soll folgende Konsolenausgabe erfolgen: Remember to pay license fee!.

Gegeben ist die ältere Klasse Toaster mit einer equals(…​)-Methode für einen Test auf Gleichwertigkeit:

public class Toaster {
  int capacity;
  boolean stainless;
  boolean extraLarge;

  @Override public boolean equals( Object o ) {
    if ( !(o instanceof Toaster) ) return false;

    Toaster toaster = (Toaster) o;
    return    capacity == toaster.capacity
           && stainless == toaster.stainless && extraLarge == toaster.extraLarge;
  }

  @Override public int hashCode() {
    return Objects.hash( capacity, stainless, extraLarge );
  }
}

Schreibe die equals(…​)-Methode so um, dass instanceof mit einer Pattern-Variable verwendet wird.

Implementiere eine Klasse Firebox für einen Feuermelder als Unterklasse von ElectronicDevice.

Feuermelder sollen nach dem Erzeugen immer eingeschaltet sein.

Die Methode off() soll mit leerem Rumpf oder mit Konsolenausgabe implementiert werden, sodass sich ein Feuermelder nicht ausschalten lässt.

Ziel der Aufgabe: eine überschriebene off()-Methode, die den Zustand isOn nicht ändert. Das lässt sich so testen:

Firebox fb = new Firebox();
System.out.println( fb.isOn() );  // true
fb.off();
System.out.println( fb.isOn() );  // true

Wenn wir die beiden Methoden weglassen, würde die Röhre nicht ausgeschaltet werden, das Fernsehgerät aber bei Vererbung als Elektrogerät durchgehen.

Wenn wir die Methoden in der Klasse lassen, wird nur die Röhre ausgeschaltet, das Gerät wird aber nicht mehr ein- oder ausgeschaltet. Diesen Zustand verwaltete ja die Oberklasse über die Methoden on()/off().

Löse das Problem, dass ein TV ein ElectronicDevice ist, aber die Bildröhre ein-/ausgeschaltet wird.

Implementiere in der Ship-Klasse eine Methode holiday(), die alle Elektrogeräte der Liste ausschaltet.

public void holiday() {
  // rufe off() für alle Elemente in der Datenstruktur auf
}

In der main(…​)-Methode von Application kann zum Beispiel stehen:

Radio bedroomRadio = new Radio();
bedroomRadio.volumeUp();
Radio cabooseRadio = new Radio();
cabooseRadio.volumeUp();
TV mainTv = new TV();
Radio crRadio = new Radio();
Firebox alarm = new Firebox();
Ship ship = new Ship();
ship.load( bedroomRadio );
ship.load( cabooseRadio );
ship.load( mainTv );
ship.load( crRadio );
ship.load( alarm );
ship.holiday();

Kopiere die folgende Klasse AsciiArt als geschachtelte Klasse in die Klasse Ship:

public static class AsciiArt {
  public static final String RADIO = " .-.\n|o.o|\n|:_:|";
  public static final String BIG_TV = """
      .---..--------------------------------------..---.
      |   ||.------------------------------------.||   |
      |.-.|||                                    |||.-.|
      | o |||                                    ||| o |
      |`-'|||                                    |||`-'|
      |.-.|||                                    |||.-.|
      | O |||                                    ||| O |
      |`-'||`------------------------------------'||`-'|
      `---'`--------------------------------------'`---'
             _||_                            _||_
            /____\\                          /____\\""";
  public static final String TV = " \\  /\n _\\/_\n|    |\n|____|";
  public static final String SOCKET = """
            ____
       ____|    \\
      (____|     `._____
       ____|       _|___
      (____|     .'
           |____/""";
}

Implementiere in Ship eine neue Methode loadingList(), die folgende Regeln umsetzt:

Löse die Aufgabe mit dem Sprachfeature Pattern Matching for switch.

Schreibe eine Unterklasse von TimerTask, die immer dann eine Meldung auf dem Bildschirm ausgibt, wenn die Anzahl freier Bytes auf dem Dateisystem unter eine gewisse Grenze fällt (z. B. weniger als 1000 MB).

long freeDiskSpace = java.io.File.listRoots()[0].getFreeSpace();

Der Timer soll diesen TimerTask alle 2 Sekunden ausführen.