OOP principles overview in Java - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a class named Car.

Java

public class [1] {
    // class body
}

Drag options to blanks, or click blank then click option'

ACar

Bcar

CVehicle

DcarClass

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase for class names

Using a different name than intended

The class name should start with a capital letter and match the intended name. Here, Car is correct.

2fill in blank

medium

Complete the code to create an object of class Car.

Java

Car myCar = new [1]();

Drag options to blanks, or click blank then click option'

AVehicle

Bcar

CCar

DMyCar

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or different names

Using a class name that does not exist

To create an object, use the class name exactly as declared. Here, Car is correct.

3fill in blank

hard

Fix the error in the code to properly override the method start in class Car.

Java

public class Car {
    public void start() {
        System.out.println("Car started");
    }
}

public class SportsCar extends Car {
    @Override
    public void [1]() {
        System.out.println("SportsCar started fast");
    }
}

Drag options to blanks, or click blank then click option'

AStart

Brun

Cbegin

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using uppercase first letter in method name

Using a different method name

Method names are case-sensitive. To override, use the exact method name start.

4fill in blank

hard

Fill both blanks to define a class that inherits from Vehicle and overrides the move method.

Java

public class Car [1] Vehicle {
    @Override
    public void [2]() {
        System.out.println("Car is moving");
    }
}

Drag options to blanks, or click blank then click option'

Aextends

Bimplements

Cmove

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using implements instead of extends

Using wrong method name

Use extends to inherit from a class and override the move method.

5fill in blank

hard

Fill all three blanks to create a simple interface and a class that implements it.

Java

public interface [1] {
    void [2]();
}

public class Car implements [3] {
    public void start() {
        System.out.println("Car started");
    }
}

Drag options to blanks, or click blank then click option'

AVehicle

Bstart

DEngine

Attempts:

3 left

💡 Hint

Common Mistakes

Using class names instead of interface names

Mismatch between interface and implemented method names

The interface is named Engine, it declares the method start, and the class Car implements Engine.

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