Java OOP Essentials: 136 MCQs with answers

`private`

`private` is the most restrictive access level; it restricts access to the same class only.

package-private

If you don't write a modifier, the member is accessible to any class in the same package, which is called package-private (or default) access.

`protected`

`protected` extends package-private access by also allowing subclasses (even in different packages) to access the member.

It prevents external code from setting invalid values

Data hiding, by making fields private, prevents external code from directly setting invalid values, thus protecting the integrity of the object's state.

Increased execution speed

Encapsulation does not directly increase execution speed; its benefits are data hiding, maintainability, flexibility, and security.

True

This is the definition of `protected` access: it extends package-private access with subclass access across packages.

—

This is the core definition.

—

This order is essential for understanding visibility.

—

No other class, not even subclasses, can access it directly.

—

This is also called default access.

—

Protected extends package-private with subclass access.

—

No restrictions.

—

Getters provide read access without exposing the field directly.

—

Setters allow controlled modification with validation.

—

These are the key benefits listed in the source.

—

JavaBeans are a classic example.

A blueprint for creating objects

A class defines the structure (fields) and behavior (methods) that objects will have. It is not an instance itself; it's a template.

new

The `new` keyword allocates memory and calls a constructor to initialize the object. Without it, no object is created.

A memory address of the object

Reference variables hold a reference (memory address) to the object, not the object's data itself. This is key to understanding aliasing.

Dog d = new Dog();

The correct syntax is `Dog d = new Dog();`. The `new` keyword is required to instantiate the object.

int

`int` is a primitive type that stores values directly. `String`, `Car`, and `Scanner` are reference types.

It accesses fields and methods of an object

The dot operator is used to access an object's fields and methods, e.g., `myCar.color` or `myCar.accelerate()`.

A default constructor is provided

Java automatically provides a default constructor with no parameters if no constructor is defined, allowing object creation.

False

A reference variable stores a memory address (reference) to the object, not the object's data itself. The actual data is stored in the heap.

False

Declaring a reference variable only creates a variable that can hold a reference. The object is created only when you use the `new` keyword.

—

This tests the fundamental definition of a class.

—

This tests understanding of object creation.

—

This tests basic object access syntax.

—

Reference variables are initialized to `null` by default.

—

This tests knowledge of a common runtime error.

—

State is the data part of an object.

—

Behavior is the functionality part of an object.

—

This tests knowledge of default constructors.

—

This tests the concept of instance independence.

—

This tests the difference between declaration and instantiation.

—

This tests basic syntax.

A variable shared by all instances of the class

A static field is a class variable; there is only one copy shared by all instances, unlike instance fields which are per-object.

`MyClass.foo()`

Static methods are called using the class name, e.g., `MyClass.foo()`. They can also be called via an object, but that's discouraged.

When the class is first loaded

A static block runs exactly once when the class is loaded into memory, before any instance creation or static method invocation.

`public static final int MAX = 10;`

A static constant uses both `static` (class-level) and `final` (unchangeable), with a type and value.

False

A static block runs only once, when the class is first loaded, not on each object creation.

—

This is the fundamental distinction between class-level and object-level data.

—

The entry point of a Java program cannot rely on object creation.

—

It is used for complex static initialization.

—

Static constants are a common pattern for fixed values.

—

The recommended way is to use the class name.

—

The compiler knows there is no instance context.

—

It runs once at class loading time.

—

Static members can access each other directly.

To initialize a new object's state when it is created

A constructor is a special method that initializes a new object's state when it is created with `new`. It sets up the object's fields and enforces invariants, ensuring the object is in a valid state before use.

A default no-argument constructor

If no constructor is defined, Java automatically provides a default no-argument constructor that sets fields to their default values (0, false, null).

The default constructor disappears

Defining any constructor removes the default constructor. You must explicitly add a no-argument constructor if you need one.

It accepts arguments to initialize an object with specific values

A parameterized constructor accepts arguments, allowing you to initialize an object with specific values at creation time, such as `new Student("Alice", 20)`.

Having multiple constructors with different parameter lists

Constructor overloading allows a class to have multiple constructors with different parameter lists, providing flexibility in how objects are created.

The current instance of the class

`this` refers to the current instance — the object on which the constructor or method is being called.

True

The compiler generates a default no-argument constructor only when no other constructor is defined. If you define any constructor, you must explicitly add a no-arg constructor if needed.

False

Constructors are called only with the `new` keyword. They cannot be invoked on an existing object using dot notation.

—

This is the fundamental definition of a constructor.

—

The compiler provides it only if no other constructor is defined.

—

This is a common source of confusion.

—

It allows setting the initial state directly.

—

Each constructor must have a unique signature.

—

It is used to disambiguate fields from parameters and to call other constructors.

To enforce encapsulation and control access

Private fields with public getters/setters enforce encapsulation by hiding data and providing controlled access, allowing validation and preventing invalid states.

`public void withdraw(double amount) { if (amount > 0 && amount <= balance) balance -= amount; }`

The correct withdraw method checks that the amount is positive and does not exceed the current balance, preventing the balance from going negative.

Because external code depends on the public interface, not internal details

Encapsulation hides internal implementation, so external code only depends on the stable public interface (getters/setters), reducing coupling and making refactoring easier.

Making fields public to avoid writing getters/setters

Making fields public exposes them to direct modification, allowing invalid data and breaking encapsulation. The correct approach is to keep fields private and provide controlled access methods.

Use the most restrictive access that works

The principle of least privilege suggests giving each member the minimum access needed, which often means using `private` for fields and only exposing what is necessary.

It validates the input

Setters often validate input before updating the field, ensuring the object remains in a valid state.

It isolates internal changes from external code

Encapsulation hides internal implementation, so you can change how data is stored or validated without affecting code that uses the class, as long as the public interface stays stable.

False

Data hiding is a part of encapsulation, but encapsulation is broader—it also includes bundling data with methods and controlling access through an interface.

—

This is the standard pattern.

—

This minimizes exposure and reduces risk.

—

Encapsulation includes data hiding but is not limited to it.

—

Public fields allow direct modification without validation.

—

The public interface acts as a contract.

Both variables point to the same object

Assignment copies the reference, not the object. Both variables now refer to the same object, so changes through one are visible through the other.

A class is a blueprint; an object is an instance

A class defines the structure and behavior, while an object is a concrete instance created from that class using `new`.

The values of its fields at a given time

State is the data stored in an object's fields. Methods define behavior, not state.

A NullPointerException is thrown

Calling a method on a `null` reference causes a `NullPointerException` at runtime, because there is no object to invoke the method on.

It is defined by its methods

Behavior is what an object can do, which is determined by its methods. Fields represent state, not behavior.

To initialize a new object

A constructor is called when an object is created to initialize its fields and set up the object's initial state.

Each object has its own copy of instance fields

Each object has its own independent copy of instance fields, so changes to one object's fields do not affect another.

—

This is a key distinction in Java's type system.

—

This tests understanding of reference semantics.

—

This tests understanding of constructors.

—

This tests the benefit of classes.

Because static methods don't have a `this` reference

Static methods are not associated with any object, so there is no `this` to refer to an instance. Accessing an instance variable without an object reference causes a compile-time error.

The parent method is hidden

Static methods are hidden, not overridden. The method invoked depends on the reference type, not the object type, unlike instance method overriding.

A

Since `display()` is static, it is hidden, not overridden. The reference type is `A`, so `A.display()` is called, printing "A".

A method that calculates the area of a circle given its radius

Static methods are best for operations that don't depend on object state, like a pure calculation. The other options require instance data.

They save memory and improve readability

Static constants have only one copy in memory, and naming them improves code clarity by replacing magic numbers.

False

Static methods are hidden, not overridden. The method called depends on the reference type, not the object type.

—

Without an object, there is no instance state to access.

—

This is different from instance method overriding.

—

This makes them efficient and easy to use.

—

Static fields are ideal for class-level data.

—

They are orthogonal concepts.

—

Static methods are accessible without an object.

`this.name = name;` to disambiguate fields

`this` is used to disambiguate field names from parameters (e.g., `this.name = name;`) and to call another constructor of the same class via `this(...)`.

It must be the first statement in the constructor

`this(...)` must be the first statement in a constructor to ensure delegation happens before any other initialization.

Memory allocation → default values → explicit field initializers → constructor body

The JVM follows a fixed order: memory allocation, then default field values, then explicit field initializers, and finally the constructor body.

It causes a compile error because the default constructor is gone

Defining any constructor removes the default no-argument constructor, so `new Student()` would not compile unless you explicitly add a no-arg constructor.

To prevent invalid object creation and enforce invariants

Constructors can throw exceptions to prevent an object from being created in an invalid state, thereby enforcing object invariants.

It delegates to the parameterized constructor to set default values

The no-argument constructor uses `this("Unknown", 0)` to delegate to the parameterized constructor, centralizing initialization logic and providing sensible defaults.

It reduces code duplication by centralizing initialization

Delegating with `this(...)` reduces code duplication by having one constructor do the real initialization while others simply pass appropriate arguments.

—

This ensures delegation happens before any other initialization.

—

This fixed order ensures fields have their explicit initial values before the constructor runs.

—

The name must match the class name exactly.

—

This is a key design pattern for robust classes.

—

Other constructors simply pass appropriate arguments to the main constructor.

—

Defining any constructor removes the default.

`protected`

`protected` allows access to subclasses in different packages, which is exactly the requirement.

It exposes data to subclasses and same-package classes

Using `protected` excessively exposes data to more classes than necessary, which can lead to unintended coupling and potential misuse.

Data hiding is a subset of encapsulation

Data hiding (making fields private) is one aspect of encapsulation; encapsulation also includes bundling data with methods and controlling access through an interface.

1050.0, because `balance` is `protected` and `SavingsAccount` is a subclass, so it can modify its own inherited field.

The `balance` field is `protected`, which allows access within the same package and by subclasses, even in different packages. `SavingsAccount` is a subclass of `Account` and is in the same package (`com.bank`), so it can directly access and modify `balance`. The `applyInterest` method correctly updates the balance to…

```java public class User { private String password; public boolean validatePassword(String input) { return this.password.equals(input); } public void setPassword(String password) { if (password.length() >= 8) { this.password = password; } } } ```

Option B correctly encapsulates the `password` field by making it private and providing a setter that validates the password length. It also provides a `validatePassword` method that allows checking a password without exposing the actual password. This follows the principle of least privilege by not exposing the passwo…

Compilation error: variable s might not be initialized

Local variables must be initialized before use. Unlike fields, local variables do not get default values, so this code does not compile.

`2 2` because `a` and `b` refer to the same object, so both see the incremented count.

When `Counter b = a;` is executed, both `a` and `b` store the same reference (memory address) pointing to the same `Counter` object. Therefore, calling `increment()` through either variable modifies the same `count` field. Since `increment()` is called twice total, the shared `count` becomes 2, and both `a.count` and `…

```java BankAccount acc1 = new BankAccount(); BankAccount acc2 = new BankAccount(); acc1.deposit(100); acc1.withdraw(50); acc2.deposit(50); ```

To create two independent objects, you must use `new` twice, as in option B. This ensures `acc1` and `acc2` point to different objects. Then, `acc1.deposit(100)` sets acc1's balance to 100, `acc1.withdraw(50)` reduces it to 50, and `acc2.deposit(50)` adds 50 to acc2's balance. Option A makes both variables refer to the…

`Charlie Charlie` because `p2` now references the same object as `p1`, and the name is changed through that shared reference.

After `p2 = p1;`, both `p1` and `p2` refer to the same `Person` object (the one originally created with "Alice"). The object originally created with "Bob" becomes unreachable. Calling `p2.setName("Charlie")` modifies the shared object's `name` field. Therefore, both `p1.name` and `p2.name` print "Charlie", resulting in…

It prints `30` because after `b1 = b2;`, both variables refer to the same object, and modifying `b2.size` changes the shared object's field.

After `b1 = b2;`, both `b1` and `b2` reference the same `Box` object (the one created with size 20). The original object with size 10 becomes unreachable. When `b2.size = 30;` is executed, it modifies the shared object's `size` field. Since `b1` points to the same object, `b1.size` also reflects 30, so the output is `3…

They run in the order they appear in the source code

Static initializations (field declarations and static blocks) execute in the order they appear in the class body when the class is loaded.

They can access instance variables via an object reference

Static methods cannot directly access instance variables, but they can if given an object reference (e.g., as a parameter). They cannot use `this`.

To perform one-time setup when the class is loaded

Static blocks are used for complex static initialization, like loading configuration files, and run once when the class is loaded.

They are automatically final

Static members are not automatically final; they can be mutable (e.g., a static counter). `final` is a separate keyword.

—

This is similar to instance initialization order.

Base 15 Main 15 30

Static methods are hidden, not overridden, so `b.show()` calls `Base.show()` because the reference type is `Base`. `Base.x` is 15 (10+5 from static block). `Derived.x` is 30 (20+10 from static block). Thus output is `Base 15 Main 15 30`.

Constructors can throw exceptions to prevent invalid object creation

Constructors can throw exceptions (e.g., `IllegalArgumentException`) to prevent invalid object creation. They have no return type and are called only with `new`.

It is the final step in the creation phase, making the object ready for use

The constructor is the final step in the creation phase. After it completes, the object is fully initialized and ready for use.

—

This is a common pattern in frameworks like Spring.

—

This prevents invalid object creation.

—

These are key distinguishing features.

It throws `IllegalArgumentException` because the balance is negative.

The three-argument constructor explicitly checks `if (balance < 0)` and throws `IllegalArgumentException` before assigning any fields. Since -5.0 is negative, the exception is thrown, preventing the creation of an invalid object. The other options are incorrect because the constructor does not silently adjust the balan…

`Parent Child`

In Java, when a subclass object is created, the superclass constructor is implicitly called before the subclass constructor body executes. Here, `Parent`'s no-argument constructor prints "Parent ", then `Child`'s constructor prints "Child ". The explicit field initializer `int value = 10;` runs before the `Child` const…

It compiles and creates a `Config` object with `limit` set to 100.

The no-argument constructor calls `this(MAX)`, which is a valid delegation to the parameterized constructor. `MAX` is a `static final` constant, accessible from any instance method or constructor. The call `this(MAX)` is the first statement, satisfying the rule. Therefore, the code compiles and creates a `Config` objec…