Object-Oriented Programming

Object-Oriented Programming (OOP): A Comprehensive Guide

Object-oriented programming (OOP) is a widely used programming paradigm that organizes software design around data objects rather than functions and logic. OOP focuses on the concepts of classes and objects, which allows for more modular, reusable, and scalable code.

OOP organizes software design around these objects, which interact with one another to perform tasks. Each object can store data in fields and execute operations using methods. This modular approach allows for greater flexibility and easier troubleshooting, as individual objects can be modified without affecting the entire system.

One of the primary benefits of OOP is that it promotes code reuse. By creating general templates, or classes, for objects, developers can generate multiple instances of these objects without duplicating code. This leads to more efficient and manageable codebases.

OOP also enhances software maintainability. Since objects are self-contained, changes to one part of the system can be made with minimal impact on other parts. This isolation reduces the risk of bugs and makes it easier to understand and modify existing code. Overall, OOP provides a robust framework for building scalable, maintainable, and reusable software systems.

Key Concepts of OOP

Object :

An object is an instance of a class. It is a specific realization of the class with actual values for the attributes defined by the class. Each object created from the class can have different attribute values, but they share the same structure and behavior as defined by the class.

Class :

A class in object-oriented programming is a blueprint for creating objects. It defines a set of attributes and methods that the created objects will have. A class encapsulates data for the object and methods to manipulate that data. It serves as a blueprint for how an object should behave and what properties it should have.

Example :

Public class Vehicle {
        
        String make;
        String model;
        int year;
    
        public Vehicle(String make, String model, int year) {
            this.make = make;
            this.model = model;
            this.year = year;
        }
    
        public void displayDetails() {
            System.out.println("Make: " + make);
            System.out.println("Model: " + model);
            System.out.println("Year: " + year);
        }
    
        public static void main(String[] args) {
            
            Vehicle myCar = new Vehicle("Toyota", "Corolla", 2021);
    
            
            myCar.displayDetails();
        }
    }

Explanation of the code :

The vehicle class is defined with attributes make, model, and year, and methods such as the constructor and 'display details'.
'myCar' is an object of the vehicle class.
'myCar' is an instance of the vehicle class with specific values for make, model, and year. The 'displayDetails' method is then called on 'myCar' to print these values.

The statement 'public class vehicle { ... }' declares a public class named 'vehicle'.

The statements ' String makes; ', ' String model;', and ' int year;' are instance variables that hold the make, model, and year of the vehicle, respectively.
The statement ' public vehicle(String make, String model, int year) { ... }' is a constructor method that initializes a new instance of the `vehicle` class with the specified make, model, and year. The constructor assigns the passed parameters to the instance variables.
The statement ' public void displayDetails() { ... }' defines a method that prints the details of the vehicle to the console. It outputs the make, model, and year of the vehicle.
The statement ' public static void main(String[] args) { ... }' defines the main method, which is the entry point of the program. When the program runs, the code inside this method is executed.
The statement 'vehicle myCar = new vehicle("Toyota", "Corolla", 2021);' creates a new instance of the 'vehicle ' class named 'myCar ' with the make "Toyota", model "Corolla", and year 2021.
The statement 'myCar.displayDetails();' calls the 'displayDetails' method on the ' myCar ' instance, which prints the vehicle details to the console.

Inheritance :

Inheritance is a core principle of object-oriented programming (OOP), where a new class, known as a derived or child class, is created based on an existing class, known as a base or parent class. The child class inherits fields and methods from the parent class, allowing it to reuse, extend, or modify the behavior defined in the parent class.

Here are key aspects of inheritance:

Inheritance allows a new class to reuse the properties and methods of an existing class, reducing redundancy and promoting code reuse.

It helps in establishing a natural hierarchical relationship between classes, modeling real-world relationships more effectively.

A derived class can extend or modify the behavior of the base class, enabling the addition of new features without altering existing code.

Inheritance supports polymorphism, where a base class reference can refer to an object of a derived class, allowing for writing more flexible and generalized code.

Example :

Class name : Vehicle.java

public class vehicle {

    String make;
    String model;
    int year;

    public vehicle(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    public void displayDetails() {
        System.out.println("Vehicle Details: ");
        System.out.println("Make: " + make);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }

    public static void main(String[] args) {

        // Create an instance of Vehicle
        vehicle myVehicle = new vehicle("Toyota", "Corolla", 2021);
        myVehicle.displayDetails();
        
        // Create an instance of Car
        Car myCar = new Car("Honda", "Civic", 2022, 4);
        myCar.displayDetails();
        myCar.displayCarDetails(); 
    }
}

    
    

Explanation of the code :

The statement 'public class Vehicle { ... }' defines a public class named Vehicle.
The statements 'String make;, String model;, and int year;' declare the attributes that store the make, model, and year of the vehicle.
The statement ' public Vehicle(String make, String model, int year) { ... } ' is the constructor that initializes the attributes make, model, and year when a new Vehicle object is created.
The statement 'public void displayDetails() { ... }' defines a method that prints the details of the vehicle to the console.
The statement ' public static void main(String[] args) { ... }' creates an instance of Vehicle and an instance of Car, and then displays their details by calling the 'displayDetails' and 'displayCarDetails' methods.

Class name : Car.java

public class Car extends vehicle {

    int numberOfDoors;

    public Car(String make, String model, int year, int numberOfDoors) {

        // Call the constructor of the superclass (Vehicle)
        super(make, model, year); 
        this.numberOfDoors = numberOfDoors;
    }

    public void displayCarDetails() {
        System.out.println("Number of Doors: " + numberOfDoors);
    }
}

Explanation of the code :

The statement 'public class Car extends Vehicle { ... }' defines a public class named 'Car ' that extends the 'Vehicle' class, indicating that 'Car ' is a subclass of 'Vehicle'.
The statement 'int numberOfDoors;' declares an additional attribute specific to the `Car` class that stores the number of doors.
The statement 'public Car(String make, String model, int year, int numberOfDoors) { ... }' initializes the 'make', 'model', and 'year' attributes using the superclass constructor 'super(make, model, year)', and initializes the 'numberOfDoors' attribute.
The statement 'public void displayCarDetails() { ... }' defines a method that prints the number of doors specific to the 'Car' class.

The 'Vehicle' class defines common attributes and methods for all vehicles. The 'Car' class inherits from 'Vehicle' and adds an attribute specific to cars. The main method in 'Vehicle' demonstrates the creation and usage of both 'Vehicle' and 'Car' objects, displaying their details.

The output of the code will display :

Vehicle Details:

Make: Toyota

Model: Corolla

Year: 2021

Vehicle Details:

Make: Honda

Model: Civic

Year: 2022

Number of Doors: 4

Polymorphism :

Compile-time Polymorphism:

Method overloading allows different methods to have the same name but differ in parameter lists within the same class. The method to be executed is resolved at compile time.

Advantages:

Improves code readability and reusability.
Reduces method names by allowing methods with different parameters.

Example :

Class name : Example.java

public class Example {
    
    public void display(int num) {
        System.out.println("Number: " + num);
    }

    public void display(String message) {
        System.out.println("Message: " + message);
    }

    public static void main(String[] args) {
        Example example = new Example();
        example.display(10);
        example.display("Hello");
    }
}

Explanation of the code :

The Example class has two display methods, each with a different parameter type (int and String).
This demonstrates method overloading, allowing the display method to handle different types of input.
The main method creates an Example object and calls the overloaded display methods with different arguments, showcasing their functionality.

The output of the code will display:

Number: 10

Message: Hello

Runtime Polymorphism:

Method overriding allows a subclass to provide a specific implementation of a method already provided by its parent class. The method to be executed is resolved at runtime.

Example :

Class name : Shape.java

public class Shape {
    
    public void draw() {
        System.out.println("Drawing a shape");
    }

    
    public static void main(String[] args) {
        
        Shape myShape = new Shape();
        Shape myCircle = new Circle();
        Shape myRectangle = new Rectangle();

        
        drawShape(myShape);
        drawShape(myCircle);
        drawShape(myRectangle);
    }

   
    public static void drawShape(Shape shape) {
        shape.draw();
    }
}


class Circle extends Shape {
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

Class name : Circle.java

public class Circle extends Shape {

    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

Class name : Rectangle.java

public class Rectangle extends Shape {

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

Explanation of the code :

The `Shape` class has a method named `draw()`, which simply prints "Drawing a shape".
There are classes named `Circle` and `Rectangle`, both of which extend the `Shape` class. They inherit the `draw()` method from the `Shape` class but provide their own implementations.
Inside the `main` method, instances of `Shape`, `Circle`, and `Rectangle` are created. `myCircle` and `myRectangle` are created as instances of their respective subclasses but referenced by the `Shape` class.
There's a static method named `drawShape()` that accepts a parameter of type `Shape`. It calls the `draw()` method on the provided `Shape` object.
When `drawShape()` is called with `myShape`, it calls the `draw()` method of the `Shape` class, printing "Drawing a shape".
When `drawShape()` is called with `myCircle` and `myRectangle`, it calls the overridden `draw()` methods of the `Circle` and `Rectangle` classes, respectively, printing specific messages related to drawing a circle and a rectangle.

The output of the code will display :

Drawing a shape

Drawing a circle

Drawing a rectangle

Encapsulation :

Encapsulation is one of the four fundamental principles of object-oriented programming. It is the practice of bundling data (variables) and methods (functions) that operate on the data into a single unit or class and restricting access to some of the object's components.

This is usually achieved using access modifiers to control the visibility of the class members.

Access modifiers

Private: The member is accessible only within the same class.

Default (Package-Private): The member is accessible only within classes in the same package. If no access modifier is specified, this is the default.

Protected: The member is accessible within the same package and also in subclasses.

Public: The member is accessible from any other class.

Benefits of Encapsulation:

Encapsulation allows control over who can access and modify the data within an object.

By hiding the internal implementation details, encapsulation makes it easier to change and maintain the code.

Encapsulation enables the addition of validation logic within setter methods to ensure the object’s state remains valid.

Example :

public class Person {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Age must be positive");
        }
    }
    public void displayDetails() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    
    public static void main(String[] args) {
        
        Person person = new Person("Alice", 25);

        // Accessing private fields through public methods
        System.out.println("Initial details:");
        person.displayDetails();

        // Modifying fields through setter methods
        person.setName("Bob");
        person.setAge(30);

        System.out.println("\nUpdated details:");
        person.displayDetails();

        // Trying to set an invalid age
        person.setAge(-5); 
}

Explanation of the code :

The fields `name` and `age` are declared as private. This means they cannot be accessed directly from outside the `Person` class. Direct access to these fields is restricted to ensure that the values can only be changed or retrieved in controlled ways.
Public methods `getName()` and `getAge()` are provided to allow controlled access to the private fields `name` and `age`. These methods return the current value of the fields.
Public methods `setName()` and `setAge()` are provided to allow controlled modification of the private fields. The `setAge()` method includes validation logic to ensure that the age cannot be set to a negative value.
The setter methods enforce rules on how the fields can be modified. For example, the `setAge()` method includes a check to ensure the age is positive. If an invalid value is provided, an error message is printed, and the age is not updated.

Abstraction :

Abstraction is the concept of hiding the complex implementation details and showing only the essential features of the object. It simplifies the interaction with objects by providing a clear and simple interface. This makes the system easier to understand and use.

Key Points of Abstraction:

Abstraction hides the internal workings of objects and only exposes the functionalities that are necessary for the user. This makes it easier to interact with the object without needing to understand how it works internally.

By providing a clear and simple interface, abstraction promotes code reusability. Developers can use abstract classes and interfaces to create flexible and reusable code components.

With abstraction, changes in the implementation do not affect the code that uses the abstracted functionality. This enhances the maintainability of the codebase.

By restricting access to the internal data and exposing only what is necessary, abstraction helps in protecting the integrity of the data.

Abstraction Mechanisms in OOP :

Abstract Classes:

Abstract classes cannot be instantiated directly. They can include abstract methods (methods without implementation) that must be implemented by derived classes.

Abstract classes can also include concrete methods (methods with implementation).

Example :

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // Abstract method
    public abstract void makeSound();
 }

class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {

    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("Buddy");
        Animal cat = new Cat("Whiskers");

        System.out.println(dog.getName() + " says:");
        dog.makeSound();

        System.out.println(cat.getName() + " says:");
        cat.makeSound();
    }
}

Explanation of the code :

The `Animal` class is an abstract class with a constructor and a getter for the `name` property. It contains an abstract method `makeSound()`, which must be implemented by any subclass.
The `Dog` and `Cat` classes extend the `Animal` class and provide specific implementations of the `makeSound()` method.
In the `main` method, we create instances of `Dog` and `Cat` using the `Animal` reference. When `makeSound()` is called on each instance, the appropriate implementation for each subclass is executed.

Interfaces :

Interfaces define a contract that implementing classes must follow. They contain only method signatures (no implementation).

A class can implement multiple interfaces, allowing for flexible and modular design.

Example :

interface Shape {
    double calculateArea();
    double calculatePerimeter();
}

class Circle implements Shape {

    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * (length + width);
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        System.out.println("Circle area: " + circle.calculateArea());
        System.out.println("Circle perimeter: " + circle.calculatePerimeter());

        System.out.println("Rectangle area: " + rectangle.calculateArea());
        System.out.println("Rectangle perimeter: " + rectangle.calculatePerimeter());
    }
}

Explanation of the code :

The `Shape` interface defines two methods: `calculateArea()` and `calculatePerimeter()`. These methods must be implemented by any class that implements the `Shape` interface.
The `Circle` and `Rectangle` classes implement the `Shape` interface and provide specific implementations for the `calculateArea()` and `calculatePerimeter()` methods.
In the `main` method, we create instances of `Circle` and `Rectangle` using the `Shape` reference. The `calculateArea()` and `calculatePerimeter()` methods are called on each instance, demonstrating how the same interface can be used to work with different shapes.

Advantages of Object Oriented Programming

Code is organized into independent units (classes), making it easier to manage and understand.

Classes can be reused in different parts of a program or in other projects, saving development time.

Data and methods are bundled together, protecting the internal state of objects and simplifying the interface.

New classes can inherit properties and methods from existing classes, promoting code reuse and reducing duplication.

Objects of different classes can be treated as objects of a common superclass, enhancing flexibility and integration.

Complex details are hidden, showing only the necessary features, making interactions with objects simpler.

The modular structure makes code easier to update and maintain, with minimal impact on the rest of the system.

Multiple developers can work on different parts of a project simultaneously, improving teamwork.

OOP makes it easier to manage and expand the codebase as the project grows, allowing for new features to be added seamlessly.

OOP models real-world entities, making it easier to conceptualize and map software solutions to real-world problems.

For more detailed information on OOP concepts, you can refer to this https://www.w3schools.com/java/java_oop.asp

Search This Blog

The Frontier of Tech Discoveries