content: import java.util.ArrayList;
  import java.util.List;
  
  // Account interface
  interface Account {
      void deposit(double amount);
      void withdraw(double amount);
  }
  
  class SavingAccount implements Account {
      private double balance;
  
      public SavingAccount() {
          balance = 0;
      }
  
      @Override
      public void deposit(double amount) {
          balance += amount;
          System.out.println("Deposited: " + amount + " in Savings Account. New Balance: " + balance);
      }
  
      @Override
      public void withdraw(double amount) {
          if (balance >= amount) {
              balance -= amount;
              System.out.println("Withdrawn: " + amount + " from Savings Account. New Balance: " + balance);
          } else {
              System.out.println("Insufficient funds in Savings Account!");
          }
      }
  }
  
  class CurrentAccount implements Account {
      private double balance;
  
      public CurrentAccount() {
          balance = 0;
      }
  
      @Override
      public void deposit(double amount) {
          balance += amount;
          System.out.println("Deposited: " + amount + " in Current Account. New Balance: " + balance);
      }
  
      @Override
      public void withdraw(double amount) {
          if (balance >= amount) {
              balance -= amount;
              System.out.println("Withdrawn: " + amount + " from Current Account. New Balance: " + balance);
          } else {
              System.out.println("Insufficient funds in Current Account!");
          }
      }
  }
  
  class FixedTermAccount implements Account {
      private double balance;
  
      public FixedTermAccount() {
          balance = 0;
      }
  
      @Override
      public void deposit(double amount) {
          balance += amount;
          System.out.println("Deposited: " + amount + " in Fixed Term Account. New Balance: " + balance);
      }
  
      @Override
      public void withdraw(double amount) {
          throw new UnsupportedOperationException("Withdrawal not allowed in Fixed Term Account!");
      }
  }
  
  class BankClient {
      private List<Account> accounts;
  
      public BankClient(List<Account> accounts) {
          this.accounts = accounts;
      }
  
      public void processTransactions() {
          for (Account acc : accounts) {
              acc.deposit(1000);  // All accounts allow deposits
  
              // Assuming all accounts support withdrawal (LSP Violation)
              try {
                  acc.withdraw(500);
              } catch (UnsupportedOperationException e) {
                  System.out.println("Exception: " + e.getMessage());
              }
          }
      }
  }
  
  public class LSPViolated {
      public static void main(String[] args) {
          List<Account> accounts = new ArrayList<>();
          accounts.add(new SavingAccount());
          accounts.add(new CurrentAccount());
          accounts.add(new FixedTermAccount());
  
          BankClient client = new BankClient(accounts);
          client.processTransactions(); // Throws exception when withdrawing from FixedTermAccount
      }
  }
  