XQA
Back to Java
2025-12-087 min read

Java OOP

Learn Java OOP step by step with clear examples and exercises.

Title: Java Object-Oriented Programming (OOP) - A full guide for Beginners

Why This Matters

Java Object-Oriented Programming (OOP) is a fundamental concept that every Java programmer should master. OOP allows you to design and implement complex applications by breaking them down into smaller, more manageable components called objects. Understanding OOP will make your code easier to maintain, reuse, and test. In interviews, being proficient in OOP can set you apart from other candidates.

By learning OOP, you'll be able to:

  • Write modular, flexible, and scalable code
  • Create classes with properties (attributes) and methods (functions)
  • Implement inheritance and polymorphism for code reuse and abstraction
  • Encapsulate data and behavior within objects, promoting security and maintainability

Prerequisites

Before diving into Java OOP, you should have a solid understanding of the following:

  1. Basic Java syntax (variables, operators, control structures)
  2. Data structures (arrays, lists, maps)
  3. Exception handling
  4. File I/O
  5. Understanding the difference between primitive types and reference types
  6. Understanding the concept of static members in a class
  7. Familiarity with Java's access modifiers (public, private, protected, default)
  8. Understanding the basics of inheritance and polymorphism
  9. Comfortable with using constructors, getters, and setters
  10. Knowledge of interfaces and abstract classes

Core Concept

In Java, an object is an instance of a class. A class is a blueprint for creating objects that have properties (attributes) and methods (functions). Here's a simple example:

public class Car {
private String color;
private int speed;
private double fuelLevel;

public Car(String color, int speed, double fuelLevel) {
this.color = color;
this.speed = speed;
this.fuelLevel = fuelLevel;
}

public void setColor(String color) {
this.color = color;
}

public void setSpeed(int speed) {
if (speed > 0 && speed <= MAX_SPEED) {
this.speed = speed;
} else {
System.out.println("Invalid speed.");
}
}

public void setFuelLevel(double fuelLevel) {
if (fuelLevel >= 0 && fuelLevel <= MAX_FUEL_LEVEL) {
this.fuelLevel = fuelLevel;
} else {
System.out.println("Invalid fuel level.");
}
}

public String getColor() {
return color;
}

public int getSpeed() {
return speed;
}

public double getFuelLevel() {
return fuelLevel;
}

public void accelerate() {
if (speed < MAX_SPEED && fuelLevel > 0) {
speed += ACCELERATION;
fuelLevel -= FUEL_CONSUMPTION_PER_KM;
} else if (speed == MAX_SPEED) {
System.out.println("Car is already at maximum speed.");
} else if (fuelLevel == 0) {
System.out.println("Not enough fuel to accelerate.");
}
}
}

In this example, Car is a class with three private properties (color, speed, and fuelLevel) and five methods (setColor(), setSpeed(), setFuelLevel(), getColor(), getSpeed(), and getFuelLevel()). The constructor initializes the properties, and the accelerate() method allows the car to move.

Worked Example

Let's create a simple Java program that demonstrates OOP concepts. The program will simulate a bank account with properties (balance, interest rate) and methods (deposit, withdraw, calculateInterest).

public interface BankAccount {
void deposit(double amount);
void withdraw(double amount);
void calculateInterest();
}

public class SavingsAccount implements BankAccount {
private double balance;
private double interestRate;

public SavingsAccount(double initialBalance, double interestRate) {
this.balance = initialBalance;
this.interestRate = interestRate;
}

@Override
public void deposit(double amount) {
balance += amount;
}

@Override
public void withdraw(double amount) {
if (amount <= balance) {
balance -= amount;
} else {
System.out.println("Insufficient funds.");
}
}

@Override
public void calculateInterest() {
double interest = balance * interestRate;
System.out.println("Interest: " + interest);
deposit(interest);
}
}

Now let's create a new instance of the SavingsAccount class and perform some operations:

public class Main {
public static void main(String[] args) {
BankAccount myAccount = new SavingsAccount(1000, 0.05);
System.out.println("Initial balance: " + myAccount.getBalance());

myAccount.deposit(500);
System.out.println("Deposited 500");
System.out.println("Current balance: " + myAccount.getBalance());

myAccount.withdraw(300);
System.out.println("Withdrew 300");
System.out.println("Current balance: " + myAccount.getBalance());

myAccount.calculateInterest();
System.out.println("Calculated interest and deposited it.");
System.out.println("Current balance: " + myAccount.getBalance());
}

private double getBalance() {
return ((SavingsAccount) myAccount).balance;
}
}

In this example, we have an interface BankAccount with three methods (deposit, withdraw, and calculateInterest). We then create a concrete implementation of the interface called SavingsAccount. The Main class creates an instance of SavingsAccount and performs some operations using the interface methods.

Common Mistakes

  1. Forgetting to initialize properties in the constructor: If you don't initialize properties in the constructor, they will have their default values (0 for numeric types, null for object types). This can lead to unexpected behavior.
public class Car {
String color; // Default value: null
int speed; // Default value: 0
}
  1. Not understanding the difference between instance variables and local variables: Instance variables belong to an object, while local variables belong to a method or block of code. If you try to use a local variable outside its scope, you'll get a compiler error.
  1. Using public fields instead of private properties with getters and setters: Public fields are bad practice because they violate encapsulation. Instead, use private properties with getters (accessors) and setters (mutators).
  1. Not properly implementing equals() and hashCode() methods in your classes: If you don't implement these methods correctly, it can lead to issues when using collections or comparing objects.
  1. Overusing inheritance: Inheritance is a powerful feature, but overuse can make code difficult to understand and maintain. Try to use composition (creating one object within another) instead of inheritance when possible.
  1. Not understanding the difference between abstract classes and interfaces: Abstract classes can have implementation details while still being incomplete, whereas interfaces only define method signatures without any implementation.

Practice Questions

  1. Create a class Rectangle with properties width, height, and methods getArea(), getPerimeter().
  2. Write a program that simulates a simple vending machine. The vending machine has properties (inventory, money) and methods (insertCoin, selectItem, dispenseChange).
  3. Create a class Person with properties name, age, and methods getName(), getAge(), setName(String name), setAge(int age).
  4. Implement the equals() and hashCode() methods in the Person class to ensure proper behavior when comparing instances of the class.
  5. Create a class Shape with an abstract method calculateArea(). Create two classes Circle and Square that extend Shape and implement the calculateArea() method for each class.
  6. Implement a simple Java program that simulates a library system. The program should have properties (books, members) and methods (borrowBook, returnBook, checkOutStatus).
  7. Create a class Employee with properties name, salary, and department. Implement a method raiseSalary(double percentage) that increases the employee's salary by the given percentage.
  8. Write a program that simulates a simple restaurant order system. The program should have a menu (properties and methods), an order (properties and methods), and a customer (properties and methods).
  9. Create a class Car with properties color, speed, and fuelLevel. Implement a method drive(double distance) that reduces the fuel level based on the distance driven.
  10. Write a program that simulates a simple video game. The game should have a player (properties and methods), enemies (properties and methods), and power-ups (properties and methods).

FAQ

  1. Why should I use OOP in Java?
  • OOP allows for better code organization and reusability
  • It promotes encapsulation, which improves security by hiding implementation details
  • It makes it easier to write testable code
  • It enables polymorphism and inheritance, allowing for more flexible and scalable solutions
  1. What is the difference between a class and an object?
  • A class is a blueprint or template for creating objects
  • An object is an instance of a class that has its own properties and methods
  1. Why should I use private properties with getters and setters instead of public fields?
  • Private properties with getters and setters promote encapsulation, making it easier to control access to the data and maintain consistency across objects
  • Public fields can lead to unexpected behavior if not properly managed
  1. What is inheritance in Java?
  • Inheritance is a mechanism that allows one class (the subclass or derived class) to acquire the properties and behaviors of another class (the superclass or base class)
  • It helps promote code reuse and abstraction by allowing you to create classes that share common characteristics
  1. What is polymorphism in Java?
  • Polymorphism allows objects of different classes to be treated as if they were instances of a single class
  • It can take two forms: compile-time polymorphism (method overloading and constructor overloading) and runtime polymorphism (method overriding and interface implementation)
  1. What is encapsulation in Java?
  • Encapsulation is the practice of hiding the internal details and complexities of an object from external users, while providing a simple interface for interacting with it
  • In Java, encapsulation is achieved through the use of access modifiers (public, private, protected) and by using private properties with getters and setters instead of public fields
  1. What is the difference between an abstract class and an interface in Java?
  • An abstract class can have implementation details while still being incomplete, whereas an interface only defines method signatures without any implementation
  • Abstract classes can be instantiated, while interfaces cannot be instantiated; they must be implemented by concrete classes
  1. What is the purpose of final keywords in Java?
  • The final keyword can be used to declare constant values, methods that cannot be overridden, and classes that cannot be subclassed
  • It helps promote code stability and security by preventing unintended modifications
  1. What is the difference between a static method and an instance method in Java?
  • Static methods belong to the class itself, not to any specific object of the class
  • Instance methods can only be called on objects of the class, and they have access to both instance variables and static variables
  1. What is the purpose of constructors in Java?
  • Constructors are special methods that are used to create and initialize objects of a class
  • They allow you to set initial values for instance variables and perform any other necessary setup when creating new objects
Java OOP | Java | XQA Learn