11.2. Four Pillars of OOP

Encapsulation is the process of bundling data and methods that operate on the data within a single unit (class), and restricting access to some of the object’s components.

• Access Modifiers: private, public, protected
• Getters and Setters: Used to access private variables

Benefits:

• Data hiding
• Improved code maintainability

Example (Java):

class Employee {
private int salary;
public void setSalary(int s) {
salary = s;
}
public int getSalary() {
return salary;
}
}

Encapsulation is a fundamental concept in OOP where the internal state of an object is protected from outside interference. By bundling the data (attributes) and methods (functions) that operate on that data into a single unit known as a class, developers can control who can access and modify the data. Access modifiers such as 'private' (only accessible within the same class), 'public' (accessible from anywhere), and 'protected' (accessible to subclasses) help enforce these rules. In the provided Java example, the 'Employee' class encapsulates the 'salary' field, preventing direct access from outside the class and providing methods (getters and setters) to manipulate the salary safely.

Think of encapsulation like a personal safe. You can store sensitive documents (data) in the safe, and you control who has the key (access). Just like you use a lock (access modifiers) to keep your documents safe, encapsulation protects an object's data from unwanted access or modification, ensuring that the data's integrity is maintained.

Inheritance allows a class (subclass/derived class) to inherit fields and methods from another class (superclass/base class).

• Promotes code reusability
• Supports hierarchical classification

Example (Java):

class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog barks.");
}
}

Inheritance is a mechanism in OOP that enables a new class (subclass or derived class) to inherit properties and behavior (methods) from an existing class (superclass or base class). This promotes code reusability because common functionalities are defined in the superclass and reused in the subclass without rewriting the code. In the example provided, the 'Animal' class contains a method 'eat', which is inherited by the 'Dog' class. This means that the 'Dog' class can use the 'eat' method without redefining it, making it easy to add new animal types while maintaining shared behavior.

Consider a family tree where children inherit traits from their parents. Just as children may have their parents' eye color or hair type (attributes), they also learn behaviors, such as how to cook or a skill for music (methods). The subclass 'Dog' inherits the eating behavior from the 'Animal' class, illustrating how inheritance allows for shared characteristics in a hierarchical manner.

Polymorphism allows objects to be treated as instances of their parent class rather than their actual class.

• Compile-time Polymorphism (Method Overloading)
• Runtime Polymorphism (Method Overriding)

Example (Method Overriding in Java):

class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Cat extends Animal {
void sound() {
System.out.println("Meow");
}
}

Polymorphism is an OOP principle that means 'many shapes' or 'many forms.' It allows methods or objects to be processed in different ways based on their context. The two types of polymorphism include compile-time polymorphism (achieved through method overloading, where multiple methods have the same name but different parameters) and runtime polymorphism (achieved through method overriding, where a subclass provides a specific implementation of a method already defined in its superclass). In the shown example, the 'sound' method is defined in the 'Animal' class and overridden in the 'Cat' class. At runtime, if a 'Cat' object calls 'sound', it will output 'Meow' instead of 'Animal makes a sound'.

Think of polymorphism like a Swiss army knife. It has various tools that can be used for different tasks. Depending on the situation, you might need to use the knife, the screwdriver, or the scissors (method overloading). Similarly, when you call a function, the specific behavior can change based on the object you are working with—like using the knife tool for cutting and the screwdriver tool for screwing.

Abstraction means hiding internal implementation and showing only the essential features.

• Achieved using abstract classes or interfaces
• Helps reduce complexity

Example (Java):

abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing Circle");
}
}

Abstraction is an OOP principle that focuses on hiding the complex reality while exposing only the necessary parts. Instead of worrying about the intricate details of how a function works, the user interacts with the function through a defined interface. This is often implemented using abstract classes and interfaces in languages like Java. In the provided example, the 'Shape' class is abstract and defines the 'draw' method, which must be implemented by any concrete subclass like 'Circle'. This way, the user of the 'Shape' class doesn’t need to understand how the 'draw' function works in detail; they only need to know that they can call it.

Imagine driving a car. You don’t need to know how the engine works or how fuel combustion happens to operate it. As the driver, you interact with the steering wheel, pedals, and buttons, which abstract away the complexities of the mechanics (internal implementation). Just as you use an abstract class or interface to interact with the car without knowing its inner workings, abstraction in programming helps simplify usage while maintaining functionality.

--