Throwing own exceptions

I have this class Account

    import java.io.IllegalArgumentException;

    class Account {
	    final int accountNo;
	    final Customer owner;
	    final double overdraft;

	    double balance = 0;

	    private Account(int accountNo, Customer owner, double overdraft) {
		    this.accountNo = accountNo;
		    this.owner = owner;
		    this.overdraft = overdraft;
	    }

	    void print() {
		    Out.println("Kontonummer: " + accountNo);
		    owner.print();
		    Out.format("Kontostand: %.2f%nÜberziehungsrahmen: %.2f%n", balance, overdraft);
	    }

	    public boolean deposit(double amount) throws IllegalArgumentException {
		    if (amount <= 0) {
			    throws new IllegalArgumentException("Cannot deposit negative amounts!");
			    break;
		    } else {
			    balance += amount;
			    return true;
		    }

		    public boolean withdraw(double amount) throws OverdraftLimitReachedException {
			    if (amount <= 0 || !isCovered(amount)) {
				    throw new OverdraftLimitReachedException("Overdraft limit has been reached", accountNo);
				    break;
			    } else {
				    balance -= amount;
				    return true;
			    }

			    boolean isCovered(double amount) {
				    return amount - overdraft <= balance;
			    }

			    boolean transfer(Account target, double amount) {
				    boolean success = withdraw(amount);
				    if (!success) return false;

				    target.deposit(amount);
				    return true;
			    }
		    }
        }
    }

Now I also have this exception that I wrote

    public class NoSuchAccountException extends AccountException {

	    public NoSuchAccountException(int accountNo) {
		    super(message, accountNo);
	    }
    }

Now I need to throw this exception in the class account,when the searched account number does not exist.Now my question is in which method(or function I think that is the same,please correct me if I'm wrong) do I throw this exception.And after what check.How would I check if the account number exist,and if it doesnt I'll throw this exception. Thank you!

EDIT: The class banking, to complete the program

class Banking {
static final int CAPACITY = 100;
final Account[] accounts = new Account[CAPACITY];
int nOfAccounts = 0;
int createAccount(String firstName, String lastName, String phone, double overdraft) {
if (nOfAccounts == CAPACITY) return -1;
// use nOfAccounts as accountNo and index to array
Customer owner = new Customer(firstName, lastName, phone);
Account account = new Account(nOfAccounts, owner, overdraft);
accounts[nOfAccounts] = account;
nOfAccounts++;
return account.accountNo;
}
boolean deposit(int accountNo, double amount) {
if (accountNo < 0 || accountNo >= nOfAccounts) return false;
Account account = accounts[accountNo];
return account.deposit(amount);
}
boolean withdraw(int accountNo, double amount) {
if (accountNo < 0 || accountNo >= nOfAccounts) return false;
Account account = accounts[accountNo];
return account.withdraw(amount);
}
boolean transfer(int fromNo, int toNo, double amount) {
if (fromNo < 0 || toNo < 0 ||
fromNo >= nOfAccounts || toNo >= nOfAccounts) return false;
Account from = accounts[fromNo];
Account to = accounts[toNo];
return from.transfer(to, amount);
}
double getBalance(int accountNo) {
if (accountNo < 0 || accountNo >= nOfAccounts) return 0;
Account account = accounts[accountNo];
return account.balance;
}
double getBalance() {
double sum = 0;
for (int i = 0; i < nOfAccounts; i++) {
sum += accounts[i].balance;
}
return sum;
}
void print() {
Out.println("---------- Bankauszug ----------");
for (int i = 0; i < nOfAccounts; i++) {
accounts[i].print();
Out.println("--------------------------------");
}
Out.format("Bilanzsumme: %.2f%n", getBalance());
Out.println("--------------------------------");
}
// --------------------- Optionaler Teil ---------------------
public static void main(String[] args) {
Banking banking = new Banking();
char op;
do {
printMenu();
op = readOperation();
switch (op) {
case 'a': {
printTitle("Konto anlegen");
String firstName = getString("Vorname");
String lastName = getString("Nachname");
String phone = getString("Telefonnummer");
double overdraft = getDouble("Überziehungsrahmen");
int accountNo = banking.createAccount(
firstName, lastName, phone, overdraft);
printMessage("Anlegen von Konto " + accountNo, accountNo != -1);
break;
}
case 'e': {
printTitle("Einzahlen");
int accountNo = getInt("Kontonummer");
double amount = getDouble("Einzahlungsbetrag");
boolean success = banking.deposit(accountNo, amount);
printMessage("Einzahlen", success);
break;
}
case 'b': {
printTitle("Abheben");
int accountNo = getInt("Kontonummer");
double amount = getDouble("Abhebungsbetrag");
boolean success = banking.withdraw(accountNo, amount);
printMessage("Abheben", success);
break;
}
case 't': {
printTitle("Überweisen");
int fromNo = getInt("Von Kontonummer");
int toNo = getInt("Auf Kontonummer");
double amount = getDouble("Betrag");
boolean success = banking.transfer(fromNo, toNo, amount);
printMessage("Überweisen", success);
break;
}
case 'd':
banking.print();
break;
case 'q':
Out.println("Beenden");
break;
default:
Out.println("Ungültige Operation");
break;
}
} while(op != 'q');
}
static void printMenu() {
Out.println();
Out.println("*********** Bankverwaltung ********");
Out.println("Konto anlegen ................... a");
Out.println("Einzahlen ....................... e");
Out.println("Beheben ......................... b");
Out.println("Überweisen ...................... t");
Out.println("Übersicht drucken ............... d");
Out.println("Beenden ......................... q");
Out.print("Welche Menuoption? [a|e|b|t|d|q]: ");
}
static char readOperation() {
char ch = Character.toLowerCase(In.readChar());
In.readLine();
return ch;
}
static void printTitle(String text) {
Out.println("*** " + text + " ***");
}
static String getString(String text) {
Out.print(text + ": ");
return In.readLine();
}
static double getDouble(String text) {
Out.print(text + ": ");
return In.readDouble();
}
static int getInt(String text) {
Out.print(text + ": ");
return In.readInt();
}
static void printMessage(String operation, boolean success) {
String message = success ?
operation + " erfolgreich durchgeführt" :
"Ungültige Operation";
Out.println(message);
}
}

It depends on the interface you create. You currently have an interface in your code where you return false if the account is not found or something other fails. That kind of error handling has benefits and drawbacks. One way that is potentially fragile is that the caller of the method(s) might forget to check the return code, which could be potentially very bad for this case (the caller first attempts to withdraw some money, which fails, and then deposits money into another account, creating money out of nowhere).

There are arguments for and against. An alternative way of doing error handling would be to throw exceptions instead of returning a boolean for error handling - that would have its own benefits and drawbacks. In Java, if you ensure it is a checked exception, the caller would be forced to catch or throw the exception as part of the type system. In any case, I don't know how I feel about mixing the two ways of handling errors, since that might be very error prone and confusing.

If you go along with the exception way of handling errors, one common refactoring might be to have a private method called checkOrThrowAccountMustExist, that takes an account ID as input and throws if it does not exist.

There is also the issue of whether to place the checks in the Banking class and/or in the Account class. My own feeling would be that it may make sense to include at least some checks in both, and that it would be a good idea to include checks in those classes that are exposed externally or to other parts of your program (and document if a class is not meant to be used outside a small part of your program). But this may or may not be outside the scope of your assignment.

I'd guess you have a class Bank or the like and a customer comes to do something with his money. So he gives you an account number, a task and maybe an amount of money.
This class would need an Array or List of Accounts. The methods in this class would be thew right place for your Exception. You than have methods, basically the same as in your account. They first check if the Account exists in the array / list and then call the method on the chosen account or throw the exception if it doesn't exist.

method vs function:
In my understanding methods and functions are the same except for one little difference: a function is a function in global space, whereas a method is a function bound to a class or an object. Thus Java doesn't have real functions. But in my understanding, every static method is a function, but bound to the namespace of a class. But that is more a practical than a theoretical point of view.

Extract the common place for acquiring the account

private Acount getAccount(accountNo) {
if (accountNo >= accounts.length || accounts[accountNo] == null) {
throw new NoSuchAccountException();
}
return account;
}
boolean deposit(int accountNo, double amount) {
Account account = getAccount(accountNo);
return account.deposit(amount);
}

Create a method in account class which accepts account number and return true if account is present otherwise false. You can call this method from deposit or withdraw methods and proceed only when it returns true otherwise throw NoSuchAccountException.