Object-Oriented Programming (OOP) : MCQs & PYQs with Explanation

Option C

Inheritance is a fundamental concept in object-oriented programming (OOP) where one class acquires the properties (data fields) and methods of another class. The class inheriting the properties is called the derived class or subclass or child class, while the class from which it inherits is called the base class or superclass or parent class. Inheritance promotes code reusability.

Option C

Encapsulation in Java is one of the fundamental principles of Object-Oriented Programming (OOP). An act of combining data (variables) and the methods that operate on that data into a single unit called a class. 
Through encapsulation, the internal details of an object are hidden from the outside world, allowing controlled access via getter and setter methods. This helps maintain data security, ensures better control over the data, and prevents unintended modification.

Option A

In Java, the final keyword can be applied to methods to prevent them from being overridden by a subclass. When a method is declared as final, its implementation cannot be changed through method overriding.
E.g.:
class Parent
{
    public final void display()
    {
        System.out.println("Parent Method");
    }
}
class Child extends Parent
{
    // Compilation Time Error
    public void display()
    {
        System.out.println("Child Method");
    }
}

Option B

In Java, a superclass reference can refer to an object of its subclass. This is an important feature of polymorphism.
E.g.:
class Animal
{
    void sound()
    {
        System.out.println("Animal Sound");
    }
}
class Dog extends Animal 
{
    void sound()
    {
        System.out.println("Dog Barks");
    }
}
class TestExample 
{
    public static void main(String args[]) 
    {
        Animal aObj = new Dog();
        aObj.sound();
    }
}
OUTPUT
Dog Barks
Here, aObj is a reference of type Animal, but it refers to a Dog object. When aObj.sound() is called, Java determines at runtime which overridden method should be executed. 
Since the actual object is a Dog, the Dog version of sound() is executed. This runtime method selection is called Dynamic Binding or Dynamic Method Dispatch.

Option D

In Object-Oriented Programming (Java), a final class is a class that cannot be extended or inherited by any other class.
When a class is declared using the keyword final, it prevents other classes from inheriting it.
final class A 
{
void displayMessage() 
{
        System.out.println("Suraku Academy");
}
}
class B extends A { } //Error.

Option D

In Java, the final keyword is used when we want a variable value to remain unchanged after it has been assigned. Such a variable is commonly treated as a constant.
E.g.:
class Example
{
    public static void main(String args[])
    {
        final int num=22;
        System.out.println(num);
        //num=33; Compilation Error
    }
}

Option B

In object-oriented programming, a class is a blueprint for creating objects and can encapsulate (combine) data (variable) and operations (methods). The degree of primitiveness of a class refers to how basic or elementary its responsibilities are.

• A primitive class is a very basic class that performs simple, specific operations only.
• It does not try to do everything or handle complex logic. Instead, it focuses on fundamental building blocks that can be used by other, more complex classes.
• A class that does only primitive operations is said to have a high degree of primitiveness.

Option B

Object-Oriented Programming (OOP) is based on several important features that help in designing reusable, secure, and manageable programs. The major features of OOP are:

• Encapsulation.
• Inheritance.
• Data Abstraction.
• Polymorphism.

Option C

Java is primarily an object-oriented programming language, and OOP is based on concepts that help organize a program around classes and objects. The four commonly recognized fundamental OOP concepts are encapsulation, inheritance, polymorphism, and abstraction.

• Polymorphism allows the same method or interface to behave differently in different situations. 
• Inheritance allows one class to acquire properties and behaviors from another class. 
• Encapsulation combines data and methods within a class and controls access to the data. 
• Abstraction focuses on exposing essential features while hiding unnecessary implementation details.

Compilation is not an OOP concept. It is the process of converting Java source code into bytecode using the Java compiler (javac).

Option A

The abstract keyword is used to declare an abstract class and abstract methods in Java. In Java, an abstract method is a method that is declared without a method body. It only specifies what the method should do, while the implementation is provided by a subclass.

• If a class contains one or more abstract methods, that class must be declared as abstract. Otherwise, the compiler will generate a Compilation Error.
• An abstract class does not necessarily need to contain an abstract method. It can contain only normal methods and still be declared abstract.
• The abstract keyword on the class means that the class cannot be instantiated directly, even though it contains no abstract methods.

Syntax:
abstract ReturnType MethodName();
E.g.:
abstract class Shape
{
    public abstract void draw();
}
class Circle extends Shape
{
    public void draw()
    {
        System.out.println("Drawing Circle");
    }
}
class Example
{
    public static void main(String args[])
    {
        Circle c = new Circle();
        c.draw();
    }
}
OUTPUT
Drawing Circle
E.g.:
abstract class Calculator
{
    public void add(int a, int b)
    {
        System.out.println("Addition : "+(a+b));
    }
}
class AdvancedCalculator extends Calculator
{
}
class Example
{
    public static void main(String args[])
    {
        // Calculator c = new Calculator();  //Not Allowed
        AdvancedCalculator obj = new AdvancedCalculator();
        obj.add(11,22);
    }
}
OUTPUT
Addition : 33