OOP Concept in real-time scenario: Mobile Device Management Software

 Scenario: Mobile Device Management Software

Context: You are developing a Device Management System for mobile providers like Realme, Redmi, Samsung, and Nokia. The system tracks and manages mobile devices, their specifications, and behaviors (e.g., sending notifications, updating software, logging activities). The software must handle different device types (e.g., smartphones, feature phones) with shared and unique features, ensure secure data handling, and support extensible functionality.
Real-Time Relevance:
  • Mobile providers need software to manage device configurations, push updates, monitor performance, and log activities for diagnostics.
  • OOP concepts like encapsulation ensure secure data access, inheritance and polymorphism enable flexible device-specific behaviors, abstraction simplifies complex operations, and interfaces enforce consistent functionality across devices.
  • This scenario aligns with tasks at companies like Equifax (data processing) or mobile software firms, where structured, reusable, and secure code is critical.
Learning Objectives:
  • Understand Class and Object as blueprints and instances.
  • Learn Encapsulation with Getters/Setters and Properties for secure data access.
  • Apply Inheritance and Polymorphism for code reuse and flexibility.
  • Use Abstraction to simplify complex operations.
  • Implement Interface to enforce consistent behavior across devices.
Step-by-Step ExplanationStep 1: Class and ObjectWhat is a Class?
  • A class is a blueprint that defines the structure (data as fields) and behavior (methods) of an entity.
  • In our scenario, a class represents a mobile device with attributes (e.g., model, battery level) and actions (e.g., display info).
Why Use a Class?
  • Organizes code for mobile devices, ensuring consistency across providers like Realme or Samsung.
  • Defines a reusable template for all devices managed by the software.
What is an Object?
  • An object is an instance of a class, representing a specific entity created from the blueprint.
  • Example: A specific Samsung Galaxy phone is an object of the device class.
Why Use an Object?
  • Objects represent individual devices (e.g., a specific Redmi Note 12) in the system, allowing tracking and manipulation.
How in C#:
  • Define a MobileDevice class with fields and a method.
  • Create objects using the new keyword.
// Class: Blueprint for a mobile device
public class MobileDevice
{
    // Fields: Store device data
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    // Constructor: Initializes a new device object
    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        this.model = model;
        this.batteryLevel = batteryLevel;
        this.operatingSystem = operatingSystem;
    }

    // Method: Displays device information
    public void DisplayInfo()
    {
        Console.WriteLine($"Model: {model}, Battery: {batteryLevel}%, OS: {operatingSystem}");
    }
}

  • Analogy: “A class is like a phone design plan. An object is a real phone built from that plan.”
Step 2: EncapsulationWhat is Encapsulation?
  • Encapsulation hides a class’s internal data (fields) and exposes it only through controlled methods or properties, using private access modifiers.
Why Use Encapsulation?
  • Protects sensitive device data (e.g., battery level) from unauthorized or invalid changes.
  • Ensures the software validates inputs (e.g., battery level between 0 and 100).
  • Critical for secure systems used by mobile providers to prevent errors or tampering.
How in C#:
  • Use private fields and public getters/setters to control access.
  • Add validation logic in setters to ensure data integrity.
public class MobileDevice
{
    // Private fields: Hidden from external access
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    // Constructor
    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        this.model = model;
        // Validate battery level
        this.batteryLevel = (batteryLevel >= 0 && batteryLevel <= 100) ? batteryLevel : 0;
        this.operatingSystem = operatingSystem;
    }

    // Getters and Setters: Controlled access
    public string GetModel()
    {
        return model;
    }

    public void SetModel(string model)
    {
        if (!string.IsNullOrEmpty(model))
        {
            this.model = model;
        }
    }

    public double GetBatteryLevel()
    {
        return batteryLevel;
    }

    public void SetBatteryLevel(double batteryLevel)
    {
        if (batteryLevel >= 0 && batteryLevel <= 100)
        {
            this.batteryLevel = batteryLevel;
        }
    }

    public string GetOperatingSystem()
    {
        return operatingSystem;
    }

    public void SetOperatingSystem(string operatingSystem)
    {
        if (!string.IsNullOrEmpty(operatingSystem))
        {
            this.operatingSystem = operatingSystem;
        }
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Model: {model}, Battery: {batteryLevel}%, OS: {operatingSystem}");
    }
}

  • Analogy: “Encapsulation is like a phone’s locked settings. You can’t directly change the battery; you need a proper interface.”
Step 3: PropertiesWhat are Properties?
  • Properties in C# provide a concise way to implement getters and setters, combining controlled access with field-like syntax.
Why Use Properties?
  • Simplifies code compared to traditional getters/setters, improving readability.
  • Maintains encapsulation with validation logic.
  • Common in C# for mobile software to access device attributes efficiently.
How in C#:
  • Replace getters/setters with properties using get and set blocks.
  • Include validation in the set block.
public class MobileDevice
{
    // Private backing fields
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    // Properties: Simplified getters/setters
    public string Model
    {
        get { return model; }
        set { if (!string.IsNullOrEmpty(value)) model = value; }
    }

    public double BatteryLevel
    {
        get { return batteryLevel; }
        set { if (value >= 0 && value <= 100) batteryLevel = value; }
    }

    public string OperatingSystem
    {
        get { return operatingSystem; }
        set { if (!string.IsNullOrEmpty(value)) operatingSystem = value; }
    }

    // Constructor
    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        Model = model;
        BatteryLevel = batteryLevel;
        OperatingSystem = operatingSystem;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Model: {Model}, Battery: {BatteryLevel}%, OS: {OperatingSystem}");
    }
}
  • Analogy: “Properties are like a smart dashboard on a phone. You access values easily, but it checks inputs first.”
Step 4: InheritanceWhat is Inheritance?
  • Inheritance allows a class (child) to inherit fields, properties, and methods from a base class (parent).
  • Child classes can extend or modify the parent’s behavior.
Why Use Inheritance?
  • Reuses common device features (e.g., model, battery) across different device types (smartphones, feature phones).
  • Allows specialization for specific devices (e.g., smartphones for Samsung, feature phones for Nokia).
  • Reduces code duplication in the device management system.
How in C#:
  • Use the : operator to inherit a child class from a base class.
  • Use base to call the parent’s constructor or methods.
public class MobileDevice
{
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    public string Model
    {
        get { return model; }
        set { if (!string.IsNullOrEmpty(value)) model = value; }
    }

    public double BatteryLevel
    {
        get { return batteryLevel; }
        set { if (value >= 0 && value <= 100) batteryLevel = value; }
    }

    public string OperatingSystem
    {
        get { return operatingSystem; }
        set { if (!string.IsNullOrEmpty(value)) operatingSystem = value; }
    }

    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        Model = model;
        BatteryLevel = batteryLevel;
        OperatingSystem = operatingSystem;
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Model: {Model}, Battery: {BatteryLevel}%, OS: {OperatingSystem}");
    }
}

// Child class: Smartphone inherits from MobileDevice
public class Smartphone : MobileDevice
{
    public int CameraMegapixels { get; set; }

    public Smartphone(string model, double batteryLevel, string operatingSystem, int cameraMegapixels)
        : base(model, batteryLevel, operatingSystem)
    {
        CameraMegapixels = cameraMegapixels;
    }

    // Override to include smartphone-specific info
    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Camera: {CameraMegapixels}MP");
    }
}

// Child class: FeaturePhone inherits from MobileDevice
public class FeaturePhone : MobileDevice
{
    public bool HasPhysicalKeypad { get; set; }

    public FeaturePhone(string model, double batteryLevel, string operatingSystem, bool hasPhysicalKeypad)
        : base(model, batteryLevel, operatingSystem)
    {
        HasPhysicalKeypad = hasPhysicalKeypad;
    }

    // Override to include feature phone-specific info
    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Physical Keypad: {HasPhysicalKeypad}");
    }
}

  • Analogy: “Inheritance is like a family tree. All phones share basic traits, but smartphones and feature phones add unique features.”
Step 5: PolymorphismWhat is Polymorphism?
  • Polymorphism allows objects of different classes to be treated as objects of a common base class, with each class providing its own method implementation.
  • Achieved in C# through method overriding with virtual and override.
Why Use Polymorphism?
  • Enables flexible behavior for different device types (e.g., different notification styles for smartphones vs. feature phones).
  • Allows the software to process diverse devices uniformly while executing type-specific actions.
  • Essential for scalable systems handling Realme, Nokia, etc.
How in C#:
  • Mark a base class method as virtual.
  • Override it in child classes using override.
public class MobileDevice
{
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    public string Model
    {
        get { return model; }
        set { if (!string.IsNullOrEmpty(value)) model = value; }
    }

    public double BatteryLevel
    {
        get { return batteryLevel; }
        set { if (value >= 0 && value <= 100) batteryLevel = value; }
    }

    public string OperatingSystem
    {
        get { return operatingSystem; }
        set { if (!string.IsNullOrEmpty(value)) operatingSystem = value; }
    }

    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        Model = model;
        BatteryLevel = batteryLevel;
        OperatingSystem = operatingSystem;
    }

    // Virtual method for polymorphism
    public virtual void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Basic Notification: {message}");
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Model: {Model}, Battery: {BatteryLevel}%, OS: {OperatingSystem}");
    }
}

public class Smartphone : MobileDevice
{
    public int CameraMegapixels { get; set; }

    public Smartphone(string model, double batteryLevel, string operatingSystem, int cameraMegapixels)
        : base(model, batteryLevel, operatingSystem)
    {
        CameraMegapixels = cameraMegapixels;
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Smartphone Push Notification: {message} (High Priority)");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Camera: {CameraMegapixels}MP");
    }
}

public class FeaturePhone : MobileDevice
{
    public bool HasPhysicalKeypad { get; set; }

    public FeaturePhone(string model, double batteryLevel, string operatingSystem, bool hasPhysicalKeypad)
        : base(model, batteryLevel, operatingSystem)
    {
        HasPhysicalKeypad = hasPhysicalKeypad;
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Feature Phone SMS Notification: {message}");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Physical Keypad: {HasPhysicalKeypad}");
    }
}
  • Analogy: “Polymorphism is like sending a message to all phones. Each phone handles it differently (push vs. SMS).”
Step 6: AbstractionWhat is Abstraction?
  • Abstraction hides complex implementation details and exposes only essential features to the user.
  • In C#, abstraction is achieved using abstract classes or interfaces. An abstract class can have both implemented and abstract (unimplemented) methods.
Why Use Abstraction?
  • Simplifies interaction with devices by hiding complex operations (e.g., software update process).
  • Ensures the software focuses on what a device does (e.g., update software) rather than how it’s done.
  • Useful for standardizing high-level operations across diverse devices.
How in C#:
  • Create an abstract class with abstract methods (no implementation) and concrete methods.
  • Child classes provide specific implementations for abstract methods.
// Abstract class: Provides a blueprint with some implementation and abstract methods
public abstract class MobileDevice
{
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    public string Model
    {
        get { return model; }
        set { if (!string.IsNullOrEmpty(value)) model = value; }
    }

    public double BatteryLevel
    {
        get { return batteryLevel; }
        set { if (value >= 0 && value <= 100) batteryLevel = value; }
    }

    public string OperatingSystem
    {
        get { return operatingSystem; }
        set { if (!string.IsNullOrEmpty(value)) operatingSystem = value; }
    }

    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        Model = model;
        BatteryLevel = batteryLevel;
        OperatingSystem = operatingSystem;
    }

    // Abstract method: Must be implemented by child classes
    public abstract void UpdateSoftware(string newVersion);

    // Virtual method for polymorphism
    public virtual void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Basic Notification: {message}");
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Model: {Model}, Battery: {BatteryLevel}%, OS: {OperatingSystem}");
    }
}

public class Smartphone : MobileDevice
{
    public int CameraMegapixels { get; set; }

    public Smartphone(string model, double batteryLevel, string operatingSystem, int cameraMegapixels)
        : base(model, batteryLevel, operatingSystem)
    {
        CameraMegapixels = cameraMegapixels;
    }

    // Implement abstract method
    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to Android {newVersion} via OTA");
        OperatingSystem = $"Android {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Smartphone Push Notification: {message} (High Priority)");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Camera: {CameraMegapixels}MP");
    }
}

public class FeaturePhone : MobileDevice
{
    public bool HasPhysicalKeypad { get; set; }

    public FeaturePhone(string model, double batteryLevel, string operatingSystem, bool hasPhysicalKeypad)
        : base(model, batteryLevel, operatingSystem)
    {
        HasPhysicalKeypad = hasPhysicalKeypad;
    }

    // Implement abstract method
    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to Nokia OS {newVersion} via service center");
        OperatingSystem = $"Nokia OS {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Feature Phone SMS Notification: {message}");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Physical Keypad: {HasPhysicalKeypad}");
    }
}
How Explanation:
  • MobileDevice is now abstract, meaning it cannot be instantiated directly.
  • UpdateSoftware is an abstract method, forcing child classes (Smartphone, FeaturePhone) to implement it.
  • Why: Hides complex update logic (e.g., OTA vs. service center) and ensures all devices support updates.

  • Analogy: “Abstraction is like a phone’s ‘Update’ button. You press it, but don’t need to know how the update happens.”
Step 7: InterfaceWhat is an Interface?
  • An interface defines a contract of methods that a class must implement, without providing any implementation.
  • All methods in an interface are implicitly abstract (until C# 8.0+ default methods).
Why Use an Interface?
  • Enforces consistent behavior across unrelated classes (e.g., all devices must log activities for diagnostics).
  • Provides flexibility to add functionality without modifying existing class hierarchies.
  • Useful for ensuring mobile software meets provider requirements (e.g., logging for Samsung, Nokia).
How in C#:
  • Define an interface with method signatures.
  • Classes implement the interface using : and provide method bodies.
// Interface: Defines a contract for logging device activity
public interface ILoggable
{
    void LogActivity(string activity);
}

// Abstract class with interface implementation
public abstract class MobileDevice : ILoggable
{
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    public string Model
    {
        get { return model; }
        set { if (!string.IsNullOrEmpty(value)) model = value; }
    }

    public double BatteryLevel
    {
        get { return batteryLevel; }
        set { if (value >= 0 && value <= 100) batteryLevel = value; }
    }

    public string OperatingSystem
    {
        get { return operatingSystem; }
        set { if (!string.IsNullOrEmpty(value)) operatingSystem = value; }
    }

    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        Model = model;
        BatteryLevel = batteryLevel;
        OperatingSystem = operatingSystem;
    }

    public abstract void UpdateSoftware(string newVersion);

    public virtual void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Basic Notification: {message}");
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Model: {Model}, Battery: {BatteryLevel}%, OS: {OperatingSystem}");
    }

    // Implement interface method
    public void LogActivity(string activity)
    {
        Console.WriteLine($"[{Model}] Log: {activity} at {DateTime.Now}");
    }
}

public class Smartphone : MobileDevice
{
    public int CameraMegapixels { get; set; }

    public Smartphone(string model, double batteryLevel, string operatingSystem, int cameraMegapixels)
        : base(model, batteryLevel, operatingSystem)
    {
        CameraMegapixels = cameraMegapixels;
    }

    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to Android {newVersion} via OTA");
        OperatingSystem = $"Android {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Smartphone Push Notification: {message} (High Priority)");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Camera: {CameraMegapixels}MP");
    }
}

public class FeaturePhone : MobileDevice
{
    public bool HasPhysicalKeypad { get; set; }

    public FeaturePhone(string model, double batteryLevel, string operatingSystem, bool hasPhysicalKeypad)
        : base(model, batteryLevel, operatingSystem)
    {
        HasPhysicalKeypad = hasPhysicalKeypad;
    }

    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to Nokia OS {newVersion} via service center");
        OperatingSystem = $"Nokia OS {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Feature Phone SMS Notification: {message}");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Physical Keypad: {HasPhysicalKeypad}");
    }
}
How Explanation:
  • ILoggable defines a LogActivity method that all devices must implement.
  • MobileDevice implements ILoggable, providing a default logging behavior.
  • Why: Ensures all devices can log activities (e.g., for diagnostics), meeting provider requirements.

  • Analogy: “An interface is like a contract. Every phone must log activities, but how it logs is up to the device.”
Complete C# Program
using System;
using System.Collections.Generic;

// Interface: Contract for logging
public interface ILoggable
{
    void LogActivity(string activity);
}

// Abstract class: Base for all mobile devices
public abstract class MobileDevice : ILoggable
{
    private string model;
    private double batteryLevel;
    private string operatingSystem;

    public string Model
    {
        get { return model; }
        set { if (!string.IsNullOrEmpty(value)) model = value; }
    }

    public double BatteryLevel
    {
        get { return batteryLevel; }
        set { if (value >= 0 && value <= 100) batteryLevel = value; }
    }

    public string OperatingSystem
    {
        get { return operatingSystem; }
        set { if (!string.IsNullOrEmpty(value)) operatingSystem = value; }
    }

    public MobileDevice(string model, double batteryLevel, string operatingSystem)
    {
        Model = model;
        BatteryLevel = batteryLevel;
        OperatingSystem = operatingSystem;
    }

    public abstract void UpdateSoftware(string newVersion);

    public virtual void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Basic Notification: {message}");
    }

    public virtual void DisplayInfo()
    {
        Console.WriteLine($"Model: {Model}, Battery: {BatteryLevel}%, OS: {OperatingSystem}");
    }

    public void LogActivity(string activity)
    {
        Console.WriteLine($"[{Model}] Log: {activity} at {DateTime.Now}");
    }
}

public class Smartphone : MobileDevice
{
    public int CameraMegapixels { get; set; }

    public Smartphone(string model, double batteryLevel, string operatingSystem, int cameraMegapixels)
        : base(model, batteryLevel, operatingSystem)
    {
        CameraMegapixels = cameraMegapixels;
    }

    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to Android {newVersion} via OTA");
        OperatingSystem = $"Android {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Smartphone Push Notification: {message} (High Priority)");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Camera: {CameraMegapixels}MP");
    }
}

public class FeaturePhone : MobileDevice
{
    public bool HasPhysicalKeypad { get; set; }

    public FeaturePhone(string model, double batteryLevel, string operatingSystem, bool hasPhysicalKeypad)
        : base(model, batteryLevel, operatingSystem)
    {
        HasPhysicalKeypad = hasPhysicalKeypad;
    }

    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to Nokia OS {newVersion} via service center");
        OperatingSystem = $"Nokia OS {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Feature Phone SMS Notification: {message}");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Physical Keypad: {HasPhysicalKeypad}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create objects (Class/Object)
        List<MobileDevice> devices = new List<MobileDevice>
        {
            new Smartphone("Galaxy S23", 80.0, "Android 13", 50),
            new FeaturePhone("Nokia 3310", 95.0, "Nokia OS", true),
            new Smartphone("Redmi Note 12", 90.0, "Android 12", 48)
        };

        // Demonstrate polymorphism and abstraction
        Console.WriteLine("Device Operations:");
        foreach (MobileDevice device in devices)
        {
            device.DisplayInfo();
            device.SendNotification("Update available!");
            device.UpdateSoftware("14.0"); // Abstraction
            device.LogActivity("Device started"); // Interface
            Console.WriteLine();
        }

        // Demonstrate encapsulation and properties
        Smartphone samsung = new Smartphone("Galaxy S23", 80.0, "Android 13", 50);
        samsung.BatteryLevel = 85.5; // Valid
        samsung.BatteryLevel = -10;  // Ignored
        samsung.DisplayInfo();

        // Demonstrate inheritance
        FeaturePhone nokia = new FeaturePhone("Nokia 3310", 95.0, "Nokia OS", true);
        Console.WriteLine($"Nokia has physical keypad: {nokia.HasPhysicalKeypad}");
    }
}
Output 
Device Operations:
Model: Galaxy S23, Battery: 80%, OS: Android 13
Camera: 50MP
[Galaxy S23] Smartphone Push Notification: Update available! (High Priority)
[Galaxy S23] Updating to Android 14.0 via OTA
[Galaxy S23] Log: Device started at 8/21/2025 4:22:00 PM

Model: Nokia 3310, Battery: 95%, OS: Nokia OS
Physical Keypad: True
[Nokia 3310] Feature Phone SMS Notification: Update available!
[Nokia 3310] Updating to Nokia OS 14.0 via service center
[Nokia 3310] Log: Device started at 8/21/2025 4:22:00 PM

Model: Redmi Note 12, Battery: 90%, OS: Android 12
Camera: 48MP
[Redmi Note 12] Smartphone Push Notification: Update available! (High Priority)
[Redmi Note 12] Updating to Android 14.0 via OTA
[Redmi Note 12] Log: Device started at 8/21/2025 4:22:00 PM

Model: Galaxy S23, Battery: 85.5%, OS: Android 13
Camera: 50MP
Nokia has physical keypad: True
Walk through:
    • Create MobileDevice with properties (Steps 1–3).
    • Add Smartphone and FeaturePhone for inheritance (Step 4).
    • Implement SendNotification for polymorphism (Step 5).
    • Make MobileDevice abstract with UpdateSoftware (Step 6).
    • Add ILoggable interface (Step 7).
  • Run the program and explain output.
  • Test edge cases: Invalid BatteryLevel, empty device list.
Hands-On Practic
  • Tasks:
    • Add a new property (e.g., StorageGB) to MobileDevice.
    • Create a Tablet class inheriting from MobileDevice, implementing ILoggable.
    • Modify UpdateSoftware in Tablet (e.g., “Updating to iOS via Wi-Fi”).
    • Test with new objects (e.g., new Tablet("iPad", 70.0, "iOS", 10.2)).
  • Sample Code for Tablet:

    public class Tablet : MobileDevice
{
    public double ScreenSize { get; set; }

    public Tablet(string model, double batteryLevel, string operatingSystem, double screenSize)
        : base(model, batteryLevel, operatingSystem)
    {
        ScreenSize = screenSize;
    }

    public override void UpdateSoftware(string newVersion)
    {
        Console.WriteLine($"[{Model}] Updating to iOS {newVersion} via Wi-Fi");
        OperatingSystem = $"iOS {newVersion}";
    }

    public override void SendNotification(string message)
    {
        Console.WriteLine($"[{Model}] Tablet Notification: {message} (Large Screen)");
    }

    public override void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Screen Size: {ScreenSize} inches");
    }
}
Wrap-Up and Q&A
  • Recap: “You used classes to define devices, encapsulation/properties for security, inheritance/polymorphism for reuse and flexibility, abstraction to simplify operations, and interfaces for consistency.”
  • Questions: Address:
    • “Why use abstraction vs. interface?” (Abstract classes provide partial implementation; interfaces are pure contracts.)
    • “When to use polymorphism?” (When behavior varies by type.)

Comments

Post a Comment

Popular posts from this blog

Interview Tips: Dot NET Framework vs Net CORE

Image
Interview Tips: Dot NET Framework vs Net CORE .NET Framework What :  It's a software development framework created by Microsoft, mainly used for building Windows applications. Why :  It has been around for a long time and is very reliable for building large, complex applications especially for enterprises. How :  You use it to build applications that run exclusively on Windows, making use of a vast array of built-in libraries and features. Why Not :  It can't be used for cross-platform applications, so if you need your application to run on other operating systems like macOS or Linux, .NET Framework isn't the right choice. .NET Core What :  It's a newer, open-source, and cross-platform framework from Microsoft, designed for modern app development. Why :  It's lightweight, high-performance, and can run on multiple operating systems (Windows, macOS, Linux). How :  You use it to build modern, scalable, and quickly deployable applications, especially cloud...
Read more

FREE Webinar: Run Your Own Independent DeepSeek LLM

Image
Faith Infotech Academy, Technopark invites you to an exclusive FREE webinar on "Run Your Own Independent DeepSeek LLM" , where you’ll learn how to deploy and manage DeepSeek LLM effectively. Speaker:  Abhilash Nelson  Trainer & Researcher in AI & Machine Learning  An expert in AI and machine learning, Abhilash will guide you through the process of setting up and running your own independent DeepSeek LLM, empowering you with insights into model deployment, fine-tuning, and real-world applications. What You’ll Learn: ✅ Understanding DeepSeek LLM and its capabilities ✅ Setting up DeepSeek LLM on your own infrastructure ✅ Fine-tuning and optimizing the model for various applications ✅ Use cases and practical demonstrations Key Takeaways: ✅ Mastering DeepSeek LLM for Developers ✅ Boost Your VS Code workflow ✅ Learn to Run DeepSeek locally for AI assistance 📅 Date: 6 February 2025, Thursday 🕒 Time:  10.00 to 11.00 AM 📍 Mode: Online (Webinar link will be shar...
Read more

ORACLE 11g: User Authentication System with Stored Procedure and SQL*Plus Integration

Oracle 11g PL/SQL: User Authentication System with Stored Procedure and SQL*Plus Integration Creating the tblUsers and tblRoles tables with sequences and 6 records, creating a stored procedure sp_UserNameAndPassword that returns user details as an OUT parameter (using a record type), and modifying the login.sql script to accept username and password, call the procedure, and display the results in SQL*Plus.  The solution will include "what," "why," "how" explanations, comments, and adhere to coding standards with exception handling. Step-by-Step Solution 1. Create Tables and Insert Records Create the tables with sequences for primary keys and insert 6 records. -- Create tblRoles table with sequence for RoleId CREATE TABLE tblRoles ( RoleId NUMBER ( 10 ) PRIMARY KEY , roleName VARCHAR2 ( 50 ) NOT NULL ) ; CREATE SEQUENCE role_seq START WITH 1 INCREMENT BY 1 ; -- Insert 4 roles INSERT INTO tblRoles ( RoleId , roleName ) VAL...
Read more