Rural Bank Account Management System (RBAMS)

Project Overview

This is a console-based banking application developed for the Rural Bank of Nepal (RBN) to support financial inclusion in remote areas. The system implements core banking operations while adhering to object-oriented programming principles.

Class Design and OOP Implementation

1. Abstraction

• Abstract Class: BankAccount serves as the base class with common attributes and abstract methods
• Interface: Transaction interface defines the contract for banking operations
• Abstract Method: getAccountType() must be implemented by concrete classes

2. Inheritance

• SavingsAccount extends BankAccount
• CurrentAccount extends BankAccount
• Both child classes inherit common properties and override specific behaviors

3. Encapsulation

• All data members are private with public getter/setter methods
• Protected access for balance to allow child class access
• Private helper methods for internal operations

4. Polymorphism

• Method Overriding: withdraw() method behaves differently in savings vs current accounts
• Runtime Polymorphism: Same interface used for different account types
• Method Overloading: Multiple constructors with different parameters

5. Aggregation

• Customer class contains a collection of BankAccount objects
• Demonstrates "HAS-A" relationship (Customer has accounts)

Key Features

Account Types

1. Savings Account

   • Interest calculation and application
   • Strict balance checking (no overdraft)
   • Interest rate management

2. Current Account

   • Overdraft facility up to predefined limit
   • Business transaction support
   • Flexible withdrawal rules

Exception Handling

• Custom Exception: InsufficientBalanceException
• Thrown when withdrawal exceeds available funds
• Proper exception handling with user-friendly messages

Operations Supported

• Create new accounts (Savings/Current)
• Deposit money
• Withdraw money (with balance/overdraft validation)
• Add interest to savings accounts
• View all customer accounts
• Account details display

Technical Implementation

Design Patterns Used

• Template Method Pattern: Abstract class with common implementation
• Strategy Pattern: Different withdrawal strategies for account types
• Factory Pattern: Account creation based on type selection

Data Validation

• Input validation for amounts and menu choices
• Exception handling for invalid operations
• User-friendly error messages

Security Features

• Unique account number generation
• Balance validation before transactions
• Overdraft limit enforcement

How to Run

1. Compile all Java files: javac *.java
2. Run the main class: java RuralBankSystem
3. Follow the console prompts to interact with the system

Sample Usage Flow

1. Enter customer name
2. Create accounts (Savings/Current)
3. Perform banking operations
4. View account details
5. Handle exceptions gracefully

Code Structure

├── Transaction.java (Interface)
├── InsufficientBalanceException.java (Custom Exception)
├── BankAccount.java (Abstract Base Class)
├── SavingsAccount.java (Concrete Implementation)
├── CurrentAccount.java (Concrete Implementation)
├── Customer.java (Aggregation Class)
└── RuralBankSystem.java (Main Application)

This implementation demonstrates comprehensive OOP principles while providing a practical banking solution for rural communities.

## Screenshots and Testing

Here are the key operations you should test:

1. **Account Creation and Deposit**:
   - Create both savings and current accounts
   - Test deposit functionality

2. **Withdrawal with Exception Handling**:
   - Try withdrawing more than balance from savings account
   - Test overdraft functionality in current account

3. **Interest Addition**:
   - Add interest to savings accounts
   - Verify balance updates

The system implements all required OOP concepts:

- **Abstraction**: Abstract `BankAccount` class and `Transaction` interface
- **Inheritance**: `SavingsAccount` and `CurrentAccount` extend `BankAccount`
- **Encapsulation**: Private data members with public getters/setters
- **Polymorphism**: Overridden `withdraw()` methods behave differently
- **Aggregation**: `Customer` class contains multiple `BankAccount` objects

The custom exception handling ensures robust error management, and the console interface provides an intuitive user experience suitable for rural banking scenarios.