Problem Statement: Bank Account System

You are tasked with designing and implementing a simplified Bank Account System in Java. This system must demonstrate a solid understanding of object-oriented programming (OOP) principles, including **interfaces**, **inheritance**, and **polymorphism**.

The system should be able to manage different types of bank accounts, such as Savings and Current accounts, each with its own specific behavior while sharing a common set of functionalities.

Functional Requirements

Common Functionality: All bank accounts must support the following operations:
- deposit(double amount): Adds a specified amount to the account.
- withdraw(double amount): Subtracts a specified amount from the account.
- getBalance(): Returns the current balance of the account.
Savings Account: This account type should have a minimum balance rule. A withdrawal should not be allowed if it brings the balance below a predefined minimum threshold (e.g., $1000).
Current Account: This account type has a feature to process a limited number of "overdraft" transactions. It can have a negative balance up to a certain limit (e.g., -$500).

Technical Requirements

Use an Interface: Create a Java interface, for example, BankAccount, that declares the common methods: deposit(), withdraw(), and getBalance().
Implement Classes: Create concrete classes, such as SavingsAccount and CurrentAccount, that **implement** the BankAccount interface.
Utilize Inheritance: You may use a base class (e.g., AbstractBankAccount) to hold common fields like balance and implement the deposit method, which is common to all. The specific withdrawal logic should then be overridden in the subclasses.
Demonstrate Polymorphism: In your main class (e.g., Main), create a variety of account objects (e.g., a SavingsAccount and a CurrentAccount) and store them in an array or a list of type BankAccount.
Dynamic Method Dispatch: Use a loop to iterate through the collection of BankAccount objects and call the withdraw() method on each. Observe how the correct, specific implementation is called at runtime for each object.

Testing Requirements

Your solution must be testable. Write a Main class that performs the following test cases:

Savings Account Test:
- Create a SavingsAccount with an initial balance of $1500.
- Attempt to withdraw $200. The transaction should succeed.
- Attempt to withdraw an amount that would leave the balance below the minimum threshold (e.g., try to withdraw another $400). This transaction should fail, and an appropriate message should be printed.
Current Account Test:
- Create a CurrentAccount with an initial balance of $300.
- Attempt to withdraw $500. The transaction should succeed, resulting in a negative balance.
- Attempt to withdraw an amount that would exceed the overdraft limit (e.g., try to withdraw another $200). This transaction should fail, and an appropriate message should be printed.
Polymorphism Test:
- Create a List and add both a SavingsAccount and a CurrentAccount object to it.
- Iterate through the list and try to withdraw a large amount (e.g., $1000) from each account. The output should clearly show how the withdrawal logic differs for each account type.