Create a new class Radio.

Provide the radio with the following instance variables:

What types of variables are useful? Make sure that the instance variables are not static!

Write an additional class Application, which creates a Radio object in its main(…​) method. Assign and access the variables for testing.

Add the following non-static methods:

In the main(…​) method of the Application class, the object methods of the radio can be tested like this, for example:

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();

Make all instance variables from Radio private.

Decide if the methods can be made public.

Are there any internal methods that should be private?

Implement a static method double stationNameToFrequency(String) in the class Radio that maps a station as a string to a frequency (for example, the well-known pirate radio station "Walking the Plank" has the frequency 98.3).

If null is passed to the method, then the result shall be 0.0. Furthermore, for unknown station names, the return should be 0.0.

In the main program, we can write:

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

Declare a new enumeration type Modulation with the values AM and FM in its own file.

Add a private instance variable Modulation modulation to Radio where the radio keeps the modulation.

Set the Modulation via a new Radio method void setModulation(Modulation modulation), a getter can also exist.

Customize the toString() method in Radio.

Longwave: 148.5 kHz to 283.5 kHz

Mediumwave: 526.5 kHz to 1606.5 kHz

Shortwave: shortwave broadcasting uses several bands between 3.2 MHz and 26.1 MHz.

Ultra-shortwave (FM): 87.5 MHz to 108 MHz.

Add two new private instance variables:

When calling setModulation(Modulation), the instance variables minFrequency and maxFrequency are to be set to their minimum and maximum value ranges, namely for AM 148.5 kHz to 26.1 MHz and for FM 87.5 MHz to 108 MHz.

Write a constructor for the class Radio so that you can initialize a radio with a frequency (double). But you should still be able to create radios with the parameterless constructor!

Alternatively, a Radio object should be able to be initialized with a station name (as String) (use stationNameToFrequency(..) internally for this). The station name is not stored, only the frequency.

How can we use the constructor delegation with this(…​)?

Implement a copy constructor for Radio.

Constructors exist in principle, but they are private, and consequently, outsiders cannot create instances.

So that objects can be built, there are static methods, which internally call the constructor and return the instance.

Create a new class TV.

The TV should get methods on()/off() which write short messages to the console (an instance variable is not necessary for the example for now).

Create a TV in the main(…​) method of Application.

Create a new class MonitorTube.

A TV shall reference a MonitorTube via a private instance variable. How can this be done in Java?

When the TV is switched on/off, the monitor tube should also be switched on/off.

Optional: How can we implement a bidirectional relationship? There might be a problem?

Declare a new static method in the class ElectronicDevice:

public static int numberOfElectronicDevicesSwitchedOn( ElectronicDevice... devices ) {
  // Returns the number of switched on devices,
  // that were passed to the method
}

If, for example, r1 and r2 are two radios that are turned on, and ice is an ice machine that is turned off, main(…​) may say, for example:

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

When a radio is passed to the load(…​) addition method, it should be checked if it has volume 0; in that case, it should not be included in the data structure.

When a radio is added, the console output should be: Remember to pay license fee!.

Given is an older class Toaster with an equals(…​) method for a test for equivalence:

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 );
  }
}

Rewrite the equals(…​) method to use instanceof with a pattern variable.

Implement a class Firebox for a fire detector as a subclass of ElectronicDevice.

Fire detectors should always be switched on after creation.

The off() method should be implemented with an empty body or with console output so that a fire detector cannot be turned off.

Task target: an overridden off() method that does not change the isOn state. This can be tested like this:

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

If we omit the two methods, the tube would not be turned off, but the TV would pass as an electrical device when inherited.

If we leave the methods in the class, only the tube will be turned off, but the device is no longer switched on or off. After all, this state was managed by the superclass via the on()/off() methods.

Fix the problem that a TV is an ElectronicDevice, but the monitor tube is turned on/off.

Implement a method holiday() in the ship class that turns off all the electrical devices in the list.

public void holiday() {
  // call off() for all elements in the data structure
}

The main(…​) method of Application may contain, for example:

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();

Copy the following class AsciiArt as a nested class into the class 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 = """
            ____
       ____|    \\
      (____|     `._____
       ____|       _|___
      (____|     .'
           |____/""";
}

Implement a new method printLoadingList() in Ship that implements the following rules:

Solve the task with the language feature Pattern Matching for switch.

Write a subclass of TimerTask that prints a message on the screen whenever the number of free bytes on the file system falls below a certain limit (e.g., less than 1000 MB).

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

The Timer should execute this TimerTask every 2 seconds.