OOP principles overview in Java

Introduction

OOP helps organize code by grouping related data and actions together. It makes programs easier to build, understand, and change.

When building programs that model real-world things like cars, animals, or users.

When you want to reuse code without rewriting it.

When you want to keep parts of your program separate and easy to fix.

When working on large projects with many programmers.

When you want your program to be easy to grow and add new features.

Syntax

Java

class ClassName {
    // fields (data)
    // methods (actions)
}

A class is like a blueprint for objects.

Objects are created from classes and hold actual data.

Examples

This class has a color and a drive action.

Java

class Car {
    String color;
    void drive() {
        System.out.println("Driving");
    }
}

This class models a dog that can bark.

Java

class Dog {
    String name;
    void bark() {
        System.out.println("Woof!");
    }
}

Sample Program

This program shows inheritance and method overriding. Dog inherits from Animal and changes how speak() works.

Java

class Animal {
    String name;
    void speak() {
        System.out.println(name + " makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println(name + " says Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.speak();
    }
}

Important Notes

Encapsulation means keeping data safe inside classes.

Inheritance lets one class use features of another.

Polymorphism means one action can work in different ways.

Abstraction hides complex details and shows only what is needed.

Summary

OOP groups data and actions into classes and objects.

Four main principles: Encapsulation, Inheritance, Polymorphism, Abstraction.

OOP makes code easier to manage and grow.

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