OOPS in Java

In Java, classes and objects are core concepts of Object-Oriented Programming (OOP), used to represent real-world entities and behaviors. A class acts as a blueprint for creating objects, while an object is an instance of a class. For example, “Dog” can be considered a class, while a specific dog named “Bruno” would be an object of that class.

In this article, we’ll explore Java classes, objects, and how to implement them in your programs.

Java Classes

A class in Java is a collection of objects with common properties and behaviors. It is essentially a user-defined prototype from which objects are created. For instance, “Car” is a class, while “BMW” is an object.

Properties of Java Classes

• A class is not a physical entity but a blueprint used to create objects.
• A class itself does not occupy memory; only objects do.
• It groups variables (attributes) and methods (behaviors) under a common structure.

A class in Java can include the following components:

• Data members (variables)
• Methods
• Constructors
• Nested Classes
• Interfaces

Class Declaration in Java

access_modifier class ClassName {
    // variables (data members)
    // methods
    // constructors
    // nested classes
    // interfaces
}

In this example, the Student class has two data members, id and name, with default values 0 and null, respectively.

Components of Java Classes

A class declaration typically contains the following:

• Modifiers: A class can be public or have default access.
• Class keyword: Used to declare a class.
• Class name: Starts with an uppercase letter by convention.
• Superclass: The parent class (if any), specified with the extends keyword.
• Interfaces: Any implemented interfaces, separated by commas and declared with the implements keyword.
• Body: The class body is enclosed in curly braces {}.

Constructors

Constructors initialize new objects. They have the same name as the class and no return type. Fields (data members) define the state of objects, while methods define the behavior.

Java Objects

An object in Java is an instance of a class, representing a specific entity or concept. Each object has:

• State: Represented by the attributes (data members) of the object.
• Behavior: Represented by the methods of the object.
• Identity: A unique identifier that allows interaction between different objects.

For example, in a shopping system, objects could include “ShoppingCart”, “Product”, and “Customer”.

Declaring and Initializing Java Objects

When an object is created, the class is instantiated. The values of the object’s attributes (state) are unique for each instance.

Dog myDog; // Declaration
myDog = new Dog(); // Instantiation

Example of an Object Initialization

public class Dog {
    // Instance variables
    String name;
    String breed;
    int age;
    String color;

    // Constructor
    public Dog(String name, String breed, int age, String color) {
        this.name = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    }

    @Override
    public String toString() {
        return "My dog's name is " + name + ", breed: " + breed + ", age: " + age + ", color: " + color;
    }

    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy", "Golden Retriever", 3, "Golden");
        System.out.println(myDog.toString());
    }
}

Output:

My dog's name is Buddy, breed: Golden Retriever, age: 3, color: Golden

Memory Allocation in Java Objects

When an object is created, it is allocated memory on the heap. All classes have at least one constructor; if none is explicitly defined, Java provides a default constructor.

Methods to Create Objects

There are several ways to create objects in Java:

1. Using the new keyword:

Car myCar = new Car();

2. Using Class.forName(String className):

Car obj = (Car)Class.forName("com.example.Car").newInstance();

3. Using clone() method:

Car car1 = new Car();
Car car2 = (Car)car1.clone();

4. Using Deserialization:

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Car car = (Car)in.readObject();

Anonymous Objects

Anonymous objects are objects created without a reference and are often used for immediate method calls. These objects are destroyed after the method call completes.

new Car().drive();

Difference Between Class and Object

A method in Java is a collection of statements designed to perform a specific task and, optionally, return a result. Methods can also execute tasks without returning any value. By using methods, Java allows code reuse, eliminating the need to rewrite similar logic multiple times. Unlike languages such as C, C++, or Python, every method in Java must belong to a class.

Key Points about Methods:

• A method is similar to a function and is used to describe the behavior of an object.
• It is a block of code that performs a particular task.

Syntax of a Method:

<access_modifier> <return_type> <method_name>(list_of_parameters) {
    // body of the method
}

Advantages of Methods:

• Code Reusability: Methods allow code to be written once and reused as needed, saving time and effort.
• Code Optimization: Methods simplify complex operations and improve the structure of the code.

Method Declaration

A method declaration generally has six components:

1. Modifier: Defines the access level of the method (e.g., public, private, protected, default).

• public: Accessible in all classes.
• protected: Accessible within the class and its subclasses.
• private: Accessible only within the defining class.
• default: Accessible within the same class and package, with no modifier.

2. Return Type: Specifies the data type of the value returned by the method or void if no value is returned.
3. Method Name: The name given to the method, following the same rules as variable names but typically being a verb. It is required.
4. Parameter List: A comma-separated list of input parameters (preceded by their data types). If no parameters are needed, empty parentheses are used. This is optional.
5. Exception List: Specifies any exceptions the method can throw. This is optional.
Method Body: The actual code executed by the method, enclosed in braces. This is also optional.

Types of Methods in Java

1. Predefined Methods: These are methods already provided by Java libraries, also known as standard or built-in methods. We can directly call these methods within our program.

2. User-defined Methods: Methods written by the programmer, tailored to specific tasks according to the program’s needs.

Ways to Create Methods in Java

1. Instance Methods: Access instance data using the object name. These methods are declared within a class.

void methodName() {
    // method body
}

2. Static Methods: Access static data using the class name. These methods are declared with the static keyword.

static void methodName() {
    // method body
}

Method Signature

A method signature consists of the method name and its parameter list (the number, type, and order of parameters). The return type and exceptions are not part of the method signature.

Example:

int max(int x, int y)  // Method signature

In this example, the method max has two parameters of type int.

Naming a Method

The convention for naming methods in Java is to use verbs in lowercase or multi-word names starting with a verb. If the name contains multiple words, the first letter of each word after the first should be capitalized (CamelCase).

Rules:

• Method names should be verbs and start with a lowercase letter.
• If the method name contains more than one word, the first word must be a verb, followed by an adjective or noun.
• In multi-word names, capitalize the first letter of each subsequent word (e.g., findMax, computeSum).

Method Calling

Methods need to be called to execute. They can be called in three situations:

• The method completes all its statements.
• The method reaches a return statement.
• The method throws an exception.

Example:

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result = calc.add(5, 10);
        System.out.println("Sum: " + result);
    }
}

Output:

Sum: 15

Passing Parameters to Methods

Parameters can be passed in two ways:

1. Passing Arrays: Arrays can be passed as arguments to methods.

2. Varargs (Variable Arguments): When the number of parameters is unknown, we can use the varargs feature by specifying the parameter type followed by an ellipsis (...).

Method Overloading

Method overloading allows multiple methods with the same name but different parameter lists to coexist in the same class. This enables methods to handle various types of inputs.

Memory Allocation for Methods

Method calls are implemented using a stack. When a method is invoked, a stack frame is created to store its arguments, local variables, and return value. Once the method completes, its stack frame is removed from the stack.

Example:

class Example {
    private int number;
    private String name;

    // Getter and Setter methods
    public int getNumber() { return number; }
    public String getName() { return name; }

    public void setNumber(int number) { this.number = number; }
    public void setName(String name) { this.name = name; }

    // Other methods
    public void printDetails() {
        System.out.println("Number: " + number);
        System.out.println("Name: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Example example = new Example();
        example.setNumber(42);
        example.setName("Java Example");
        example.printDetails();
    }
}

Output:

Number: 42
Name: Java Example

Access modifiers in Java are essential for controlling the visibility and accessibility of classes, constructors, methods, variables, and data members. They provide a way to enforce security and manage how components of a program can interact with each other based on the access modifier used. In this section, we’ll explore the types of access modifiers available in Java, along with examples that demonstrate their use.

Types of Access Modifiers in Java

There are four access modifiers in Java:

1. Default (No keyword required)
2. Private
3. Protected
4. Public

1. Default Access Modifier

If no access modifier is specified, the default modifier is used. Members with the default access modifier are accessible only within the same package.

Example:

// Java program demonstrating default access modifier
package package1;

class ExampleClass {
    void showMessage() {
        System.out.println("This is a default access modifier example.");
    }
}

// Attempting to access a default class from another package
package package2;

import package1.*;

public class TestClass {
    public static void main(String[] args) {
        ExampleClass example = new ExampleClass(); // Compile-time error
        example.showMessage();
    }
}

Output:

Compile-time error

2. Private Access Modifier

The private keyword is used to restrict access to class members. Members declared as private are accessible only within the class where they are defined.

Example:

// Java program illustrating private access modifier
package package1;

class ExampleClass {
    private void displayMessage() {
        System.out.println("This is a private method.");
    }
}

public class TestClass {
    public static void main(String[] args) {
        ExampleClass example = new ExampleClass();
        example.displayMessage();  // Compile-time error
    }
}

Output:

error: displayMessage() has private access in ExampleClass
        example.displayMessage();

3. Protected Access Modifier

The protected keyword allows access to members within the same package and also in subclasses, even if they are in different packages.

Example:

// Package 1 - Parent class with protected method
package package1;

public class ParentClass {
    protected void displayMessage() {
        System.out.println("This is a protected method.");
    }
}

// Package 2 - Subclass inheriting from ParentClass
package package2;

import package1.ParentClass;

public class ChildClass extends ParentClass {
    public static void main(String[] args) {
        ChildClass child = new ChildClass();
        child.displayMessage();
    }
}

Output:

This is a protected method.

4. Public Access Modifier

The public keyword gives the widest access. Members declared as public can be accessed from any class, in any package.

Example:

// Java program demonstrating public access modifier
package package1;

public class ExampleClass {
    public void showMessage() {
        System.out.println("This is a public method.");
    }
}

// Accessing a public method from another package
package package2;

import package1.ExampleClass;

public class TestClass {
    public static void main(String[] args) {
        ExampleClass example = new ExampleClass();
        example.showMessage();
    }
}

Output:

This is a public method.

Key Points:

• Default access is package-private, meaning it’s accessible only within the same package.
• Private access is the most restrictive, limiting access only to the class in which the member is declared.
• Protected access allows visibility in the same package and in subclasses across different packages.
• Public access provides unrestricted access throughout the program.

Best Practices for Using Access Modifiers

• Always prefer the most restrictive access level for class members. For example, use private unless there’s a specific reason to expose a member.
• Avoid using public fields, as this breaks encapsulation. Instead, use getter and setter methods to control access to fields.

Algorithm for Using Access Modifiers in Java

1. Define the class: Create a class representing your object or functionality.
2. Declare instance variables: Define the data members that represent the object’s state.
3. Choose access modifiers:

• Use private for variables that should not be accessible outside the class.
• Use protected for variables that can be accessed by subclasses, even in different packages.
• Use public for variables that need to be accessed from any part of the program.
  Implement getter and setter methods: Even for public variables, it’s good practice to use accessors and mutators to control how values are accessed and modified.

4. Test visibility: Ensure that your chosen access levels make sense for the structure and interaction of your classes.

In Java, a constructor is a special type of method used to initialize an object. Constructors are called when an object of a class is created, allowing developers to set initial values for the object’s attributes.

Whenever you create an object using the new keyword, a constructor is invoked to allocate memory for the object and initialize it.

Understanding constructors can greatly enhance your Java programming skills, particularly when working with large applications. Mastery of constructors is crucial for developing scalable, maintainable code, serving as a stepping stone toward more advanced programming concepts.

Example of a Java Constructor

Below is a simple demonstration of how constructors work in Java:

// Java Program to demonstrate
// Constructor usage
public class MyClass {

    // Constructor
    MyClass() {
        System.out.println("Constructor called");
    }

    public static void main(String[] args) {
        // Creating an object which calls the constructor
        MyClass obj = new MyClass();
    }
}

Output:

Constructor called

Differences Between Constructors and Methods

• Name: A constructor must have the same name as the class, whereas methods can have any name.
• Return Type: Constructors do not have a return type, while methods can return values (or be void if they return nothing).
• Invocation: Constructors are called only once when an object is created, whereas methods can be called multiple times.

Syntax Example of a constructor:

class MyClass {
    // A constructor
    MyClass() {
        // Initialization code here
    }
}

// Creating an object, which invokes the constructor
MyClass obj = new MyClass();

Output:

Constructor called

Differences Between Constructors and Methods

• Name: A constructor must have the same name as the class, whereas methods can have any name.
• Return Type: Constructors do not have a return type, while methods can return values (or be void if they return nothing).
• Invocation: Constructors are called only once when an object is created, whereas methods can be called multiple times.

Syntax example of a constructor:

class MyClass {
    // A constructor
    MyClass() {
        // Initialization code here
    }
}

// Creating an object, which invokes the constructor
MyClass obj = new MyClass();

Why Do We Need Constructors?

Constructors are used to initialize objects at the time of creation. For example, if we think of a class that represents a box, it might have fields like length, breadth, and height. When an object of this class is created, it wouldn’t make sense for it to have undefined dimensions, so constructors ensure these values are set.

When Is a Constructor Called?

A constructor is called whenever an object is instantiated using the new keyword. Some rules for writing constructors include:

• The constructor must have the same name as the class.
• A constructor cannot be abstract, final, static, or synchronized.
• Access modifiers can be used with constructors to control which classes can instantiate objects.

Types of Constructors in Java

There are three types of constructors in Java:

1. Default Constructor
2. Parameterized Constructor
3. Copy Constructor

1. Default Constructor : A default constructor is one without parameters. If no constructor is defined explicitly, Java automatically provides a default constructor.

Example:

// Java Program to demonstrate Default Constructor
public class MyClass {

    // Default Constructor
    MyClass() {
        System.out.println("Default constructor called");
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();
    }
}

Output:

Default constructor called

2. Parameterized Constructor : A parameterized constructor takes arguments, allowing you to set object properties with specific values at the time of creation.

Example:

// Java Program to demonstrate Parameterized Constructor
public class MyClass {
    String name;
    int id;

    // Parameterized Constructor
    MyClass(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass("John", 101);
        System.out.println("Name: " + obj.name + ", ID: " + obj.id);
    }
}

Output:

Name: John, ID: 101

3. Copy Constructor : A copy constructor is used to create a new object as a copy of an existing object. While Java does not provide a built-in copy constructor, you can create one manually by passing an object of the same class to the constructor.

Example:

// Java Program to demonstrate Copy Constructor
public class MyClass {
    String name;
    int id;

    // Parameterized Constructor
    MyClass(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // Copy Constructor
    MyClass(MyClass obj) {
        this.name = obj.name;
        this.id = obj.id;
    }

    public static void main(String[] args) {
        // Creating an object using a parameterized constructor
        MyClass obj1 = new MyClass("Alice", 202);

        // Creating a new object using the copy constructor
        MyClass obj2 = new MyClass(obj1);

        System.out.println("Name: " + obj2.name + ", ID: " + obj2.id);
    }
}

Output:

Name: Alice, ID: 202

Constructor Overloading

Just like methods, constructors can also be overloaded by defining multiple constructors with different parameter lists. This allows for flexibility when creating objects with varying initial values.

Example:

// Java Program to demonstrate Constructor Overloading
public class MyClass {

    // Constructor with one parameter
    MyClass(String name) {
        System.out.println("Name: " + name);
    }

    // Constructor with two parameters
    MyClass(String name, int age) {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static void main(String[] args) {
        // Calling different constructors
        MyClass obj1 = new MyClass("Alice");
        MyClass obj2 = new MyClass("Bob", 25);
    }
}

Output:

Name: Alice
Name: Bob, Age: 25

Java Inheritance Overview

Inheritance is one of the core concepts in Object-Oriented Programming (OOP), allowing a class to inherit properties and behaviors (fields and methods) from another class. In Java, this mechanism enables the creation of new classes that reuse, extend, and modify the functionality of existing ones. A class that inherits from another class can access the fields and methods of the parent class, while also adding its own methods and fields.

Why Do We Need Java Inheritance?

Inheritance offers several benefits, such as promoting code reusability, method overriding (which helps in achieving runtime polymorphism), and abstraction, allowing us to work with classes without needing to know the full details of their implementations. By leveraging inheritance, developers can create flexible and easily maintainable code.

Key Benefits:

• Code Reusability: Common code in the superclass can be reused in the child classes, reducing redundancy.
• Method Overriding: Enables the child class to provide specific implementations for methods defined in the parent class, facilitating runtime polymorphism.
• Abstraction: Hides complex details from the user and only shows relevant functionalities.

Important Terms

• Class: A blueprint for creating objects that share common attributes and behaviors.
• Super Class (Parent Class): The class whose properties are inherited by another class.
• Sub Class (Child Class): The class that inherits from another class. It can have additional fields and methods specific to itself.
• Reusability: One of the major advantages of inheritance, where existing fields and methods from a parent class can be used in the child class without duplicating code.

How to Implement Inheritance in Java?

Inheritance in Java is implemented using the extends keyword. This keyword allows the subclass to extend the functionality of the superclass.

Syntax:

class SubClass extends SuperClass {
   // fields and methods
}

Example of Java Inheritance

In this example, we have a base class Vehicle and a derived class Car that extends the Vehicle class. The TestDrive class is used to demonstrate the usage of inheritance.

// Base class
class Vehicle {
    public int speed;
    public int fuel;

    // Constructor
    public Vehicle(int speed, int fuel) {
        this.speed = speed;
        this.fuel = fuel;
    }

    // Methods
    public void accelerate(int increment) {
        speed += increment;
    }

    public void brake(int decrement) {
        speed -= decrement;
    }

    @Override
    public String toString() {
        return "Speed: " + speed + " km/h, Fuel: " + fuel + " L";
    }
}

// Derived class
class Car extends Vehicle {
    public int numberOfDoors;

    // Constructor
    public Car(int speed, int fuel, int numberOfDoors) {
        super(speed, fuel); // Calling the constructor of the superclass
        this.numberOfDoors = numberOfDoors;
    }

    // Additional method for the Car class
    public void lockDoors() {
        System.out.println("Doors locked.");
    }

    @Override
    public String toString() {
        return super.toString() + ", Doors: " + numberOfDoors;
    }
}

// Driver class
public class TestDrive {
    public static void main(String[] args) {
        Car myCar = new Car(80, 50, 4);
        System.out.println(myCar.toString());
    }
}

Output:

Speed: 80 km/h, Fuel: 50 L, Doors: 4

In this example, when an object of Car is created, the fields and methods from the Vehicle class are inherited, allowing the car to access properties like speed and fuel. The toString() method is overridden in the Car class to display additional information about the car.

Types of Inheritance in Java

Java supports several types of inheritance, each with its own structure and use cases:

1. Single Inheritance: A subclass inherits from one superclass.
2. Multilevel Inheritance: A chain of classes where a subclass inherits from a superclass, and another class inherits from that subclass.
3. Hierarchical Inheritance: One superclass is inherited by multiple subclasses.
4. Multiple Inheritance (Through Interfaces): In Java, a class can implement multiple interfaces, which allows it to inherit features from multiple sources. Java doesn’t support multiple inheritance with classes directly to avoid complexity, but interfaces provide a way to achieve this.
5. Hybrid Inheritance: A combination of multiple and other forms of inheritance. Java supports this through interfaces and combinations of single and hierarchical inheritance.
Example:

In the following example, Dog is a subclass that inherits from the Animal superclass.

// Superclass
class Animal {
    public void sound() {
        System.out.println("This is an animal sound.");
    }
}

// Subclass
class Dog extends Animal {
    public void bark() {
        System.out.println("The dog barks.");
    }
}

// Driver class
public class TestAnimal {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.sound();  // Inherited from Animal
        myDog.bark();   // Defined in Dog
    }
}

Output:

This is an animal sound.
The dog barks.

Abstraction in Java refers to the practice of showing only the necessary details and functionalities to the user while hiding the underlying implementation. By doing so, unnecessary complexities are kept out of sight, making it easier to work with the code.

Real-World Example of Abstraction:

A remote control for a TV is a great example of abstraction. You press buttons to change channels or adjust the volume, without needing to understand the inner workings of the TV or how the remote communicates with it.

What is Abstraction in Java?

In Java, abstraction is implemented using abstract classes and interfaces. If you want complete (100%) abstraction, interfaces are the tool of choice.

Data Abstraction is the process of focusing on the important characteristics of an object while ignoring irrelevant details. It helps in defining the key behaviors and properties of an object, distinguishing it from others in a meaningful way.

Real-Life Example of Abstraction:

Imagine driving a car. You know pressing the accelerator increases the speed, and pressing the brakes slows it down, but you don’t need to understand the detailed mechanism behind it. This is how abstraction simplifies interaction.

Java Abstract Classes and Abstract Methods

• An abstract class is defined with the abstract keyword.
• An abstract method is declared without any implementation.
• An abstract class can have both abstract methods and regular methods.
• If a class contains abstract methods, it must be declared as abstract.
• Abstract classes cannot be instantiated directly; they must be extended.
• Abstract classes can have constructors, both parameterized and default.

How to Implement Abstraction in Java

1. Define an abstract class or interface to represent the abstraction.
2. Declare common behaviors and properties as abstract methods within the class or interface.
3. Extend the abstract class or implement the interface in concrete classes.
4. Provide the specific implementations for the abstract methods in the concrete classes.
5. Use these concrete classes to achieve the desired functionality in your program.

When to Use Abstract Classes and Methods?

Abstract classes are useful when you want to define a template that outlines the structure of an abstraction but leave some details to be implemented by subclasses. A common example is the Shape hierarchy in design or simulation software, where shapes like circles, squares, and triangles share some characteristics but differ in how they calculate their areas.

Java Abstraction Example

Example 1:

// Abstract class for Shape
abstract class Shape {
    String color;

    // Abstract methods
    abstract double area();
    public abstract String toString();

    // Constructor for Shape
    public Shape(String color) {
        this.color = color;
    }

    // Concrete method
    public String getColor() {
        return color;
    }
}

// Circle class extending Shape
class Circle extends Shape {
    double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * Math.pow(radius, 2);
    }

    @Override
    public String toString() {
        return "Circle color is " + getColor() + " and area is: " + area();
    }
}

// Rectangle class extending Shape
class Rectangle extends Shape {
    double length, width;

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

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

    @Override
    public String toString() {
        return "Rectangle color is " + getColor() + " and area is: " + area();
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle("Red", 5.0);
        Shape rectangle = new Rectangle("Blue", 4.0, 6.0);

        System.out.println(circle.toString());
        System.out.println(rectangle.toString());
    }
}

Output:

Circle color is Red and area is: 78.53981633974483
Rectangle color is Blue and area is: 24.0

Using Interfaces for Abstraction

Interfaces provide a way to achieve complete abstraction in Java. They contain method declarations but no method implementations.

Example:

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

// Circle class implementing Shape interface
class Circle implements Shape {
    private double radius;

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

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

// Rectangle class implementing Shape interface
class Rectangle implements Shape {
    private double length, width;

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

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

// Main class
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);

        System.out.println("Area of Circle: " + circle.calculateArea());
        System.out.println("Area of Rectangle: " + rectangle.calculateArea());
    }
}

Output:

Area of Circle: 78.53981633974483
Area of Rectangle: 24.0

Advantages of Abstraction

1. Simplifies Code: Reduces complexity by hiding implementation details.
2. Increases Reusability: Encourages code reuse and avoids duplication.
3. Enhances Security: Provides essential details while hiding the rest.
4. Improves Maintainability: Easier to update and maintain.
5. Supports Modularity: Breaks down complex systems into smaller parts.

Disadvantages of Abstraction

1. Increased Complexity: May add unnecessary layers if not used properly.
2. Debugging Challenges: Can make debugging more difficult due to hidden layers.
3. Potential Performance Overhead: Additional abstraction layers might affect performance.