Master the Core of Object-Oriented Design Language-Independent OOP Principles & Models

Object-Oriented Programming (OOP) is a programming paradigm focused on structure, modularity, and modeling. Instead of writing sequences of instructions (known as procedural programming), OOP organizes software around data (objects) rather than functions and logic.

OOP is governed by four core pillars that help manage complexity, reduce redundancy, and establish relationships between different parts of a system: Encapsulation, Inheritance, Polymorphism, and Abstraction.

To understand OOP, you must understand the difference between a Class and an Object:

• Class: The conceptual blueprint, template, or schema. It defines the structure and types of data, as well as the actions that can be performed, but it contains no actual value or physical state of its own.
• Object: A concrete instance created from a Class blueprint. It resides in system memory, holds concrete values (state), and executes actions (behaviors).

class Car
    // Constructor definition
    constructor(colorInput, speedInput)
        color = colorInput
        speed = speedInput
end class

// Creating Object Instances
Car myRedCar = new Car("Red", 120)
Car myBlueCar = new Car("Blue", 95)

Inside a Class template, variables and functions are redefined conceptually:

• Attributes (State): The variables declared inside a class that hold the data associated with an object. In different environments, these are called properties, fields, or member variables.
• Behaviors (Actions): The functions defined inside a class that operate on the object's data. These are called member functions or methods.

class BankAccount
    // Attributes (State)
    attribute accountNumber: String
    attribute balance: Decimal

    // Behaviors (Actions/Methods)
    method deposit(amount)
        balance = balance + amount
    end method

    method withdraw(amount)
        if balance >= amount then
            balance = balance - amount
        end if
    end method
end class

Encapsulation is the practice of bundling data and the methods that operate on that data into a single, cohesive unit (a class) while restricting direct external access to some of the object's components.

This restricts external code from directly modifying internal states (known as **data hiding**), preventing unintended bugs.

To interact with private fields safely, classes expose public Getters (methods to read data) and Setters (methods to modify data with validation constraints).

class Employee
    // Private attributes cannot be accessed directly from outside
    private attribute salary: Decimal

    // Public setter with validation
    public method setSalary(newSalary)
        if newSalary > 0 then
            salary = newSalary
        end if
    end method

    // Public getter
    public method getSalary()
        return salary
    end method
end class

Inheritance is a mechanism that allows a class (called a **subclass** or **derived class**) to inherit attributes and methods from another class (called a **superclass** or **base class**). This forms an "is-a" relationship (e.g., a Dog *is a* Mammal).

class Vehicle
    public method move()
        print "Moving..."
end class

// Subclass inheriting from Vehicle
class Bicycle extends Vehicle
    public method ringBell()
        print "Ring! Ring!"
end class

Polymorphism (Greek for "many forms") is the ability of different objects to respond to the same method call in their own unique way.

class Animal
    public method speak()
        print "Generic sound"
end class

class Dog extends Animal
    // Overriding Base Method
    override method speak()
        print "Woof!"
end class

class Cat extends Animal
    // Overriding Base Method
    override method speak()
        print "Meow!"
end class

Abstraction is the process of hiding the internal details and complexity of a system, showing only the essential features to the outside world. It helps reduce programming complexity.

In software design, abstraction is achieved using **Abstract Classes** and **Abstract Methods**:

• An **Abstract Class** is a class that cannot be instantiated directly. It serves as a placeholder containing abstract definitions.
• An **Abstract Method** is a method declared in an abstract class without any implementation body. Subclasses must implement it.

abstract class Appliance
    // Abstract method: no body defined
    abstract method turnOn()
    
    // Non-abstract method
    public method setPowerRating(watts)
        rating = watts
    end method
end class

An Interface is a formal contract that defines a set of behaviors (methods) without providing any implementation code. It specifies *what* a class should do, but not *how* to do it.

Unlike abstract classes, interfaces do not maintain instance states (they have no attributes/fields) and are used to build decoupled software systems.

interface Printable
    method printDocument()
end interface

class Invoice implements Printable
    public method printDocument()
        print "Printing invoice receipt details..."
    end method
end class

Composition is a design principle where a complex object is constructed by combining one or more simpler object instances. This forms a "has-a" relationship (e.g., a Car *has an* Engine).

class Engine
    public method start()
        print "Engine starts vroom!"
end class

class Car
    // Composition: Car contains an instance of Engine
    private attribute engine: Engine

    constructor()
        engine = new Engine()
    end constructor

    public method drive()
        engine.start()
        print "Car is driving."
    end method
end class

Let's combine all of these pillars into a conceptual, comprehensive model of an **E-Commerce Checkout System**. Notice how inheritance, interfaces, and composition cooperate:

interface PaymentProcessor
    method processPayment(amount)
end interface

class CreditCardProcessor implements PaymentProcessor
    public method processPayment(amount)
        print "Processing card transaction of $" + amount
    end method
end class

class Order
    // Composition: Order contains customer name and payment processor
    private attribute customerName: String
    private attribute processor: PaymentProcessor
    private attribute total: Decimal

    constructor(name, paymentProcessor, amount)
        customerName = name
        processor = paymentProcessor
        total = amount
    end constructor

    public method checkout()
        print "Checking out order for: " + customerName
        // Polymorphism: processor execution varies depending on instance type
        processor.processPayment(total)
    end method
end class

Read through the design scenarios below and identify the correct object-oriented principles or solutions.

Test your understanding of Object-Oriented Programming concepts with this interactive quiz.