Object Oriented Programming

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data in the form of fields (often known as attributes or properties) and code in the form of procedures (often known as methods).

In OOP, programs are designed by making them out of a collection of interacting objects, rather than a flat set of functions. Each object is a self-contained unit that represents a real-world entity or a conceptual entity. This approach helps in organizing complex software into smaller, manageable, and reusable components.

The core principles of OOP are:

• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

Let's explore each of these concepts in detail.

Class

A class is a blueprint or a template for creating objects. It defines the properties (data members or attributes) and behaviors (member functions or methods) that all objects of that type will have. Think of a class as a cookie cutter, and the objects created from it as the cookies themselves.

A class acts as a user-defined data type. It bundles together data and the functions that operate on that data into a single unit. When you define a class, you are essentially specifying how an object of that class should be structured and what it can do.

Example: Consider a `Car` class.

• Attributes (Data Members): `color`, `model`, `year`, `speed`.
• Methods (Member Functions): `startEngine()`, `accelerate()`, `brake()`, `changeGear()`.

The class `Car` defines what all cars will have (color, model, etc.) and what they can do (start, accelerate, etc.). However, the class itself doesn't represent a specific car; it's just the definition.

Object

An object is an instance of a class. It is a concrete realization of the blueprint defined by the class. When you create an object from a class, you are creating a specific entity with its own set of data (attribute values) and the ability to perform the actions defined by the class's methods.

Each object created from the same class will have the same structure (same attributes and methods), but their attribute values can be different. For example, you can create multiple car objects from the `Car` class, each with a different color, model, and current speed.

Example: Creating objects from the `Car` class.

• `myCar` (an object of `Car`): `color` = "Red", `model` = "Sedan", `year` = 2023.
• `yourCar` (another object of `Car`): `color` = "Blue", `model` = "SUV", `year` = 2022.

Both `myCar` and `yourCar` are instances of the `Car` class. They share the same structure and can perform the same actions, but they are distinct entities with their own unique states (attribute values).

In programming, creating an object is often referred to as "instantiation".

Encapsulation

Encapsulation is the bundling of data (attributes) and methods (functions) that operate on the data into a single unit, called a class. It is a mechanism of hiding the internal state and implementation details of an object from the outside world and only exposing the necessary functionalities through an interface.

The primary goals of encapsulation are:

• Data Hiding: To protect an object's internal data from accidental or intentional modification by external code. This is usually achieved using access modifiers like `private`.
• Modularity: To make objects self-contained, which improves code organization and maintainability.
• Flexibility and Maintainability: The internal implementation of a class can be changed without affecting the code that uses the class, as long as the public interface remains the same.

Encapsulation is often implemented using getter and setter methods. Getter methods are used to retrieve the value of an attribute, and setter methods are used to modify it. These methods provide controlled access to the data.

Example: In the `Car` class, the `speed` attribute could be made `private`. To change the speed, you would use a `setSpeed()` method, and to get the current speed, you would use a `getSpeed()` method.

private int speed;

public void setSpeed(int newSpeed) { this.speed = newSpeed; }

public int getSpeed() { return this.speed; }

By making `speed` private, external code cannot directly set an invalid speed (e.g., a negative speed). The `setSpeed()` method can include validation logic to ensure the speed remains within valid bounds.

Inheritance

Inheritance is a mechanism that allows a new class (called a subclass or derived class) to inherit properties and behaviors from an existing class (called a superclass or base class). This promotes code reusability and establishes a relationship between classes, often referred to as an "is-a" relationship.

The subclass can use the inherited members as they are, or it can override them (provide its own implementation) or add new members. This allows for the creation of a hierarchy of classes, where more specialized classes inherit from more general ones.

Benefits of Inheritance:

• Code Reusability: Common attributes and methods can be defined in a base class and reused by multiple derived classes.
• Extensibility: New functionalities can be added to existing classes without modifying their source code.
• Hierarchical Classification: Creates a natural structure for representing relationships between different types of objects.

Example: Consider a base class `Vehicle`.

• Vehicle class attributes: `brand`, `model`, `year`.
• Vehicle class methods: `startEngine()`, `stopEngine()`.

Now, we can create derived classes like `Car`, `Motorcycle`, and `Truck` that inherit from `Vehicle`.

• The `Car` class inherits `brand`, `model`, `year`, `startEngine()`, `stopEngine()`.
• The `Car` class can add its own specific attributes like `numberOfDoors` and methods like `openTrunk()`.
• A `Car` might override the `startEngine()` method to provide a specific way a car's engine starts.

In Java, inheritance is achieved using the `extends` keyword:

class Car extends Vehicle { ... }

In C++, it's done using colons:

class Car : public Vehicle { ... };

Polymorphism

Polymorphism, meaning "many forms," is an OOP concept that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms (data types). This means that a method call can behave differently depending on the object it is called on.

There are two main types of polymorphism:

1. Compile-time Polymorphism (Static Polymorphism): Achieved through method overloading and operator overloading. The decision of which method or operator to call is made during compile time.
2. Run-time Polymorphism (Dynamic Polymorphism): Achieved through method overriding. The decision of which method to call is made during run time, based on the actual type of the object.

Method Overriding (Run-time Polymorphism):

When a subclass provides a specific implementation for a method that is already defined in its superclass, it is called method overriding. The method in the subclass must have the same name, same parameters, and same return type (or a covariant return type) as the method in the superclass.

Example:

Consider a `Shape` class with a method `draw()`.

• `Shape` class (superclass): `draw()` method prints "Drawing a generic shape."
• `Circle` class (subclass of `Shape`): Overrides `draw()` to print "Drawing a circle."
• `Square` class (subclass of `Shape`): Overrides `draw()` to print "Drawing a square."

If you have a list of `Shape` objects, and you iterate through them calling the `draw()` method on each, the correct `draw()` method (for `Circle`, `Square`, etc.) will be executed at runtime.

Shape myShape = new Circle();

myShape.draw(); // This will call the draw() method of Circle

Method Overloading (Compile-time Polymorphism):

Method overloading occurs when a class has multiple methods with the same name but different parameter lists (different number of parameters, different types of parameters, or both). The compiler determines which method to call based on the arguments provided during the method call.

Example:

A class `Calculator` might have overloaded `add()` methods:

• `add(int a, int b)`: Returns the sum of two integers.
• `add(double a, double b)`: Returns the sum of two doubles.
• `add(int a, int b, int c)`: Returns the sum of three integers.

The compiler selects the correct `add` method based on the types and number of arguments passed.

Abstract Classes

An abstract class is a class that cannot be instantiated on its own. It is meant to be a superclass for other classes. Abstract classes are declared using the `abstract` keyword.

Abstract classes can have both abstract methods and concrete methods. An abstract method is a method declared without an implementation (no method body). It is declared using the `abstract` keyword. Any class that inherits from an abstract class must provide an implementation for all its abstract methods, unless the subclass is also declared abstract.

Purpose of Abstract Classes:

• Define a Common Interface: They enforce a common structure and behavior for their subclasses.
• Partial Implementation: They can provide some common functionality (concrete methods) while requiring subclasses to provide specific implementations for other functionalities (abstract methods).
• Code Reusability: Concrete methods in an abstract class can be reused by all its subclasses.

Example:

Let's revisit the `Shape` example. We can make `Shape` an abstract class.

abstract class Shape {

// Concrete method

public void displayInfo() {

System.out.println("This is a shape.");

}

// Abstract method - no implementation

public abstract void draw();

}

Now, any class that extends `Shape` must implement the `draw()` method:

class Circle extends Shape {

@Override

public void draw() {

System.out.println("Drawing a circle.");

}

}

class Square extends Shape {

@Override

public void draw() {

System.out.println("Drawing a square.");

}

}

You cannot create an object of `Shape` directly:

Shape s = new Shape(); // This will cause a compile-time error.

However, you can create objects of `Circle` and `Square` and use them as `Shape` references:

Shape c = new Circle();

Shape sq = new Square();

c.draw(); // Calls Circle's draw()

sq.displayInfo(); // Calls Shape's displayInfo()

Abstraction

Abstraction is the concept of showing only essential features of an object and hiding unnecessary details. It focuses on "what" an object does rather than "how" it does it. Abstraction helps in managing complexity by allowing us to think about objects at a higher level of detail.

Abstraction is closely related to encapsulation, but they are not the same. Encapsulation is about bundling data and methods and controlling access. Abstraction is about hiding complex implementation details and showing only the necessary functionality.

Abstract classes and interfaces are mechanisms used to achieve abstraction in programming languages.

Example:

Consider driving a car. When you drive, you use the steering wheel, accelerator, and brakes. You don't need to know the intricate details of how the engine works, how the fuel injection system operates, or how the braking system applies pressure.

• Essential Features (Abstraction): Steering wheel, accelerator pedal, brake pedal.
• Hidden Details (Implementation): Engine combustion, transmission gears, hydraulic brake lines.

The car's interface (steering, pedals) provides an abstraction of its complex internal workings. You interact with the car through this simplified interface.

In programming, when you use a library or an API, you are interacting with an abstraction. You know what functions to call and what they do, but you don't necessarily need to understand the internal code that makes them work.