update

dart_ex_1/advanced_class.dart

@@ -0,0 +1,219 @@
+// WHAT: A mixin is a set of fields and methods that can be reused by multiple classes.
+// WHY: To allow 'SmartSpeaker' to have connection logic without forcing 'SmartLight' to have it.
+mixin Connectable {
+  // WHAT: A boolean instance variable initialized to false.
+  // WHY: To track whether a specific device is currently linked to a network or bluetooth.
+  bool isConnected = false;
+
+  // WHAT: A function using arrow syntax (=>) to negate the current boolean.
+  // WHY: Provides a standardized, reusable way to flip the connection state for any class using this mixin.
+  void toggleConnection() => isConnected = !isConnected;
+}
+
+// WHAT: An abstract class acting as a base template.
+// WHY: It defines the shared "DNA" of all devices but prevents anyone from creating a generic "SmartDevice".
+abstract class SmartDevice {
+  // WHAT: A final String that can only be set once.
+  // WHY: Ensures the device's unique identifier remains immutable (unchangeable) after creation.
+  final String id;
+
+  // WHAT: A private String (indicated by the underscore).
+  // WHY: Encapsulation; it hides raw data so we can control how it's accessed or formatted via getters/setters.
+  String _name;
+
+  // WHAT: Private boolean state for power.
+  // WHY: To keep the "ON/OFF" state internal to the object, requiring a method call to change it.
+  bool _powerStatus = false;
+
+  // WHAT: Private boolean for automation.
+  // WHY: To track if the device should handle its own power timing without user intervention.
+  bool _auto_on_off = false;
+
+  // WHAT: A static constant String.
+  // WHY: This belongs to the class itself (the brand), not the individual instances.
+  static const String brand = "GeminiHome";
+
+  // 1. Standard Constructor
+  // WHAT: A generative constructor using 'user_provided' naming.
+  // WHY: Maps the external input (user_provided_id) to the internal final field (id).
+  SmartDevice({
+    required String user_provided_id, 
+    required String user_provided_name
+    }) : id = user_provided_id, 
+         _name = user_provided_name;
+
+  // 2. Named Constructor: Office
+  // WHAT: A specialized constructor for a specific use-case.
+  // WHY: It streamlines creation by hardcoding the name and auto-mode for office settings.
+  SmartDevice.office({
+    required String user_provided_id
+    }) : id = user_provided_id,
+        _name = "Office Desk Lamp",
+        _auto_on_off = true;
+
+  // 3. Named Constructor: Eco
+  // WHAT: A specialized constructor for power saving.
+  // WHY: It ensures the device starts in an "OFF" state with "Auto" mode enabled for efficiency.
+  SmartDevice.eco({
+    required String user_provided_id
+    })  : id = user_provided_id,
+        _name = "Eco Saver Unit",
+        _powerStatus = false,
+        _auto_on_off = true;
+
+  // 4. Factory Constructor
+  // WHAT: A factory that decides which subclass to create.
+  // WHY: It allows the "SmartDevice" class to return a "SmartLight" or "SmartSpeaker" based on a String input.
+  factory SmartDevice.create({
+    required String user_provided_type,
+    required String user_provided_id,
+    required String user_provided_name,
+  }) {
+    // WHAT: Logic to check the 'type' string.
+    // WHY: To determine which concrete implementation is needed for the user's request.
+    if (user_provided_type == 'light') {
+      return SmartLight(user_provided_id: user_provided_id, user_provided_name: user_provided_name);
+    }
+    return SmartSpeaker(user_provided_id: user_provided_id, user_provided_name: user_provided_name);
+  }
+
+  // WHAT: A public Getter for the private name.
+  // WHY: Allows other parts of the app to read the name without being able to overwrite it directly.
+  String get name => _name;
+
+  // WHAT: A public Setter with a .trim() method.
+  // WHY: Cleans the input data (removing spaces) before saving it to the private '_name' field.
+  set name(String user_provided_new_name) => _name = user_provided_new_name.trim();
+
+  // WHAT: An abstract method signature (no curly braces).
+  // WHY: It forces every subclass to define what "performing an action" actually means for that specific device.
+  void performAction();
+
+  // WHAT: A concrete method shared by all subclasses.
+  // WHY: To avoid code duplication; every smart device uses the same logic to toggle power.
+  void togglePower() {
+    // WHAT: Boolean inversion.
+    // WHY: Changes 'true' to 'false' or vice versa to simulate a power switch.
+    _powerStatus = !_powerStatus;
+    print('$_name is now ${_powerStatus ? "ON" : "OFF"} (Auto-mode: $_auto_on_off)');
+  }
+}
+
+// WHAT: A concrete implementation of a SmartDevice.
+// WHY: To add specific properties (like brightness) that only a light would have.
+class SmartLight extends SmartDevice {
+  // WHAT: An integer specific to this class.
+  // WHY: To track how bright the light is; initialized to 100 by default.
+  int brightness = 100;
+
+  // WHAT: Standard constructor passing data to the super class.
+  // WHY: To ensure a custom light gets its ID and Name correctly initialized in the base class.
+  SmartLight({
+    required String user_provided_id, 
+    required String user_provided_name
+    }) : super(user_provided_id: user_provided_id, user_provided_name: user_provided_name);
+
+  // WHAT: Named constructor with an extra assignment in the initializer list.
+  // WHY: It combines the "Office" defaults from the parent with a specific "50%" brightness for this subclass.
+  SmartLight.office({
+    required String user_provided_id
+    }) : brightness = 50, // Sets the brightness specifically for office use.
+      super.office(user_provided_id: user_provided_id); // Calls the parent's office logic.
+  
+  // WHAT: Named constructor for Eco mode.
+  // WHY: Redirects to the eco settings in the base class (e.g., auto-off enabled).
+  SmartLight.eco({
+    required String user_provided_id
+    }) : brightness = 20, // WHY: Maybe Eco mode should be even dimmer to save more power!
+      super.eco(user_provided_id: user_provided_id);
+
+  @override
+  // WHAT: Implementation of the abstract method.
+  // WHY: To display the specific state (brightness) of this light.
+  void performAction() {
+    print('[$_name] Brightness: $brightness%');
+  }
+}
+
+// WHAT: A concrete implementation using inheritance (SmartDevice) and a mixin (Connectable).
+// WHY: To create a device that has a name/id AND the ability to connect/disconnect.
+class SmartSpeaker extends SmartDevice with Connectable {
+  // WHAT: A double (0.0 to 1.0) for audio level.
+  // WHY: Specific data needed only for audio-based devices.
+  double volume;
+
+  // WHAT: Constructor with an assertion check.
+  // WHY: The 'assert' stops the program during debugging if the volume is out of bounds (0.0 - 1.0).
+  SmartSpeaker({
+    required String user_provided_id,
+    required String user_provided_name,
+    this.volume = 0.5,
+  })  : assert(volume >= 0 && volume <= 1.0),
+        super(user_provided_id: user_provided_id, user_provided_name: user_provided_name);
+
+  @override
+  // WHAT: Concrete implementation of the abstract method.
+  // WHY: Defines that for a Speaker, "performing an action" includes checking the connection status.
+  void performAction() {
+    print('[$_name] Volume: ${(volume * 100).toInt()}%. Connected: $isConnected');
+  }
+}
+
+// --- EXECUTION ---
+
+void main() {
+  // WHAT: Instantiating a Light using the Office preset.
+  // WHY: To demonstrate how named constructors simplify creating specific device configurations.
+  final workLamp = SmartLight.office(user_provided_id: 'OFFICE_01');
+  
+  // WHAT: Instantiating a Light using the Eco preset.
+  // WHY: Shows the reuse of the super.eco logic.
+  final ecoLight = SmartLight.eco(user_provided_id: 'ECO_99');
+
+  // WHAT: Standard instantiation of a SmartLight.
+  // WHY: Demonstrates creating an object with custom labels.
+  final customLight = SmartLight(
+    user_provided_id: 'CUST_01', 
+    user_provided_name: 'My Custom Light'
+  );
+
+  // WHAT: Using the factory constructor.
+  // WHY: Shows how the 'SmartDevice' base class can act as a single entry point to create different types of objects.
+  final speaker = SmartDevice.create(
+    user_provided_type: 'speaker', 
+    user_provided_id: 'SPK_01', 
+    user_provided_name: 'Living Room Bass'
+  );
+
+  // WHAT: Printing and calling methods.
+  // WHY: To verify that all constructors and methods are working as expected.
+  print('--- Testing Presets ---');
+  workLamp.performAction();
+  workLamp.togglePower();
+  
+  print('');
+  
+  ecoLight.performAction();
+  ecoLight.togglePower();
+
+  print('');
+  speaker.performAction();
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+