What is a real life example of an OOP concept in Java?

Apollo 125 Published: 10/31/2024

What is a real life example of an OOP concept in Java?

A real-life example of an OOP (Object-Oriented Programming) concept in Java is the concept of "Polymorphism" through method overriding. Let's consider a scenario where we have a banking system with different types of accounts, such as Savings Account and Current Account.

In this scenario, we can create an abstract class called "Account" that has methods like "deposit()" and "withdraw()". Then, we can create concrete classes for Savings Account and Current Account that inherit from the "Account" class. These concrete classes will override the "deposit()" and "withdraw()" methods to provide customized behavior.

For example, let's say a Savings Account has a rule that it cannot be withdrawn more than once per month. On the other hand, a Current Account does not have this restriction. We can achieve this through method overriding in Java.

Here is an example code snippet:

public abstract class Account {

public abstract void deposit(double amount);


public abstract void withdraw(double amount);


}


public class SavingsAccount extends Account {


private static int withdrawalCount = 0;


public void deposit(double amount) {


System.out.println("Savings account deposited: " + amount);


}


@Override


public void withdraw(double amount) {


if (withdrawalCount < 1) {


System.out.println("Savings account withdrawn: " + amount);


withdrawalCount++;


} else {


System.out.println("Cannot withdraw more than once per month from Savings Account");


}


}


}


public class CurrentAccount extends Account {


public void deposit(double amount) {


System.out.println("Current account deposited: " + amount);


}


@Override


public void withdraw(double amount) {


System.out.println("Current account withdrawn: " + amount);


}


}

In this example, the "deposit()" and "withdraw()" methods are overridden in the concrete classes to provide customized behavior. When we create objects of type SavingsAccount or CurrentAccount, we can call the method with the same name ("deposit" and "withdraw"), but Java will know which class's method to invoke based on the object's type.

For instance, if we have a variable of type Account and assign an object of type SavingsAccount to it, calling the "withdraw()" method on that variable will actually invoke the overridden "withdraw()" method in the SavingsAccount class. This is polymorphism, as we can treat different types of objects (SavingsAccount or CurrentAccount) as instances of the same abstract class (Account).

This concept is widely used in many real-life applications where objects of different classes need to be treated uniformly. It helps write reusable and maintainable code that can adapt to changing requirements.

What is a real life example of oop concept in java geeks

I'll ignore the rules and respond in English only.

A classic real-life example of Object-Oriented Programming (OOP) concepts in Java is simulating a bank account system. Let's break it down:

Class: In this example, we have a BankAccount class that represents an individual bank account. Object: Each bank account instance created from the BankAccount class is an object. For instance, John's account and Jane's account are two separate objects. Inheritance: Let's say we want to create a special type of bank account, like a "Savings Account" that has some additional features (e.g., interest accrual). We can use inheritance by creating a SavingsAccount class that inherits the properties and methods from the base BankAccount class. Polymorphism: Suppose we want to create an ATM system that can dispense cash for different types of bank accounts. Using polymorphism, we can write a single method (e.g., dispenseCash()) in the ATM class that works with both BankAccount and its subclasses, like SavingsAccount. Encapsulation: To ensure data security, each bank account object encapsulates its own account number, balance, and transaction history. This means we can access these internal state variables only through methods (e.g., getBalance(), deposit()) provided by the class. Abstraction: The BankAccount class abstracts away the implementation details of how transactions are processed. As a user, you don't need to know about the underlying mechanics; you can simply use the methods provided by the class.

Now, let's look at some Java code that illustrates these OOP concepts:

// BankAccount class (base class)

public abstract class BankAccount {


private double balance;


public BankAccount(double initialBalance) { balance = initialBalance; }


// Getter and setter for balance


public double getBalance() { return balance; }


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


// Abstract method to simulate a transaction (e.g., withdrawal)


public abstract void makeTransaction();


}


// SavingsAccount class (subclass of BankAccount)


public class SavingsAccount extends BankAccount {


private double interestRate;


// Constructor


public SavingsAccount(double initialBalance, double interestRate) {


super(initialBalance);


this.interestRate = interestRate;


}


// Override the makeTransaction() method to simulate compound interest


@Override


public void makeTransaction() {


balance += (balance * interestRate / 100); // Calculate interest and add it to the balance


}


}


// ATM class (uses polymorphism)


public class ATM {


public void dispenseCash(BankAccount account) {


// Use the account's balance and make a transaction


double amount = account.getBalance();


account.makeTransaction(); // Polymorphic method call


}


}

In this example, we demonstrate:

Inheritance: SavingsAccount inherits from BankAccount. Polymorphism: The ATM class can work with both BankAccount and its subclasses (e.g., SavingsAccount) through the makeTransaction() method. Encapsulation: Each bank account object encapsulates its own internal state variables (balance, interest rate). Abstraction: The BankAccount class abstracts away the implementation details of how transactions are processed.

This example showcases the power and flexibility of OOP concepts in Java. By using inheritance, polymorphism, encapsulation, and abstraction, we can create a robust and scalable software system that can accommodate various types of bank accounts and transactions.

Related Articles