Trouble with transfer and withdraw methods for Bank program

Question

I'm writing a Banking GUI program that will allow a user to transfer, withdraw or deposit money into a checking and savings account, and also allows them to check the balance of each. The balance and deposit methods are working fine.

The transfer method should allow the user to transfer the amount of money they enter in the text field so long as it's available. If it's not, an exception is thrown. The problem is that even if there is enough, the exception is still being thrown.

As for my withdraw method, it lets the user withdraw money in increments of $20. It works, but it keeps displaying a message that says there's not enough funds. It's also supposed to charge $1.50 after the user has withdrawn a combined total of four times for both accounts.

Banking class

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Banking extends JPanel
{ 
   private JFrame frame;
   private JPanel panel;
   private JButton withdraw;
   private JButton deposit;
   private JButton transfer;
   private JButton balance;
   private JRadioButton checking;
   private JRadioButton savings;
   private JTextField input;
   private Account checkingAccount;
   private Account savingsAccount;
   private Account currentAccount;
   private double amount;

   public Banking(Account checkingAccount,Account savingsAccount)
   {

       frame=new JFrame("ATM");
       panel=new JPanel();
       withdraw=new JButton("Withdraw");
       deposit=new JButton("Deposit");
       transfer=new JButton("Transfer");
       balance=new JButton("Balance");
       checking=new JRadioButton("Checking");
       savings=new JRadioButton("Savings");
       input=new JTextField("");
       this.checkingAccount=checkingAccount;
       this.savingsAccount=savingsAccount;

       panel.setLayout(new GridLayout(4,2));

       panel.add(withdraw);panel.add(deposit);
       panel.add(transfer);panel.add(balance);
       panel.add(checking);panel.add(savings);
       panel.add(input);

       frame.add(panel);
       frame.pack();
       frame.setLocationRelativeTo(null);
       frame.setSize(600,300);
       frame.setVisible(true);


       checking.addActionListener(new ActionListener(){

           public void actionPerformed(ActionEvent e)
           {
               if(checking.isSelected())
               {
                   currentAccount=checkingAccount;
                   savings.setSelected(false);
               }
           }
       });

       savings.addActionListener(new ActionListener(){

           public void actionPerformed(ActionEvent e)
           {
               if(savings.isSelected())
               {
                   currentAccount=savingsAccount;
                   checking.setSelected(false);
               }
           }
       });


       withdraw.addActionListener(new ActionListener(){

           public void actionPerformed(ActionEvent e)
           {


             try
             {
                 amount=Double.parseDouble(input.getText());
                 if(amount%20==0)
                 {
                     currentAccount.withdraw(amount);
                     JOptionPane.showMessageDialog(null, "You've withdrawn $"+amount);


                 }
                 else
                 {
                     JOptionPane.showMessageDialog(null, "You can only withdraw money in increments of $20");

                 }
             }
             catch(NumberFormatException a)
             {
                 JOptionPane.showMessageDialog(null, "Please enter a numerical number");
             } 
             catch (InsufficientFunds e1)
             {
                 JOptionPane.showMessageDialog(null, "Not enough funds");

             }

           }
       });


     transfer.addActionListener(new ActionListener(){

         public void actionPerformed(ActionEvent e)
         {
             if(currentAccount.equals(savingsAccount))
             {

                 try
                 {
                     currentAccount.transferTo(savingsAccount, amount);
                 }
                 catch(NumberFormatException a)
                 {
                     JOptionPane.showMessageDialog(null, "Please enter a numerical number");
                 } 
                 catch (InsufficientFunds e1)
                 {
                     JOptionPane.showMessageDialog(null, "Not enough funds");

                 }
             }
             else
             {
                 try
                 {
                     currentAccount.transferTo(checkingAccount, amount);
                 }
                 catch(NumberFormatException a)
                 {
                     JOptionPane.showMessageDialog(null, "Please enter a numerical number");
                 } 
                 catch (InsufficientFunds e1)
                 {
                     JOptionPane.showMessageDialog(null, "Not enough funds");
             }
     }
         }
   });

   deposit.addActionListener(new ActionListener(){

       public void actionPerformed(ActionEvent e)
       {
           try
           {
               amount=Double.parseDouble(input.getText());
               currentAccount.deposit(amount);
                 JOptionPane.showMessageDialog(null, "You've deposited $"+amount);


           }
          catch(NumberFormatException a)
          {
                 JOptionPane.showMessageDialog(null, "Please enter a numerical number");
          } 
       }
   });


   balance.addActionListener(new ActionListener(){

       public void actionPerformed(ActionEvent e)
       {

           JOptionPane.showMessageDialog(null, "You're balance is $ "+currentAccount.getBalance());

       }
   });


}
   public static void main(String[] args)
   {
       Account checking=new Account(3000.00);
       Account savings=new Account(5000.00);
       Banking myBank=new Banking(checking,savings);
   }
} 

Account class

public class Account
{
private double balance;
static int counter=0;

public Account(double balance)
{
    this.balance=balance;
}

public void withdraw(double amount) throws InsufficientFunds
{
     int counter=0;

    if(amount<=balance)
    {
        balance=balance-amount;
        counter++;

        if(counter>4)
        {
            if(balance<1.50)
            {
                throw new InsufficientFunds(1.50);
            }
            else
            {
                balance=balance-1.50;
            }
        }

    else
    {
        double needed=amount-balance;
        throw new InsufficientFunds(needed);
    }
    }


}

public double getBalance()
{
    return balance;
}

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

public void transferTo(Account bank, double amount) throws InsufficientFunds
{
    if(amount<=balance)
    {
        withdraw(amount);
        bank.deposit(amount);
    }
    else
    {
        throw new InsufficientFunds(amount);
    }
}
}

Insufficient Funds class

import java.io.*;
public class InsufficientFunds extends Exception
{
private double amount;

public InsufficientFunds(double amount)
{
      this.amount = amount;
}

public double getAmount()
{
      return amount;
}
}

Answer 1

I could only see 2 problems from what you explained ,

*Inside the withdraw method you are declaring a new counter which will make the counter always to 1 after increment counter++.

public void withdraw(double amount) throws InsufficientFunds{
     int counter = 0; // should be removed ..
}

**if the counter is greater than 4 you should already check whether the account has enough money for the fee of 1.50 before deducting the withdrawal amount

if(amount<=balance)
    {

    if(counter>4)
    {

        if(balance<(amount+1.50))
        {
            throw new InsufficientFunds((amount+1.50)-balance);
        }
        else
        {
            balance=balance-amount-1.50;
            counter++;
        }

    }else{

    balance=balance-amount;
    counter++;
    }
}