Java OOPs Basic

In this article, you'll take a deep dive into a crucial aspect of Java that is essential for mastering Data Structures and Algorithms: Object-Oriented Programming (OOP).

Introuction

Object-Oriented Programming, often abbreviated as OOP, is a programming paradigm based on the concept of Classes and Objects, which can contain data and code to manipulate that data. Understanding OOP is vital as it allows for more organized, modular, and reusable code, which is particularly important when dealing with complex problems in Data Structures and Algorithms.

Classes and Objects

Class: In Java, a class serves as a blueprint or a template for creating objects. A class encapsulates data for the object and methods to manipulate that data. Code in Java is typically defined within a class, as Java is an object-oriented programming language, which means that almost everything revolves around the concept of objects and classes.

Object: An object is an instance of a class. When a class is defined, no memory is allocated or action performed until an object is created from that class. An object is a real-world entity that represents the specific instance of the blueprint (class). It holds actual data in the form of attributes and can perform actions using the methods defined in the class.

Access Specifiers:

Access specifiers in Java determine the visibility and accessibility of classes, methods, and variables. The most common access specifiers are:

• public: When a class or method is declared as public, it is accessible from anywhere in the program.
• private: Declaring something as private restricts its access to within the class it is declared in.
• protected: A protected entity is accessible within its own package and by subclasses.

The Main Method and Its Role:

Here is a code snippet to print "Hello World" on the console in Java.

class Basics {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Static Methods:

A static method belongs to the class rather than any instance of the class. This allows for calling a static method directly using the class name without the need to create an object. For example:

ClassName.methodName();

Creating and Using Objects:

In Java, objects are instances(copies) of classes. To access non-static methods, an object of the class must be created using the new keyword, followed by the class constructor. For example:

ClassName objName = new ClassName();

// Test class
class Test {
    int age;
    public void assignAge(int num) {
        // Assign the number to age
        age = num;
    }
}

class Basics {
    public static void main(String[] args) {
        // Creating an object having name test1 of Test class
        Test test1 = new Test();
        test1.assignAge(10); // Assigning age 10 to test1 object
        
        // Creating an object having name test2 of Test class
        Test test2 = new Test(); 
        test2.assignAge(19); // Assigning age 10 to test2 object
        
        System.out.println(test1.age);
        System.out.println(test2.age);
    }
}

Arguments in Methods:

Arguments are the values or variables passed to a function or method when it is called. These arguments provide the necessary inputs that the function uses to perform its operations. For example:

// Test class
    class Test {
        public int sum(int num1, int num2) {
            // Return the sum
            return num1 + num2;
        }
    }
    
    class Basics {
        public static void main(String[] args) {
            // Creating an object of class Test
            Test test = new Test();
            
            // Sum two numbers using test object
            int sum = test.sum(10, 15);
            
            // Display the result
            System.out.println(sum);
        }
    }

Constructors:

In Object-Oriented Programming (OOP) in Java, a constructor is a special type of method used to initialize objects. It is called automatically when an object of a class is created. The constructor's main role is to set initial values for the object's attributes and perform any necessary setup tasks. Key Points:

• Same Name as Class: A constructor has the same name as the class it belongs to.
• No Return Type: Constructors do not have a return type, not even void.
• Called Automatically: When an object is created using the new keyword, the constructor is called automatically.
• Types of Constructors: Java provides two types of constructors: Default Constructor and Parameterized Constructor.

• Default Constructor: A default constructor is a constructor that has no parameters. If no constructor is defined in a class, Java automatically provides a default constructor that initializes object fields to their default values
• Parameterized Constructor: A parameterized constructor allows passing arguments to the constructor so that specific values can be assigned to object attributes at the time of creation.

Encapsulation:

Encapsulation is one of the core concepts of Object-Oriented Programming (OOP). It refers to the practice of bundling data (variables) and methods (functions) that operate on the data into a single unit, known as a class, and restricting direct access to the data from outside the class.

Key Points:

• Data Hiding: Encapsulation hides the internal details of how an object works. The object's data is kept private and can only be accessed or modified through methods (getters and setters).
• Controlled Access: Through encapsulation, only specific methods are provided to access or modify the data, ensuring more controlled and secure interactions with the object's data.

class BankAccount {
    private int balance;  // Private variable (data hiding)

    // Public method to access the balance
    public int getBalance() {
        return balance;
    }

    // Public method to modify the balance
    public void setName(int newBalance) {
        balance = newBalance;
    }
}

Inheritence:

Inheritance is a core concept of Object-Oriented Programming (OOP) that allows a class to inherit properties and behaviors (fields and methods) from another class. It helps in reusing existing code and creating a hierarchical relationship between classes.

Key Points:

• Parent (Superclass) and Child (Subclass): In inheritance, the class that is inherited from is called the parent class (or superclass), and the class that inherits is called the child class (or subclass).
• Reuse of Code: The child class automatically gets the properties and methods of the parent class, so there is no need to rewrite the same code.
• Extending Functionality: The child class can add new features or override existing ones to modify the behavior inherited from the parent class.

// Base class
    class Vehicle {
        private String VehicleNumber;
        
        public Vehicle(String VehicleNumber) {
            this.VehicleNumber = VehicleNumber;
        }
        
        public void honk() {
            System.out.println("Honk !!!!!!!!!!!");
        }
        
        public void printVehicleNumber() {
            System.out.println(VehicleNumber);
        }
    }
    
    // Derived class
    class Car extends Vehicle{
        public Car(String CarNumber) {
            super(CarNumber);
        }
    }
    
    // Derived class
    class Bus extends Vehicle{
        public Bus(String BusNumber) {
            super(BusNumber);
        }
    }
    
    class Main {
        public static void main(String[] args) {
            Car car = new Car("AB12CD2345");
            car.printVehicleNumber();
            car.honk();
            
            Bus bus = new Bus("XY23MN5678");
            bus.printVehicleNumber();
            bus.honk();
        }
    }

Polymorphism:

Polymorphism is a concept in Object-Oriented Programming (OOP) that allows objects to be treated as instances of their parent class or interface, while having the ability to take on different forms or behaviors. It enables the same method to perform different actions depending on the object calling it.

Key Points:

• Two types of Polymorphism:
  • Compile-time Polymorphism (Method Overloading): The ability to have multiple methods in the same class with the same name but different parameters.
  • Runtime Polymorphism (Method Overriding): The ability of a subclass to provide a specific implementation of a method that is already defined in its parent class.
• Method Overloading: Multiple methods can have the same name but different parameter lists (number or type of parameters).
• Method Overriding: A method in the child class can have the same name and parameters as in the parent class, but the child class provides its own implementation.

// Base class
class Vehicle {
    private String VehicleNumber;
    
    public Vehicle(String VehicleNumber) {
        this.VehicleNumber = VehicleNumber;
    }
    
    public void honk() {
        System.out.println("Honk !!!!!!!!!!!");
    }
    
    public void printVehicleNumber() {
        System.out.println(VehicleNumber);
    }
}

// Derived class
class Car extends Vehicle{
    public Car(String CarNumber) {
        super(CarNumber);
    }
    
    @Override
    public void honk() {
        System.out.println("Car Honk !!!!!!!");
    }
}

// Derived class
class Bus extends Vehicle{
    public Bus(String BusNumber) {
        super(BusNumber);
    }
}

class Main {
    public static void main(String[] args) {
        Car car = new Car("AB12CD2345");
        car.printVehicleNumber();
        car.honk();
        
        Bus bus = new Bus("XY23MN5678");
        bus.printVehicleNumber();
        bus.honk();
    }
}

Abstraction:

Abstraction is a core concept of Object-Oriented Programming (OOP) in Java that focuses on hiding complex implementation details and exposing only the essential features of an object or method. It helps simplify programming by only showing what is necessary and keeping internal workings hidden.

Key Points:

• Hides Complexity: Abstraction allows a user to interact with an object or method without needing to understand the underlying details of how it works.
• Simplifies Interaction: Only the important aspects are exposed, making it easier to use the object or method.

• Abstract Classes
• Interfaces

1. Abstract Class

• Cannot be Instantiated: An abstract class cannot be used to create objects directly. It must be inherited by a subclass, and only the subclass can be instantiated.
• Abstract Methods: These are methods without implementation in the abstract class, and the subclasses are required to provide their own implementations.
• Can Have Regular Methods: Along with abstract methods, an abstract class can also have fully defined methods.

abstract class Animal {
    // Abstract method (no implementation)
    abstract void sound();

    // Regular method
    void sleep() {
        System.out.println("This animal sleeps.");
    }
}

// Subclass providing implementation for abstract method
class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks.");
    }
}

2. Interfaces

• Pure Abstraction: An interface only defines what methods should be present; the actual implementation is provided by the classes that implement the interface.
• No Instantiation: Like abstract classes, interfaces cannot be instantiated. They only serve as a blueprint.
• Multiple Implementation: A class can implement multiple interfaces, allowing for more flexibility compared to single inheritance in classes.

interface Animal {
    void sound(); // Abstract method (no body)
}

// Class implementing the interface
class Dog implements Animal {
    public void sound() {
        System.out.println("Dog barks.");
    }
}

Advantages of Abstraction with Interfaces:

• Multiple Inheritance: A class can implement multiple interfaces, unlike classes that can only extend one class.
• Loose Coupling: Interfaces help to reduce the dependencies between different parts of the code, making the system more modular and easier to maintain.