Is there a way to get my program to start at the very beginning of a do while loop if an exception occurs?

Question

I want it to start again at the most outer for loop, so that if a user messes up the input, they can sign in again and everything work just like if the program started all over again. I tried using continue statements and break statements and using the nicknames for the loops. Like

outer: do {
//loop code
}
then break outer;

The problem is when I do that, it messes up my controlling of the loop. The end statement that asks the user if they want to go back to the main menu. Right now I just have the app exit, if an exception is encountered, using return statement, but If I'm just gonna exit, I might as well just let the app crash. I want to actually resolve the situation and ask the user for valid input.

package main;

import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Scanner;

import model.BankAccount;

public class app {

    static Scanner console = new Scanner(System.in);
    
    public static void main(String[] args) {
        
        HashMap<String, BankAccount> accounts = new HashMap<>();
        BankAccount sallyAccount = new BankAccount(1000);
        BankAccount bobAccount = new BankAccount(2000);
        BankAccount naomiAccount = new BankAccount();
        accounts.put("Sally", sallyAccount);
        accounts.put("Bob", bobAccount);
        accounts.put("Naomi", naomiAccount);
        String name;
        BankAccount account;
        int userInput;
        double amount;
        boolean again;
        
        do
        {
            again = true;
            System.out.println("Login: Enter your name.");
            name = console.next();
            account = accounts.get(name);
            if(account == null)
            {
                System.out.println("Please enter a valid name.");
                return;
            }
    
            do
            {
                System.out.println("1 - Deposit");
                System.out.println("2 - Withdraw");
                System.out.println("3 - View Balance");
                System.out.println("4 - Logout");
                userInput = console.nextInt();
                switch(userInput)
                {
                case 1:
                    System.out.println("Enter amount to deposit: ");
                    try
                    {
                        amount = console.nextDouble();
                    }
                    catch(InputMismatchException e)
                    {
                        System.out.println("Please enter a numeric amount.");
                        return;
                    }
                    if(amount < 0)
                    {
                        System.out.println("You can't withdraw a negative amount");
                        return;
                    }
                    account.deposit(amount);
                    break;
                case 2:
                    System.out.println("Enter amount to withdraw: ");
                    try
                    {
                        amount = console.nextDouble();
                    }
                    catch(InputMismatchException e)
                    {
                        System.out.println("Please enter a numeric amount.");
                        return;
                    }
                    if(amount < 0)
                    {
                        System.out.println("You can't withdraw a negative amount");
                        return;
                    }
                    account.withdraw(amount);
                    break;
                case 3:
                    System.out.println(account.getBalance());
                    break;
                case 4:
                    again = false;
                    break;
                default:
                    System.out.println("Enter a valid option.");
                }
            }
            while(again);
            System.out.println("Back to main menu? 1 - Yes, 2 - No");
            try
            {
                userInput = console.nextInt();
            }
            catch(InputMismatchException e)
            {
                System.out.println("Please enter a number");
                return;
            }
        }
        while(userInput == 1);
    }
}

package model;

public class BankAccount {

    private double balance = 0;
    
    public BankAccount() {}
    
    public BankAccount(double balance)
    {
        this.balance = balance;
    }
    
    public void deposit(double amount)
    {
        balance = balance + amount;
    }
    
    public void withdraw(double amount)
    {
        if((balance - amount) < 0)
        {
            System.out.println("Transaction Failed: You can't withdraw more than you have.");
        }
        else
        {
            balance = balance - amount;
        }
    }
    
    public double getBalance()
    {
        return balance;
    }
}

Answer 1

You'll be best served by breaking up your main function in multiple functions that handle different parts of the control logic. A good rule of thumb (for beginning programmers) is a function over ~10-15 lines should probably be multiple functions, though it's not an ironclad rule.

I rewrote your program to be multiple functions, but since this seems like a homework problem I won't post the whole thing. Rather, a general strategy with some snippets.

For example, when the user enters an amount to deposit or withdraw. What your programs wants in that moment is a single double, so you could request a single double, and let another method figure out how to get it:

switch (getMenuChoice()) {
    case 1:
        account.deposit(getDepositOrWithdrawAmount("deposit"));
        break;
    case 2:
        account.withdraw(getDepositOrWithdrawAmount("withdraw"));
        break;
    // etc.
}

Then, that function is responsible for looping infinitely until the user provides a valid value:

static double getDepositOrWithdrawAmount(String depositOrWithdraw) {
    // loop infinitely until we get a valid value
    while (true) {
      System.out.println("Enter amount to " + depositOrWithdraw);
      try {
        double amount = console.nextDouble();
        if (amount < 0) {
          System.out.println("You can't " + depositOrWithdraw + " a negative amount.");
        } else {
          // valid value! return for deposit / withdraw to use
          // , ending the infinite loop
          return amount;
        }
      } catch (InputMismatchException e) {
        System.out.println("Please enter a numeric amount.");

        // clear the bad token from the stream
        // if you don't do this, each time you
        // call `nextDouble`, the same value will
        // be returned, causing an infinite loop
        console.next();
      }
    }
  }

The nice thing about this function is it works in isolation:

public static void main(String[] args) {
  System.out.println("Test: " + getDepositOrWithdrawal("test!"));
}

Gives this result:

Enter amount to test!
abc
Please enter a numeric amount.
Enter amount to test!
not-a-number
Please enter a numeric amount.
Enter amount to test!
-5 
You can't test! a negative amount.
Enter amount to test!
1000
Test: 1000.0

This lets you test that pieces of your program are working on their own, instead of trying to debug one big program.

You can write other parts of your program as functions as well, but I'll leave that to you.