Mastering the Basics of OOP with Real-World Examples and C# Code!

Here's an optimized version of your LinkedIn continuation article:

?? Continuing from our previous deep dive into Object-Oriented Programming (OOP) basics(#), where we explored crucial concepts for writing clean, efficient, and maintainable code. Let's delve deeper into these concepts with C# code samples for each principle.

1. Encapsulation: We used the analogy of a smartphone to illustrate bundling data and methods within a class. Imagine the hardware (data) and software (methods) encapsulated within a device, allowing users to interact without knowing its internal complexities.

Now, let's explore these concepts further with C# code examples.

public class Smartphone
{
    private string operatingSystem;
    private string model;

    public Smartphone(string os, string model)
    {
        this.operatingSystem = os;
        this.model = model;
    }

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

class Program
{
    static void Main(string[] args)
    {
        Smartphone phone = new Smartphone("Android", "Pixel 5");
        phone.DisplayInfo();
    }
}        

2. Inheritance: Drawing from our solar system analogy, classes inherit properties. Like planets inheriting traits from the solar system, each planet has unique features such as rings or moons.

public class SolarSystem
{
    public string Star { get; set; }

    public SolarSystem(string star)
    {
        Star = star;
    }
}

public class Planet : SolarSystem
{
    public string Name { get; set; }
    public bool HasRings { get; set; }

    public Planet(string star, string name, bool hasRings) : base(star)
    {
        Name = name;
        HasRings = hasRings;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Planet: {Name}, Star: {Star}, Has Rings: {HasRings}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Planet earth = new Planet("Sun", "Earth", false);
        earth.DisplayInfo();
    }
}        

3. Polymorphism: Illustrated by musical instruments, showcasing the flexibility of object behavior. Different instruments (classes) produce sound uniquely despite using the same play method.

public abstract class Instrument
{
    public abstract void Play();
}

public class Guitar : Instrument
{
    public override void Play()
    {
        Console.WriteLine("Playing the guitar.");
    }
}

public class Piano : Instrument
{
    public override void Play()
    {
        Console.WriteLine("Playing the piano.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Instrument myGuitar = new Guitar();
        Instrument myPiano = new Piano();

        myGuitar.Play();
        myPiano.Play();
    }
}        

4. Abstraction: Using a restaurant menu metaphor, complex object details are simplified. When ordering food, you see the dish's name and description, not its detailed recipe or cooking process.

public abstract class Menu
{
    public abstract void ShowDish();
}

public class Dish : Menu
{
    private string Name;
    private string Description;

    public Dish(string name, string description)
    {
        Name = name;
        Description = description;
    }

    public override void ShowDish()
    {
        Console.WriteLine($"Dish: {Name}, Description: {Description}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dish pasta = new Dish("Pasta", "Creamy Alfredo Pasta with Chicken");
        pasta.ShowDish();
    }
}        

Wrapping up, these foundational OOP principles are essential for real-world software development, helping you build cleaner, more efficient, and maintainable applications.

Let's continue to grow as better programmers together!

#OOP #SoftwareDevelopment #CodingTips #TechnicalInterviews #Programming #Encapsulation #Inheritance #Polymorphism #Abstraction