• Calling Conventions:
  • A calling convention is a protocol governing the calling of and returning from "subprograms"
• Some Observations:
  • A calling convention needs to consider information that needs to be saved/restored, parameters, return values, and the transfer of control
  • Many such protocols are possible
• An Abstraction:
  • We can ignore the details and consider an abstract activation record (or invocation record or stack frame)

• StackTraceElement :
  • An encapsulation of a stack frame
• Organization:
  • StackFrameElement objects are organized into a last-in, first-out (LIFO) "collection" (called a stack)
  • Each StackFrameElement object (except, perhaps, the top-most) represents a method invocation
  • The top-most StackFrameElement object can represent an execution point (e.g., the point at which a Throwable was created)

• Recall:
  • When an exception is never caught (e.g., re-thrown by every method including main()), the program terminates and a message is printed
• The Contents of the Message:
  • The LIFO "collection" of StackFrameElement objects

• Obtaining a Stack Trace:
  • The static getStackTrace() method in the Throwable class will return the stack trace (i.e., the LIFO StackTraceElement[]) that was created when the Throwable was created
  • The getStackTrace() method belonging to a Thread object returns its current stack trace and the current Thread (loosely, the current sequence of instructions) can be obtained using the static currentThread() method in the Thread class
• Useful Methods:
  • getClassName()
  • getFileName()
  • getLineNumber()
  • getMethodName()

javaexamples/oopbasics/banking/Account.java

/**
 * A simple "bank" Account
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class Account
{
    protected double balance;
    protected int    id;

    /**
     * Default constructor
     */
    public Account() 
    {

        balance = 0;
        id = -1;
    }

    /**
     * Explicit Value Constructor
     *
     * @param idNumber        The ID for the Account
     * @param initialDeposit  The initial deposit
     */
    public Account(int idNumber, double initialDeposit)
    {
        balance = 0;

        id = idNumber;
        if (initialDeposit > 0) balance = initialDeposit;
    }

    /**
     * Determine the maximum amount that can be withdrawn
     *
     * @return The size of the maximum possible withdrawal
     */
    public double amountAvailable()
    {
        return balance;
    }

    /**
     * Deposit money in this Account
     *
   * @param amount    The size of the deposit
   *
   * @return false if unable to deposit and true otherwise
   */
    public boolean deposit(double amount)
    {
        boolean ok;

        ok = false;
        if (amount >= 0) {

            balance += amount;
            ok = true;
        }

        return ok;
    }

    /**
     * Obtain the ID of this Account
     *
     * @return The ID of this Account
     */
    public int getID()
    {
        return id;
    }
  
    /**
     * Withdraw money from this Account
     *
     * @param amount   The size of the withdrawal
     *
     * @return false if unable to withdraw and true otherwise
     */
    public boolean withdraw(double amount)
    {
        boolean     ok;

        ok = false;
        if (amount >= 0) {

            // Check if available funds are sufficient
            // 
            // Note: amountAvailble() is overriden in the 
            // derived class OverdraftAccount.
            // Which version of amountAvailable() will be 
            // called?
            //
            if (amountAvailable() >= amount) {

                balance -= amount;
                ok = true;
            }
        }

        return ok;
    }
}
        

javaexamples/oopbasics/banking/OverdraftAccount.java

/**
 * A "bank" Account that allows the owner to withdraw more money
 * than is in the account 
 *
 * @version 1.0
 * @author  Prof. David Bernstein, James Madison University
 */
public class OverdraftAccount extends Account
{
    protected double   overdraftLimit;

    /**
     * Constructor
     *
     * @param idNumber        The ID for the Account
     * @param initialDeposit  The initial deposit
     * @param limit           The overdraft limit
     */
    public OverdraftAccount(int idNumber, 
                            double initialDeposit, double limit) 
    {
        balance = 0.0;
        
        id = idNumber;
        if (initialDeposit > 0) balance = initialDeposit;
        
        overdraftLimit = 0.0;
        if (limit > 0.0) overdraftLimit = limit;
    }

    /**
     * Determine the maximum amount that can be withdrawn
     *
     * Note: This method overrides amountAvailable() in Account.
     * This method is called by the method withdraw() which
     * is defined in Account.
     *
     * @return The size of the maximum possible withdrawal
     */
    public double amountAvailable() {

        return (balance+overdraftLimit);
    }
}
        

    // Suppose we add the following to the amountAvailable() method
    // in OverdraftAccount

    StackTraceElement[] trace;
    trace = Thread.currentThread().getStackTrace();
    for (int i=0; i<trace.length; i++) {
        System.out.println(trace[i]);
    }

    // And then do the following in the driver
    OverdraftAccount  billSmith;
    billSmith = new OverdraftAccount(1001,15000.00,5000.00);
    billSmith.withdraw(19000.00);
  

The Stack Trace:

  OverdraftAccount.amountAvailable(OverdraftAccount.java:20)
  Account.withdraw(Account.java:59)
  Driver.main(Driver.java:36)