Question

No matter which editor you’re using, there are debugging tools that can help simplify the process of hunting down logic errors. In Eclipse and BlueJ, you just need to toggle a breakpoint in the gutter of the text area; this should place a blue circle next to the line of code your debugger will execute up to. Then to debug, instead of play, click on the “little bug” icon next to play. Say yes to the perspective change dialog, and watch as your code executes up until the breakpoint. Once your code is paused, you now have the option to inspect variables and their values (hover over them or use a watch). You can step over whole lines at a time (such as function calls) or step into a function call to examine the execution further. If you’re using JEdit, you may have to configure the plug-in manager to include a debugger. If on linux, consider using gdb, which offers command-line debugging (and there are GUIs to wrap this). Answer the following questions in your comments in any file and submit that.

(1) Using your debugger, debug Account.java and DebuggingExercise4.java

(2) Hover over variables to see their values. a. Where is the variable watch window on your screen? i. What information does this present to you? 1. Describe this in comments in your code. b. Where is the method call stack on your screen? i. What information does this describe?

(3) Find the shortcut keys for the following debugging commands, and describe what each does in comments. a. Step over i. What does this do? b. Step into i. What does this do

ii. How is it different from step over? c. Step out i. What does this do? ii. How is it different from step over or step into? d. Continue i. What does this do? ii. How is it different than moving in steps?

DebugginExersie4

class DebuggingExercise4
{
public static void main(String[] args)
{
Account a = null;
a.deposit(100);
System.out.println(a.getOwner() + " has $" + a.getBalance());
a.withdraw(200);
System.out.println("After trying to withdraw $200, " + a.getOwner() + " has $" + a.getBalance());
}
}

Account.java

{
// Instance variables
   private double balance;   // invariant: balance >= 0 (should never be negative)
   private String owner;

//Constructor
   public Account(String name)
   {
       balance = 0;
       owner = name;
   }

// Instance methods
   /** Deposits 'amount' into the account
   */
   public void deposit(int amount)
   {
       balance = balance + amount;
   }

   /** Withdraws 'amount' from the account.
   *   This only makes sense if amount <= balance.
   *   This method should be re-written so that there is not a possibility of
   *   having a negative balance.
   */
   public void withdraw(int amount)
   {
       balance = balance - amount;
   }

   /* Returns the balance of the Account
   */
   public double getBalance()
   {
       return balance;
   }

   /* Returns the owner of the Account
   */
   public String getOwner()
   {
       return owner;
   }
}

Answer 1

Please let me know if you have any doubts or you want me to modify the answer. And if you find this answer useful then don't forget to rate my answer as thumps up. Thank you! :)

class DebuggingExercise4 {
    public static void main(String[] args) {
        Account a = new Account("John");
        a.deposit(100);
        System.out.println(a.getOwner() + " has $" + a.getBalance());
        a.withdraw(200);
        System.out.println("After trying to withdraw $200, " + a.getOwner() + " has $" + a.getBalance());
    }
}
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public class Account {
    private double balance;
    private String owner;

    //Constructor
    public Account(String name) {
        balance = 0;
        owner = name;
    }

    // Deposits amount into the account

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

    // Withdraws 'amount' from the account.

    public void withdraw(int amount) {
        if (amount <= balance) {
            balance = balance - amount;
        }
    }

    // Returns the balance of the Account

    public double getBalance() {
        return balance;
    }

    // Returns the owner of the Account

    public String getOwner() {
        return owner;
    }
}

----------------------------------------------------------------------------------------------------------------------------------

Where is the variable watch window on your screen?
Answer: Bottom panel (below the code editor where output shows).

What information does this present to you?
Answer:
args (String[])
Account)
balance (double)
owner name (String)
value (char[])
hash (int)

Where is the method call stack on your screen?
Answer:
To the left of the variables

What information does this describe?
Answer:
The active threads and the call stack.

Step Over: What does this do?
Answer:
Go to the next line in the block.

Step Into: What does this do?
Answer:
Go to the next line or into a user defined method.

Step Out: What does this do?
Answer:
Completes and moves to to the point that called the method

Continue: What does this do?
Answer:
Runs the program from where programmer has set debug point up to the end of the program or to the point where programmer has set break point