What are all seven OOP concepts?

package com.bank.service;

public class TradeService {
    private final NotificationService notificationService; // association: uses

    public TradeService(NotificationService notificationService) {
        this.notificationService = notificationService;
        // TradeService does not CREATE notificationService: it is injected.
    }

    public void executeTrade(Trade trade) {
        // ... execute trade logic ...
        notificationService.sendTradeConfirmation(trade);
    }
}
// TradeService and NotificationService are associated.
// Neither owns the other. Spring injects the dependency.

package com.bank.model;

import java.util.ArrayList;
import java.util.List;

public class TradingDepartment {
    private String departmentName;
    private List<Trader> traders = new ArrayList<>();

    public void addTrader(Trader trader) {
        traders.add(trader);
        // Department does NOT create the trader.
    }

    public List<Trader> dissolve() {
        List<Trader> surviving = new ArrayList<>(traders);
        traders.clear();
        return surviving; // traders still exist, can join another department
    }
}
// department = null; traders still exist in memory.
// In JPA: NO cascade delete.

package com.bank.model;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

public class Account {
    private String accountId;
    private BigDecimal balance;
    private final List<Transaction> transactions = new ArrayList<>(); // composition: owns

    public void deposit(BigDecimal amount) {
        balance = balance.add(amount);
        transactions.add(new Transaction("CREDIT", amount, LocalDateTime.now()));
        // Account CREATES the transaction. It owns it.
    }

    public void close() {
        transactions.clear(); // transactions destroyed with account
        // In JPA: @OneToMany(cascade = ALL, orphanRemoval = true)
    }
}
// Transaction cannot exist without an Account.

// 1. MODULARITY: each class is a self-contained unit
// AccountService: handles balance, deposits, withdrawals
// TradeService: handles trade execution
// NotificationService: handles SMS/email
// Each can be developed, tested, and deployed independently.

// 2. MAINTAINABILITY: change one class without breaking others
// Change NotificationService from SMS to email: TradeService unchanged.
// Add NRIAccount: InterestBatchService unchanged (polymorphism).

// 3. REAL-WORLD MODELING: objects map to real things
// Account object = real bank account at National Bank of India
// Trade object = real stock trade on NSE
// Customer object = real customer like Rajesh

// ENCAPSULATION: Account.balance is private
// ABSTRACTION: PaymentService.transfer() hides NEFT/UPI complexity
// INHERITANCE: SavingsAccount extends Account
// POLYMORPHISM: account.calculateInterest() dispatches to correct override
// ASSOCIATION: SettlementService uses ClearingHouse (injected)
// AGGREGATION: TradingDepartment has Traders (traders survive dissolution)
// COMPOSITION: Trade owns Fees (fees die with the trade)

// WRONG: treating composition as aggregation
// Loan-EMI is composition, not aggregation.
// An EMI without a Loan is meaningless.
// If you model it as aggregation (no cascade delete),
// closing a loan leaves orphan EMI rows in the database.

// CORRECT:
@OneToMany(mappedBy = "loan", cascade = CascadeType.ALL, orphanRemoval = true)
private List<EMI> emis; // composition: EMIs die with the loan