Object-Oriented Programming

Core Concepts

Core Concepts

1. Classes and Objects

• Class: A blueprint for creating objects. It defines the properties (attributes) and behaviors (methods) that its objects will have. For example, a Car class could define properties like color and maxSpeed, and methods like startEngine() and accelerate().
• Object: An instance of a class. If Car is the blueprint, then a specific red Ferrari is an object (an instance) created from that blueprint.

2. The Four Pillars of OOP

• Encapsulation: The bundling of data (attributes) and the methods that operate on that data into a single unit (a class). It also involves restricting direct access to some of an object's components, which is a key part of data hiding.
  • Access Modifiers: Keywords like public, private, and protected control the visibility of attributes and methods.
• Abstraction: Hiding complex implementation details and showing only the essential features of the object. When you drive a car, you use the steering wheel and pedals; you don't need to know the complex mechanics of the engine. That's abstraction.
• Inheritance: A mechanism where a new class (subclass or derived class) inherits attributes and methods from an existing class (superclass or base class). This promotes code reuse. For example, ElectricCar and Truck classes could inherit from a general Vehicle class.
• Polymorphism: The ability of a message to be displayed in more than one form. It allows objects of different classes to be treated as objects of a common superclass. The most common use of polymorphism is when a parent class reference is used to refer to a child class object.
  • Method Overriding: A subclass provides a specific implementation of a method that is already provided by its parent class.
  • Method Overloading: Defining multiple methods with the same name but with different parameters within the same class.

3. Other Key Concepts

• Constructor: A special method for creating and initializing an object instance of that class.
• Destructor: A special method that is automatically called when an object is destroyed.

Examples & Use Cases

Examples & Use Cases

A Simple Class in Python

class Dog:
    # This is the constructor
    def __init__(self, name, age):
        self.name = name  # Attribute
        self.age = age    # Attribute

    # This is a method
    def bark(self):
        return "Woof!"

# Creating objects (instances) of the Dog class
my_dog = Dog("Rex", 5)
another_dog = Dog("Buddy", 2)

print(f"{my_dog.name} says: {my_dog.bark()}")
# Output: Rex says: Woof!

Inheritance in Java

// Superclass
class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

// Subclass
class Cat extends Animal {
    // Method Overriding
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Cat myCat = new Cat();
        myAnimal.makeSound(); // Outputs: Some generic animal sound
        myCat.makeSound();    // Outputs: Meow
    }
}

Practice Questions

Practice Questions

1. MCQ: Which OOP principle is primarily about bundling data and methods together? A) Inheritance B) Polymorphism C) Abstraction D) Encapsulation

2. Short Answer: Explain the difference between a class and an object using a real-world analogy (other than a car or dog).

3. Coding Task: Create a Shape superclass with a method called getArea(). Then, create two subclasses, Circle and Rectangle, that inherit from Shape and override the getArea() method to calculate their specific area.

Quick Summary

Quick Summary

• OOP models software using objects and classes.
• A class is a blueprint; an object is an instance of that blueprint.
• Encapsulation bundles data and methods, hiding complexity.
• Abstraction shows essential features while hiding implementation details.
• Inheritance allows classes to inherit properties and behaviors from other classes, promoting code reuse.
• Polymorphism allows objects to take on many forms, enabling flexibility.