OOP principles overview in Java - Mini Project: Build & Apply

OOP Principles Overview in Java

📖 Scenario: Imagine you are creating a simple program to manage information about cars in a car rental service. You want to organize the data and behavior of cars using basic Object-Oriented Programming (OOP) principles.

🎯 Goal: Build a Java program that demonstrates the four main OOP principles: encapsulation, inheritance, polymorphism, and abstraction by creating classes and using them step-by-step.

📋 What You'll Learn

Create a class with private variables and public methods (encapsulation)

Create a subclass that inherits from a superclass (inheritance)

Use method overriding to show polymorphism

Use an abstract class with an abstract method (abstraction)

Print outputs to show how each principle works

💡 Why This Matters

🌍 Real World

Organizing code for vehicle management systems in rental or sales companies using OOP makes the code easier to maintain and extend.

💼 Career

Understanding OOP principles is essential for Java developers working on real-world applications, as it helps create clean, reusable, and scalable code.

1

Create the Car class with encapsulation

Create a class called Car with a private String variable model and a private int variable year. Add a public constructor that takes model and year as parameters and sets the variables. Add public getter methods getModel() and getYear() to access these variables.

Java

public class Car {
    // Your code here
}

Hint

Use private for variables and public for methods to follow encapsulation.

2

Create a subclass ElectricCar that inherits from Car

Create a class called ElectricCar that extends Car. Add a private int variable batteryCapacity. Create a constructor that takes model, year, and batteryCapacity and calls the superclass constructor for model and year. Add a public method getBatteryCapacity() to return the battery capacity.

Java

public class Car {
    private String model;
    private int year;

    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }
}

// Your code here

Hint

Use extends to inherit and super() to call the parent constructor.

3

Override a method to show polymorphism

In the Car class, add a public method public String start() that returns the String "Car is starting". In the ElectricCar class, override the start() method to return "Electric car is starting silently". This shows polymorphism by changing behavior in the subclass.

Java

public class Car {
    private String model;
    private int year;

    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }

    // Your code here
}

public class ElectricCar extends Car {
    private int batteryCapacity;

    public ElectricCar(String model, int year, int batteryCapacity) {
        super(model, year);
        this.batteryCapacity = batteryCapacity;
    }

    public int getBatteryCapacity() {
        return batteryCapacity;
    }

    // Your code here
}

Hint

Use the same method name in the subclass and add @Override above it.

4

Create an abstract Vehicle class to show abstraction and print outputs

Create an abstract class called Vehicle with an abstract method public abstract String fuelType(). Make Car extend Vehicle and implement fuelType() to return "Gasoline". Make ElectricCar override fuelType() to return "Electricity". In a Main class with main method, create a Car object and an ElectricCar object. Print the results of calling start() and fuelType() on both objects.

Java

public class Car extends Vehicle {
    // Your code here
}

public class ElectricCar extends Car {
    // Your code here
}

public class Main {
    public static void main(String[] args) {
        // Your code here
    }
}

Hint

Remember to declare Vehicle as abstract and implement fuelType() in subclasses. Use System.out.println() to print outputs.

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