OOP principles overview in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Encapsulation in OOP?

Encapsulation means keeping data (variables) and methods (functions) that work on the data together inside a class. It hides the internal details and only exposes what is necessary.

beginner

Define Inheritance in simple terms.

Inheritance allows a new class to get properties and behaviors from an existing class. It helps reuse code and create a hierarchy.

intermediate

What does Polymorphism mean in OOP?

Polymorphism means one action can behave differently based on the object it is acting on. For example, the same method name can do different things in different classes.

intermediate

Explain Abstraction with an example.

Abstraction means showing only the important details and hiding the complex inner workings. For example, when you drive a car, you use the steering wheel without knowing how it works inside.

beginner

List the four main OOP principles.

The four main OOP principles are:
1. Encapsulation
2. Inheritance
3. Polymorphism
4. Abstraction

Which OOP principle means hiding internal details and showing only necessary parts?

A Inheritance

B Abstraction

C Polymorphism

D Encapsulation

Abstraction hides complex details and shows only what is needed.

What does inheritance allow a class to do?

A Hide data from other classes

B Create unrelated objects

C Change method names dynamically

D Reuse code from another class

Inheritance lets a class reuse properties and methods from a parent class.

Polymorphism allows methods to:

A Create new classes from scratch

B Hide data inside a class

C Have the same name but behave differently

D Prevent code reuse

Polymorphism means one method name can work differently depending on the object.

Encapsulation is best described as:

A Combining data and methods in one unit

B Using inheritance to extend classes

C Changing method behavior at runtime

D Showing only important details

Encapsulation groups data and methods inside a class to protect and organize them.

Which principle helps in creating a class hierarchy?

A Inheritance

B Abstraction

C Polymorphism

D Encapsulation

Inheritance creates a hierarchy by letting classes inherit from others.

Explain the four main OOP principles and give a simple example for each.

Think about how classes hide data, reuse code, behave differently, and hide complexity.

Why is encapsulation important in programming? How does it help in real-life coding?

Consider how keeping things private helps avoid mistakes.

Practice

1. Which of the following is NOT one of the four main principles of Object-Oriented Programming (OOP)?

easy

A. Encapsulation

B. Inheritance

C. Polymorphism

D. Compilation

Solution

1. Step 1: Recall the four main OOP principles

   The four main principles are Encapsulation, Inheritance, Polymorphism, and Abstraction.

2. Step 2: Identify the option not in the list

   Compilation is a process of converting code to machine language, not an OOP principle.

3. Final Answer:

   Compilation -> Option D

4. Quick Check:

   OOP principles exclude Compilation [OK]

Hint: Remember the four OOP pillars: E, I, P, A [OK]

Common Mistakes:

• Confusing compilation with abstraction
• Mixing OOP principles with programming processes

2. Which Java keyword is used to inherit properties from a parent class?

easy

A. implements

B. inherits

C. extends

D. super

Solution

1. Step 1: Identify the keyword for class inheritance in Java

   Java uses the keyword extends to inherit from a parent class.

2. Step 2: Differentiate from other keywords

   implements is for interfaces, super accesses parent members, and inherits is not a Java keyword.

3. Final Answer:

   extends -> Option C

4. Quick Check:

   Inheritance keyword = extends [OK]

Hint: Use 'extends' to inherit classes in Java [OK]

Common Mistakes:

• Using 'implements' for class inheritance
• Confusing 'super' with inheritance keyword

3. What will be the output of the following Java code?

class Animal {
  void sound() { System.out.println("Animal sound"); }
}
class Dog extends Animal {
  void sound() { System.out.println("Bark"); }
}
public class Test {
  public static void main(String[] args) {
    Animal a = new Dog();
    a.sound();
  }
}

medium

A. Bark

B. Animal sound

C. Compilation error

D. Runtime error

Solution

1. Step 1: Understand method overriding and polymorphism

   The object a is declared as Animal but refers to a Dog instance. The sound() method is overridden in Dog.

2. Step 2: Determine which method runs at runtime

   Java uses dynamic method dispatch, so the Dog's sound() method runs, printing "Bark".

3. Final Answer:

   Bark -> Option A

4. Quick Check:

   Overridden method runs = Bark [OK]

Hint: Overridden methods run from actual object type [OK]

Common Mistakes:

• Thinking declared type method runs
• Expecting compilation or runtime errors

4. Identify the error in the following Java code snippet:

class Vehicle {
  private int speed;
  public int getSpeed() { return speed; }
}
class Car extends Vehicle {
  public void setSpeed(int speed) { this.speed = speed; }
}

medium

A. Cannot access private field 'speed' directly in subclass

B. Cannot override getSpeed() method

C. Missing constructor in Car class

D. No error, code is correct

Solution

1. Step 1: Check access to private fields in subclass

   The field speed is private in Vehicle, so Car cannot access it directly.

2. Step 2: Analyze the setSpeed method in Car

   Car's setSpeed tries to assign this.speed, which is not accessible, causing a compile error.

3. Final Answer:

   Cannot access private field 'speed' directly in subclass -> Option A

4. Quick Check:

   Private fields inaccessible in subclass [OK]

Hint: Private fields are not visible in subclasses [OK]

Common Mistakes:

• Assuming private fields are inherited
• Ignoring access modifiers

5. You want to design a Java class hierarchy where different shapes (Circle, Rectangle) can calculate their area. Which OOP principle best supports writing a method double getArea() in a base class or interface and having each shape provide its own implementation?

hard

A. Encapsulation

B. Polymorphism

C. Abstraction

D. Inheritance

Solution

1. Step 1: Understand the scenario of method overriding

   Each shape class provides its own version of getArea(), meaning the method behaves differently depending on the object.

2. Step 2: Identify the OOP principle for multiple forms of a method

   This is Polymorphism, where the same method name works differently in subclasses.

3. Final Answer:

   Polymorphism -> Option B

4. Quick Check:

   Different behaviors for same method = Polymorphism [OK]

Hint: Same method, different behaviors = Polymorphism [OK]

Common Mistakes:

• Confusing abstraction with polymorphism
• Thinking inheritance alone handles this