Core Java - OOPs - Polymorphism and Interfaces - The Universal Remote: Controlling Devices with Java Interfaces

[akash-coded]

We're going to build a simple "Universal Remote" system. It's a bit like your example, but instead of a Parent class, we'll use an interface to define what our controllable devices can do. This will help you see how different, unrelated classes can be treated uniformly, a concept vital for understanding collections of diverse objects and dependency injection.

Our Mission: To create a system where a single "universal remote" can control different electronic devices, not because they inherit from a common "Device" parent class, but because they all agree to a common Controllable contract (our interface).

The Analogy: The "Universal Remote Control"

Imagine you have a universal remote. It can control your TV, your streaming box, maybe even your smart lights. These devices are made by different manufacturers and have totally different internal workings. The remote works because these devices, despite their differences, have all agreed to respond to certain standard signals or commands (like "power on", "power off"). Our interface will be like that set of standard commands.

Ready to design this? Let's start with the contract!

---

The Universal Remote: Controlling Devices with Java Interfaces

Deliverable: A single Java file named HomeAutomation.java.

---

Step 1: Defining the Contract - The Controllable Interface

An interface defines a set of methods that any class can promise to implement. It's all about the behavior.

Your Task (Puzzle 1):

1. Inside your HomeAutomation.java file, define an interface named Controllable.
2. Interface Methods (The Contract):
   • void powerOn(); (A command to turn the device on)
   • void powerOff(); (A command to turn the device off)
   • String getStatus(); (A way to ask the device for its current status)
   • Think & Discuss: Notice these methods have no body (no {}). Why? (Answer: Interfaces only declare what methods must exist; the how is up to the classes that implement the interface).
3. Javadoc Comments: Add Javadoc comments to the interface and its methods. Yes, interfaces get Javadoc too! It explains the contract.

// HomeAutomation.java
import java.util.ArrayList;
import java.util.List;

/**
 * Defines a contract for devices that can be controlled.
 * Any class implementing this interface promises to provide these control methods.
 *
 * @author // Your Name Here
 * @version 1.0
 */
interface Controllable {
    /**
     * Turns the device on.
     * The specific actions taken depend on the implementing class.
     */
    void powerOn();

    /**
     * Turns the device off.
     * The specific actions taken depend on the implementing class.
     */
    void powerOff();

    /**
     * Gets the current status of the device.
     * @return A string describing the current status.
     */
    String getStatus();
}

// TODO: Steps 2, 3, 4 will go here in the same file

Tutor's Insight: This Controllable interface is our "standard set of buttons" for the universal remote. Any device, no matter how different, if it wants to be controlled by our remote, must provide these functionalities.

---

Step 2: Building the Devices - Implementing the Controllable Interface

Now, let's create a couple of different electronic devices. They don't need to be related by inheritance to each other, but they will both agree to our Controllable contract.

Your Task (Puzzle 2):

1. SmartTV Class:

   • Create a class SmartTV that implements Controllable.
   • Data Members (Specific to SmartTV):
     • private boolean isOn;
     • private int currentChannel;
     • private int volume;
   • Constructor: public SmartTV(String brand)
     • Initialize isOn to false, currentChannel to 1, volume to 10.
     • Print a message like: System.out.println(brand + " SmartTV initialized.");
   • Implement Controllable methods (with @Override):
     • powerOn(): Sets isOn to true, sets currentChannel to 1, and prints "SmartTV is now ON. Channel: 1".
     • powerOff(): Sets isOn to false and prints "SmartTV is now OFF.".
     • getStatus(): Returns a string like "SmartTV Status: [ON/OFF], Channel: [currentChannel], Volume: [volume]".
   • Add specific SmartTV methods:
     • public void changeChannel(int newChannel): If isOn, changes currentChannel and prints the change. Else, prints "TV is off."
     • public void adjustVolume(int change): If isOn, changes volume and prints the change. Else, prints "TV is off."
   • Add Javadoc.

2. StreamingPlayer Class:

   • Create a class StreamingPlayer that implements Controllable.
   • Data Members (Specific to StreamingPlayer):
     • private boolean isPowered;
     • private String currentApp; // e.g., "Netflix", "Standby"
     • private boolean isPlaying;
   • Constructor: public StreamingPlayer(String deviceName)
     • Initialize isPowered to false, currentApp to "Home Screen", isPlaying to false.
     • Print a message like: System.out.println(deviceName + " Streaming Player initialized.");
   • Implement Controllable methods (with @Override):
     • powerOn(): Sets isPowered to true, currentApp to "Home Screen", and prints "Streaming Player is now POWERED ON. App: Home Screen".
     • powerOff(): Sets isPowered to false, isPlaying to false, and prints "Streaming Player is now POWERED OFF.".
     • getStatus(): Returns a string like "Streaming Player Status: [POWERED/OFF], App: [currentApp], Playing: [isPlaying]".
   • Add specific StreamingPlayer methods:
     • public void launchApp(String appName): If isPowered, changes currentApp and prints. Else, prints "Player is off."
     • public void play(): If isPowered, sets isPlaying to true and prints. Else, prints "Player is off."
     • public void stop(): If isPowered, sets isPlaying to false and prints. Else, prints "Player is off."
   • Add Javadoc.

// ... (after Controllable interface)

/**
 * Represents a Smart Television that can be controlled.
 */
class SmartTV implements Controllable {
    private boolean isOn;
    private int currentChannel;
    private int volume;
    private String brand;

    public SmartTV(String brand) {
        this.brand = brand;
        this.isOn = false;
        this.currentChannel = 1;
        this.volume = 10;
        System.out.println("DEVICE: " + this.brand + " SmartTV initialized.");
    }

    @Override
    public void powerOn() {
        this.isOn = true;
        this.currentChannel = 1; // Default channel on power on
        System.out.println("ACTION: " + this.brand + " SmartTV is now ON. Channel: " + this.currentChannel);
    }

    @Override
    public void powerOff() {
        this.isOn = false;
        System.out.println("ACTION: " + this.brand + " SmartTV is now OFF.");
    }

    @Override
    public String getStatus() {
        return this.brand + " SmartTV Status: " + (this.isOn ? "ON" : "OFF") +
               ", Channel: " + this.currentChannel +
               ", Volume: " + this.volume;
    }

    public void changeChannel(int newChannel) {
        if (this.isOn) {
            this.currentChannel = newChannel;
            System.out.println("ACTION: " + this.brand + " SmartTV channel changed to " + this.currentChannel);
        } else {
            System.out.println("INFO: " + this.brand + " SmartTV is off. Cannot change channel.");
        }
    }

    public void adjustVolume(int change) {
        if (this.isOn) {
            this.volume += change;
            if (this.volume < 0) this.volume = 0;
            if (this.volume > 100) this.volume = 100; // Max volume
            System.out.println("ACTION: " + this.brand + " SmartTV volume adjusted to " + this.volume);
        } else {
            System.out.println("INFO: " + this.brand + " SmartTV is off. Cannot adjust volume.");
        }
    }
}

/**
 * Represents a Streaming Player device that can be controlled.
 */
class StreamingPlayer implements Controllable {
    private boolean isPowered;
    private String currentApp;
    private boolean isPlaying;
    private String deviceName;

    public StreamingPlayer(String deviceName) {
        this.deviceName = deviceName;
        this.isPowered = false;
        this.currentApp = "Home Screen";
        this.isPlaying = false;
        System.out.println("DEVICE: " + this.deviceName + " Streaming Player initialized.");
    }

    @Override
    public void powerOn() {
        this.isPowered = true;
        this.currentApp = "Home Screen"; // Default app
        this.isPlaying = false;
        System.out.println("ACTION: " + this.deviceName + " Streaming Player is now POWERED ON. App: " + this.currentApp);
    }

    @Override
    public void powerOff() {
        this.isPowered = false;
        this.isPlaying = false;
        System.out.println("ACTION: " + this.deviceName + " Streaming Player is now POWERED OFF.");
    }

    @Override
    public String getStatus() {
        return this.deviceName + " Streaming Player Status: " + (this.isPowered ? "POWERED ON" : "POWERED OFF") +
               ", App: " + this.currentApp +
               ", Playing: " + (this.isPlaying ? "Yes" : "No");
    }

    public void launchApp(String appName) {
        if (this.isPowered) {
            this.currentApp = appName;
            this.isPlaying = false; // Stop previous playback if any
            System.out.println("ACTION: " + this.deviceName + " launching app: " + this.currentApp);
        } else {
            System.out.println("INFO: " + this.deviceName + " Streaming Player is off. Cannot launch app.");
        }
    }

    public void play() {
        if (this.isPowered) {
            if (!this.currentApp.equals("Home Screen")) {
                this.isPlaying = true;
                System.out.println("ACTION: " + this.deviceName + " is now PLAYING content in " + this.currentApp);
            } else {
                System.out.println("INFO: " + this.deviceName + " is on Home Screen. Select an app to play content.");
            }
        } else {
            System.out.println("INFO: " + this.deviceName + " Streaming Player is off. Cannot play.");
        }
    }

    public void stop() {
        if (this.isPowered && this.isPlaying) {
            this.isPlaying = false;
            System.out.println("ACTION: " + this.deviceName + " has STOPPED playing content in " + this.currentApp);
        } else if (this.isPowered) {
            System.out.println("INFO: " + this.deviceName + " is not currently playing anything.");
        } else {
            System.out.println("INFO: " + this.deviceName + " Streaming Player is off.");
        }
    }
}

// TODO: Steps 3, 4 will go here

Tutor's Insight: Notice SmartTV and StreamingPlayer are completely separate in terms of their internal details and extra methods. One has changeChannel, the other has launchApp. They don't inherit from each other. Their only commonality defined by us is that they both implement Controllable. This is a key difference from class inheritance!

---

Step 3: The Universal Remote - Using Interface References

Now for our "Universal Remote." This class will be able to interact with any Controllable device.

Your Task (Puzzle 3):

1. Create a class UniversalRemote.
2. Method pressPowerButton(Controllable device):
   • Takes a Controllable device as a parameter.
     • Aha! Moment Update README.md #1 (Key for DI/Collections): The device parameter is of type Controllable (the interface). This means you can pass any object to this method as long as its class implements Controllable.
   • Inside the method, it should check the device's current status. A simple way: if device.getStatus() contains "OFF" (you might need to refine this logic, e.g. by checking isOn if devices had a public getter for it, but for simplicity, string check is okay for this exercise), then call device.powerOn(). Otherwise, call device.powerOff().
   • Then print System.out.println("REMOTE: Current status - " + device.getStatus());
   • Aha! Moment Retained License #2 (Dynamic Method Dispatch via Interface): When device.powerOn() or device.powerOff() is called, Java executes the version of that method from the actual object's class (SmartTV's powerOn or StreamingPlayer's powerOn). The remote doesn't care "how" they power on, just that they can.
3. (Optional Overload) Method showDeviceStatus(Controllable device):
   • A simpler method that just prints System.out.println("REMOTE STATUS CHECK: " + device.getStatus());. This is an example of method overloading, useful for different command granularities.
4. Add Javadoc.

// ... (after device classes)

/**
 * A universal remote that can control any device implementing the Controllable interface.
 */
class UniversalRemote {

    /**
     * Simulates pressing the power button on the remote for a given device.
     * If the device appears off, it turns it on. If on, it turns it off.
     * This method showcases polymorphism as it works with any Controllable device.
     * @param device The Controllable device to operate.
     */
    public void pressPowerButton(Controllable device) {
        if (device == null) {
            System.out.println("REMOTE ERROR: No device provided.");
            return;
        }
        System.out.println("REMOTE: Pressing power button for device...");
        // Simple status check; in a real app, devices might have an isOn() method in the interface.
        if (device.getStatus().contains("OFF")) { // A bit simplistic, but works for demo
            device.powerOn();
        } else {
            device.powerOff();
        }
        System.out.println("REMOTE: Action complete. Current status - " + device.getStatus());
    }

    /**
     * Shows the status of the given controllable device.
     * An example of method overloading.
     * @param device The Controllable device to check.
     */
    public void showDeviceStatus(Controllable device) {
        if (device == null) {
            System.out.println("REMOTE ERROR: No device provided to check status.");
            return;
        }
        System.out.println("REMOTE STATUS CHECK: " + device.getStatus());
    }
}

// TODO: Step 4 (Main Class) will go here

Tutor's Insight: The UniversalRemote is truly universal for Controllable things! It doesn't have separate methods like pressSmartTVPower(SmartTV tv) and pressStreamingPlayerPower(StreamingPlayer player). It has one method pressPowerButton(Controllable device). This is the elegance of programming to an interface.

---

Step 4: The Living Room Setup - HomeAutomation Main Method Demonstration

Let's set up our living room and see the remote in action!

Your Task (Puzzle 4):

1. Create the public class HomeAutomation (if you haven't already started your file with it).
2. Inside it, create the public static void main(String[] args) method.
3. Inside main:
   • Print a welcome message: System.out.println("### Welcome to the Smart Home Automation System! ###\n");
   • Create device instances:
     • SmartTV livingRoomTV = new SmartTV("Sony Bravia");
     • StreamingPlayer mainPlayer = new StreamingPlayer("Nvidia Shield");
     • SmartTV kitchenTV = new SmartTV("LG NanoCell"); // Another device
   • Create a UniversalRemote instance:
     • UniversalRemote remote = new UniversalRemote();
   • Control individual devices:
     • System.out.println("--- Controlling Living Room TV ---");
     • remote.showDeviceStatus(livingRoomTV);
     • remote.pressPowerButton(livingRoomTV); // Turns it on
     • livingRoomTV.changeChannel(101); // Using SmartTV specific method
     • livingRoomTV.adjustVolume(5);
     • remote.pressPowerButton(livingRoomTV); // Turns it off
     • remote.showDeviceStatus(livingRoomTV);
     • Do similar individual control steps for mainPlayer.
   • The Power of Collections with Interfaces (Key for your Spring/DI understanding!):
     • System.out.println("\n--- Managing All Controllable Devices in a List ---");
     • Create a List<Controllable> allDevices = new ArrayList<>();
     • Aha! Moment Task - Methods - Menu-driven Calculator #3: Add livingRoomTV, mainPlayer, and kitchenTV to this allDevices list. Even though they are different actual types, they can all live happily in a list of Controllable!
     • Iterate and control all devices uniformly:
       • System.out.println("\n--- Powering ON all devices in the list ---");
       • Loop through allDevices. For each device in the list:
         • device.powerOn(); (Polymorphic call!)
         • System.out.println(" List-Loop Status: " + device.getStatus());
       • System.out.println("\n--- Powering OFF all devices in the list ---");
       • Loop through allDevices again. For each device:
         • device.powerOff(); (Polymorphic call!)
         • System.out.println(" List-Loop Status: " + device.getStatus());
   • Print a closing message.

// ... (after UniversalRemote class)

public class HomeAutomation {
    public static void main(String[] args) {
        System.out.println("### Welcome to the Smart Home Automation System! ###\n");

        // Create device instances
        System.out.println("--- Initializing Devices ---");
        SmartTV livingRoomTV = new SmartTV("Sony Bravia");
        StreamingPlayer mainPlayer = new StreamingPlayer("Nvidia Shield");
        SmartTV kitchenTV = new SmartTV("LG NanoCell"); // Another device of same type
        System.out.println("--- Device Initialization Complete ---\n");

        // Create a UniversalRemote instance
        UniversalRemote remote = new UniversalRemote();

        // Control individual devices
        System.out.println("--- Controlling Living Room TV Individually ---");
        remote.showDeviceStatus(livingRoomTV); // Off
        remote.pressPowerButton(livingRoomTV);   // Turns ON
        livingRoomTV.changeChannel(101);     // TV-specific method
        livingRoomTV.adjustVolume(5);          // TV-specific method
        remote.pressPowerButton(livingRoomTV);   // Turns OFF
        remote.showDeviceStatus(livingRoomTV); // Off again
        System.out.println("--------------------------------------------\n");

        System.out.println("--- Controlling Streaming Player Individually ---");
        remote.showDeviceStatus(mainPlayer);   // Off
        remote.pressPowerButton(mainPlayer);   // Turns ON
        mainPlayer.launchApp("Netflix");       // Player-specific method
        mainPlayer.play();                     // Player-specific method
        remote.pressPowerButton(mainPlayer);   // Turns OFF
        remote.showDeviceStatus(mainPlayer);   // Off again
        System.out.println("--------------------------------------------\n");


        // The Power of Collections with Interfaces
        System.out.println("--- Managing All Controllable Devices via a List ---");
        List<Controllable> allDevices = new ArrayList<>();
        allDevices.add(livingRoomTV);
        allDevices.add(mainPlayer);
        allDevices.add(kitchenTV);

        System.out.println("\n  >>> Powering ON all devices in the list <<<");
        for (Controllable device : allDevices) {
            System.out.print("  Remote targeting device... "); // Indicate which device is being targeted
            device.powerOn(); // Polymorphic call!
            System.out.println("      List-Loop Current Status: " + device.getStatus());
        }

        // Let's interact with one specifically if we need to
        System.out.println("\n  >>> Specific interaction with Kitchen TV from list <<<");
        // To call SmartTV specific methods, we need to check type and cast
        for (Controllable device : allDevices) {
            if (device instanceof SmartTV && ((SmartTV) device).brand.equals("LG NanoCell")) { // Assuming brand is public or accessible for check
                SmartTV specificTV = (SmartTV) device; // Downcasting
                System.out.println("  Found Kitchen TV. Current channel: " + specificTV.currentChannel); // Need currentChannel to be accessible or have a getter
                specificTV.changeChannel(55);
                specificTV.adjustVolume(3);
                System.out.println("      List-Loop (Kitchen TV specific) Status: " + specificTV.getStatus());
                break; // Found and interacted
            }
        }


        System.out.println("\n  >>> Powering OFF all devices in the list <<<");
        for (Controllable device : allDevices) {
            System.out.print("  Remote targeting device... ");
            device.powerOff(); // Polymorphic call!
            System.out.println("      List-Loop Current Status: " + device.getStatus());
        }
        System.out.println("--------------------------------------------------\n");


        System.out.println("### Smart Home Automation Operations Concluded. ###");
    }
}

Self-Correction/Refinement during main method design:
To demonstrate calling specific methods like livingRoomTV.changeChannel(101), the livingRoomTV reference needs to be of type SmartTV. When iterating through the List<Controllable>, the device reference is of type Controllable. To call SmartTV-specific methods on such a reference, you'd need to do an instanceof check and a cast:

if (device instanceof SmartTV) {
    SmartTV tv = (SmartTV) device;
    tv.changeChannel(5); // Now you can call SmartTV methods
}

I've added a small section in the main to illustrate this, as it's an important related concept. I also made the brand and currentChannel fields in SmartTV package-private or added getters for the example to work if the main method is in the same package (which it is in a single file exercise). For the example, I made brand public for simplicity in the instanceof check, and assumed currentChannel was accessible for printing. In real code, you'd use getters. I'll adjust SmartTV slightly to make brand accessible and a getter for currentChannel for the demo.

Correction to SmartTV for the demo in main to work cleanly:

// In SmartTV class:
// ...
// public String brand; // Made public for easy access in main for demo, usually getter
// public int currentChannel; // Made public for easy access in main for demo, usually getter
// ...
// For a slightly better approach, let's use a getter for brand in the check, and keep fields private.
// In SmartTV:
// private String brand; -> public String getBrand() { return this.brand; }
// private int currentChannel; -> public int getCurrentChannel() { return this.currentChannel; }

// Main check would become:
// if (device instanceof SmartTV && ((SmartTV) device).getBrand().equals("LG NanoCell")) {
//    SmartTV specificTV = (SmartTV) device;
//    System.out.println("  Found Kitchen TV. Current channel: " + specificTV.getCurrentChannel());
//    specificTV.changeChannel(55);
//    ...
// }

I'll update the provided SmartTV code with these getters and keep fields private. This makes the example for casting more robust.

(Final check on SmartTV for the demo in main)

// In SmartTV class
// ...
// private String brand;
// private int currentChannel;
// ...
// public String getBrand() { return this.brand; } // Getter for brand
// public int getCurrentChannel() { return this.currentChannel; } // Getter for currentChannel
// ...

// Main check:
// if (device instanceof SmartTV && ((SmartTV) device).getBrand().equals("LG NanoCell")) {
// SmartTV specificTV = (SmartTV) device;
// System.out.println("  Found Kitchen TV. Current channel: " + specificTV.getCurrentChannel());
// specificTV.changeChannel(55);
// ...

This is much better. I will ensure the SmartTV code snippet reflects these getters.

---

Step 5: Understanding the Magic - Recap and Why Interfaces Rock for Life!

So, what just happened, and why is this a "for life" concept for you?

1. The Contract is King (Controllable interface):

   • Any class (SmartTV, StreamingPlayer, or a future SmartLightbulb) can promise to be Controllable. They don't need to share any other family ties (no common parent class needed). They just say, "I know how to powerOn(), powerOff(), and getStatus()."

2. Polymorphic References via Interface:

   • Controllable myDevice = new SmartTV("LG"); This is perfectly valid. The myDevice variable knows it's dealing with something that is Controllable, so it knows it can call powerOn(), powerOff(), and getStatus() on it.
   • List<Controllable> allDevices; This list can hold a mix of SmartTV objects, StreamingPlayer objects, and any other Controllable objects you invent later. This is massively powerful for managing diverse objects that share a common capability.

3. Dynamic Method Dispatch (Interface Edition):

   • When you iterate through allDevices and call device.powerOn(), Java doesn't run some generic powerOn. At runtime, it looks at the actual object (SmartTV or StreamingPlayer) and calls its specific implementation of powerOn(). The UniversalRemote or the list loop doesn't need to know the specifics – it trusts the object to do its job as per the Controllable contract.

4. Why this is CRITICAL for frameworks like Spring (Dependency Injection):

   • In Spring, you often define your services using interfaces, e.g., OrderService (interface).
   • Then you have a concrete implementation: OrderServiceImpl implements OrderService.
   • When another class needs an OrderService, Spring can "inject" an instance of OrderServiceImpl into a field declared as OrderService:

     // @Autowired
     // private OrderService orderService; // orderService will hold an OrderServiceImpl instance

   • Your code then just uses orderService.placeOrder(), and polymorphism ensures the correct implementation is called. This makes your components loosely coupled – the consuming class only depends on the OrderService interface, not the specific OrderServiceImpl. You could swap out OrderServiceImpl for AdvancedOrderServiceImpl without changing the consuming class, as long as both implement OrderService.

5. Open/Closed Principle in Action:

   • Our UniversalRemote is closed for modification (you don't need to change its code to support new devices) but open for extension (you can create new classes that implement Controllable, and the remote will just work with them).

---

You've now seen polymorphism through class inheritance (your previous example) and through interfaces (this exercise). Interfaces are incredibly common for defining roles, capabilities, or contracts that many unrelated classes can adopt. Understanding how to use interface references to manage and interact with diverse objects is a fundamental skill for any professional Java developer.

When you see a List<SomeInterface> or a method doSomething(SomeInterface param) in the future, a lightbulb should go on! You'll know that it's designed for flexibility, allowing different implementations to be plugged in seamlessly.

[Sdey0907]

**

Task 1 - The Universal Remote: Controlling Devices -Sayan Dey - Completed

**

SmartHomeController.zip