Java Interview Questions - Object-Oriented Programming (OOP)

Welcome to our comprehensive guide on Java Interview Questions, focusing on Object-Oriented Programming (OOP)! This lesson is designed for both beginners and intermediate learners, so let's dive right in.

Understanding OOP

Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around data, or objects, and methods, which operate on that data. Let's break down the main components of OOP:

Classes - Templates for creating objects. A class defines a blueprint for an object, which includes attributes (fields) and behaviors (methods).
Objects - Instances of a class. Each object has its own state and behavior, created using the class blueprint.
Inheritance - A mechanism that allows one class to acquire the properties (fields and methods) of another. This promotes code reusability and structure.
Polymorphism - The ability of objects to take on many forms. Polymorphism allows objects of different classes to be treated as objects of a common superclass.
Encapsulation - The practice of keeping fields within a class private, only exposing methods to interact with them. This helps maintain data integrity and simplifies the interface.

Creating a Class

Let's create a simple class as an example:

java

public class Car {
    private String color;
    private int speed;

    // Constructor
    public Car(String color, int speed) {
        this.color = color;
        this.speed = speed;
    }

    // Method to increase speed
    public void accelerate() {
        speed += 10;
    }

    // Method to get car color
    public String getColor() {
        return color;
    }
}

In this example, we have a Car class with two private fields, color and speed. The class also has a constructor, which sets the initial values for these fields, and two methods: accelerate and getColor.

Inheritance and Polymorphism

Let's demonstrate inheritance and polymorphism with two classes: Car and ElectricCar.

java

public class Car {
    // ... (Previous code)
}

public class ElectricCar extends Car {
    private int batteryLevel;

    // Constructor
    public ElectricCar(String color, int speed, int batteryLevel) {
        super(color, speed); // Calling the superclass constructor
        this.batteryLevel = batteryLevel;
    }

    // Method to decrease battery level and increase speed
    public void accelerate() {
        batteryLevel -= 10;
        super.accelerate();
    }
}

In this example, ElectricCar inherits from Car and adds a new field, batteryLevel. The accelerate method in ElectricCar decreases the battery level and then calls the superclass's accelerate method to increase the speed.

Encapsulation

Encapsulation can be demonstrated by making the color and speed fields private and providing public getter methods:

java

public class Car {
    private String color;
    private int speed;

    // ... (Previous code)

    // Method to get car color
    public String getColor() {
        return color;
    }

    // Method to get car speed
    public int getSpeed() {
        return speed;
    }
}

By making the fields private, we ensure that their values are only modified through the provided methods.

Quiz

We hope this tutorial provides a solid foundation for understanding OOP in Java. Stay tuned for more advanced concepts! 🎯

📝 Note: Remember to use classes to create objects, and classes can inherit from other classes to promote code reusability. Encapsulation ensures data integrity by keeping fields private and providing public getter methods.

💡 Pro Tip: Practice creating your own classes and experimenting with inheritance and polymorphism to build a strong understanding of OOP in Java.

✅ Good luck on your coding journey! 🚀