Java OOPs Interview Questions
Here are some well-known Java OOPs interview questions, along with the explanations. These Java OOPs interview questions are used to evaluate your knowledge about fundamental concepts of object-oriented programming. Going through these Java OOPs interview questions will make you different and demonstrate your prowess in interviews.
Java OOPs interview questions examining the problems will give you a complete understanding of the underlying principles like Encapsulation, Abstraction, Inheritance, and Polymorphism.
Displaying your confidence in answering Java OOPs interview questions will reflect on your ability in actual software development. If you are a newcomer or a Java developer with experience, it is an effective way to prepare Java OOPs interview questions. Java OOPs interview questions can be used to go through prime concepts and make sure you are well-prepared for your next interview.
Understanding how to approach Java OOPs interview questions can be a game-changer for you to get a career. So, get yourself involved in these Java OOPs interview questions and practice, practice, practice until your coding skill set is no less than other levels.
1. What is Object-Oriented Programming (OOP)?
Answer:
- Object-Oriented Programming (OOP) is the name of the game in programming, and it is the way that software is structured around objects, and not the functions or logic it works on.
- Specifically, at the core of OOP, the idea is that data are the functions (attributes) and methods (behaviors) that are embedded into the classes, which are units, and the objects belong to these classes.
- These are the 4 key principles of OOP:
- Encapsulation: Limiting the access of an object’s particular components and making the interaction be performed only by the use of methods.
- Abstraction: Revealing necessary functionalities and cutting out complex implementation details that are not needed.
- Inheritance: Creating a new class by deriving it from the existing one, which includes both attributes and behaviors that are inherited.
- Polymorphism: Allowing a single interface to be used to represent different underlying forms (by way of method overriding and overloading).
2. What are the primary principles of OOP?
Answer: The four fundamental principles of OOP are:
- Encapsulation: The shielding of an object’s status by the joining of data and the methods that operate on them, and the provision of only limited access to the data.
- Abstraction: Offering a simplified interface while hiding the implementation details.
- Inheritance: Making a new class based on an existing class, which allows code reuse.
- Polymorphism: Achieving the possibility of objects or methods to perform various functions depending on the context either by using overridden or overloaded methods.
3. What is a class in OOP?
Answer:
- A class is a blueprint or template for creating objects in OOP.
- As a class it defines the properties that created objects will have and the actions that will be performed by the objects.
- A class does not take up memory by itself; memory is only allocated for objects that are created.
- Example in Java:
class Car {
String make;
String model;
void startEngine() {
System.out.println(“Engine started”);
}
}
4. What is an object in OOP?
Answer:
- An object is a specific named instance of the class.
- Each object has a distinct set of the values of the properties defined in its particular class and only they can be accessed through the class instance.
- The said objects are the things that are present in the real world.
- Example in Java:
Car myCar = new Car();
myCar.make = “Toyota”;
myCar.model = “Corolla”;
myCar.startEngine();
5.What is Encapsulation in OOP?
Answer:
- Encapsulation is the act of putting the data (it’s properties) and the methods (it’s members) which operate on the data into a single entity or unit.
- That is, a class. Apart, encapsulation also involves hiding some of the object’s properties to stop the object from being manipulated.
- All of this can be achieved through the use of access modifiers like private, protected, and public, thus ensuring that the object’s inner state is safe from unauthorized outside access or alteration.
- Example in Java:
class Car {
private String make; // private variable, it cannot be accessed directly outside the class
private String model;
// Getter method to access the make
public String getMake() {
return make;
}
// Setter method to modify the make
public void setMake(String make) {
this.make = make;
}
}
6.What is Abstraction in OOP?
Answer:
- Abstraction is that the postulates of hiding the complex implementation of a system from the user and exposing just those parts that are necessary or the necessary features only the user interacts with.
- In OOP, abstraction makes you concentrate on what an object performs rather than how it performs it.
- It can be realized with the help of the abstract classes or interfaces.
- Example in Java:
abstract class Animal {
abstract void sound(); // Abstract method
}
class Dog extends Animal {
@Override
void sound() {
System.out.println(“Bark”);
}
}
7.What is Inheritance in OOP?
Answer:
- Inheritance is a mechanism that enables you to create a new class through its reusing of the properties and behaviors (methods) of a previously made class.
- The class that is inherited from is known as the parent or the superclass, while the new class is called the child or subclass.
- Inheritance can be used for code reuse and a hierarchical class structure.
- Example in Java:
class Animal {
void sound() {
System.out.println(“Some sound”);
}
}
class Dog extends Animal {
void sound() {
System.out.println(“Barking”);
}
}
8.What is Polymorphism in OOP?
Answer:
- Polymorphism is the function of the objects that are to be determined by the parent class, which allows the child class to supply specific implementations of the methods which were already present in the parent class.
- It can be achieved through method overriding (runtime polymorphism) or method overloading (compile-time polymorphism).
- Example in Java (Method Overriding):
class Animal {
void sound() {
System.out.println(“Some sound”);
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println(“Bark”);
}
}
9.What is a Constructor in OOP?
Answer:
- A constructor is a special method in a class that is automatically called when an object of that class is created.
- Its main job is to initialize the object’s state (i.e., set initial values for its attributes).
- Constructors — the same name as the class and do not have a return type.
- Example in Java:
class Car {
String make;
String model;
// Constructor
public Car(String make, String model) {
this.make = make;
this.model = model;
}
}
10.What is Method Overloading?
Answer:
- Method overloading is a programming method that is mastered when all methods of the same class have the same name, but they differ in their parameters, i.e. their number, type, or both of them.
- The method to be invoked is selected based on its arguments, which must be passed when the method is called.
- Method overloading, nevertheless, is an example of static polymorphism.
- Example in Java:
class Printer {
void print(String text) {
System.out.println(text);
}
void print(int number) {
System.out.println(number);
}
}
11.What is Method Overriding?
Answer:
- Method overriding takes place when a subclass comes up with its own or an entirely new edition of a method that is already declared in its superclass.
- Moreover, the method signature must be the same as the method in the superclass.
- Method overriding is an instance of runtime polymorphism.
- For instance in Java:
class Animal {
void sound() {
System.out.println(“Some sound”);
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println(“Bark”);
}
}
12.What is an Interface in OOP?
Answer:
- An interface is a contract that defines a set of methods a class must implement.
- Unlike classes, interfaces cannot contain implementation code for the methods; they only declare the method signatures.
- A class that implements an interface must provide implementations for all the methods defined in the interface.
- Example in Java:
interface Animal {
void sound(); // Abstract method
}
class Dog implements Animal {
@Override
public void sound() {
System.out.println(“Bark”);
}
}
13.What is an Abstract Class in OOP?
Answer:
- An abstract class is the kind of class not allowing concrete objects to be created and containing abstract methods (methods without implementation) and concrete methods (methods with implementation).
- It is a base class, which is inherited from, and this allows the inherited classes to implement the abstract methods.
- Example in Java:
abstract class Animal {
abstract void sound(); // Abstract method
void eat() { // Concrete method
System.out.println(“Eating…”);
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println(“Bark”);
}
}
14.What is the difference between an abstract class and an interface?
Answer:
The main distinctions between an abstract class and an interface are:
Abstract Class:
- Can have both abstract and concrete methods.
- Can have instance variables (fields).
- A class can inherit only one abstract class due to single inheritance.
Interface:
- Can only have abstract methods (until Java 8, now interfaces can have default and static methods).
- Cannot have instance variables (fields).
- A class can implement multiple interfaces (multiple inheritance of behavior).
15.What is the difference between method overloading and method overriding?
Answer:
Method Overloading:
- Among cases, method overloading occurs when two or more methods in a class have the same name but different parameters (different number, type, or both).
- It is determined at compile time.
Method Overriding:
- Occurs when a subclass provides its specific implementation of a method that is already defined in its superclass.
- It is determined at runtime.
16.What is a Singleton Design Pattern?
Answer:
- A Singleton Design Pattern ensures that a class contains only one object and offers a single entry access point to it across the whole program.
- It is a technique that is usually used in order to single out a resource (e.g., a database connection or a configuration manager) that safe the lifetime of an application.
- Example in Java:
class Singleton {
private static Singleton instance;
private Singleton() { }
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
17.What is the difference between == and equals() in Java?
Answer:
- == checks whether two references point to the exact same object in memory (i.e., reference comparison).
- .equals() checks whether the contents of two objects are the same (i.e., logical comparison).
- Example in Java:
System.out.println(str1.equals(str2)); // true, because the content is the same
18.What is the super keyword’s use in Java?
- Super keyword is a reserved word used in a subclass that is written to refer to its immediate superclass.
- It can be used to access superclass methods, constructors, and fields that are overridden or hidden by the subclass.
- Example in Java:
class Animal {
void sound() {
System.out.println(“Some sound”);
}
}
class Dog extends Animal {
void sound() {
super.sound(); // Calls the superclass method
System.out.println(“Bark”);
}
19.What is a static keyword in Java?
Answer:
- The static keyword is used for memory management and implies that a specific member (variable or method) is a part of a class rather than a part of an object.
- It can be accessed without creating an instance of the class.
- Example in Java:
class Counter {
static int count = 0; // Static variable
static void increment() { // Static method
count++;
}
}
20.What is a final keyword in Java?
Answer:
The final keyword in Java can be used in the following ways:
- Final variable: Its value can not be changed once it is assigned.
- Final method: The method cannot be overridden by subclasses.
- Final class: The class cannot be subclassed.