Introduction and Lesson Goal

Today's mission involves using multiple Object-Oriented Programming (OOP) principles to tackle complex tasks. When principles like Encapsulation, Abstraction, Polymorphism, and Composition are blended, the resulting code becomes streamlined and easier to manage.

Our goal is to dissect two real-world examples, gaining insights into how these principles can seamlessly orchestrate solutions.

Real-life Example 1: Building an Online Library System

Let's design an online library system, as we aim to reinforce our understanding of Encapsulation and Polymorphism. Encapsulation will help us protect the attributes of books, members, and transactions, ensuring they are accessible in a controlled manner. Polymorphism will demonstrate its power by enabling a single interface to represent different underlying forms, such as digital and print versions of books.

using System;
using System.Collections.Generic;

// Base class for different types of library users
class Member {
    private string name;

    public Member(string name) {
        this.name = name;
    }

    public void CheckOutBook(Book book) {
        Console.WriteLine($"{name} checked out {book.GetBookType()} book {book.Title}.");
    }
}

// Base class for different types of books
abstract class Book {
    private string title;

    public string Title {
        get { return title; }
        private set { title = value; }
    }

    public Book(string title) {
        Title = title;
    }

    public abstract string GetBookType();
}

// Inherits from Book, represents a digital book
class DigitalBook : Book {
    public DigitalBook(string title) : base(title) { }

    public override string GetBookType() {
        return "Digital";
    }
}

// Inherits from Book, represents a physical book
class PhysicalBook : Book {
    public PhysicalBook(string title) : base(title) { }

    public override string GetBookType() {
        return "Physical";
    }
}

// Library class that manages members and books
class Library {
    private List<Member> members;
    private List<Book> books;

    public Library() {
        members = new List<Member>();
        books = new List<Book>();
    }

    public void AddMember(Member member) {
        members.Add(member);
    }

    public void AddBook(Book book) {
        books.Add(book);
    }
}

class Program {
    static void Main(string[] args) {
        Library myLibrary = new Library();

        Member alice = new Member("Alice");
        Member bob = new Member("Bob");

        myLibrary.AddMember(alice);
        myLibrary.AddMember(bob);

        Book digitalBook = new DigitalBook("The C# Handbook");
        Book physicalBook = new PhysicalBook("Learning C# Design Patterns");

        myLibrary.AddBook(digitalBook);
        myLibrary.AddBook(physicalBook);

        alice.CheckOutBook(digitalBook);  // Prints: Alice checked out Digital book The C# Handbook.
        bob.CheckOutBook(physicalBook);   // Prints: Bob checked out Physical book Learning C# Design Patterns.
    }
}

In this code snippet, Encapsulation is observed clearly through the class structures and the controlled access to their attributes. Polymorphism is vividly illustrated by how both DigitalBook and PhysicalBook classes inherit from the Book class but provide their own implementations of the GetBookType method. This setup allows objects of DigitalBook and PhysicalBook to be used interchangeably when a book’s type needs to be identified, demonstrating polymorphism’s capability to work with objects of different classes through a common interface.

  • Encapsulation ensures that details about members and books are well-contained within their respective classes.
  • Polymorphism showcases flexibility by treating different book types uniformly, making the system more adaptive and scalable.
Sign up
Join the 1M+ learners on CodeSignal
Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal