CS 46A - Lecture 6

Pre-class reading

• Sections 3.1 - 3.4
• Did you take the quiz?

Reminders

• Canvas has only three uses for us: Quizzes. Dropbox. Grades.
• Nobody reads what you post on Canvas.
• Those who posted the following will need to contact the appropriate person (me or the lab assistant) by email:

  Hello. I was just wondering how I got two out of four on the assignment? Does the scribe get two usually?
  Why did I get only 13 out of 14?
  Had no lab Partner and this didnt show up in my grades so im re-submitting it

• Some of you still didn't change your Canvas names. If you are one of the following, you need to change your profile!!!

  andyly25@yahoo.com
  jason900412@gmail.com
  johanhestenes@gmail.com
  nicholasbettencourt@yahoo.com
  Ryandpg@gmail.com
  tulan94@gmail.com
  velasquezariel92@gmail.com

Instance Variables

• Example: tally counter
  
• Simulator statements:

  Counter tally = new Counter(); 
  tally.count(); 
  tally.count();
  int result = tally.getValue(); // Sets result to 2

• Each counter needs to store a variable that keeps track of how many times the counter has been advanced

Instance Variables

• Instance variables store the data of an object
• Instance of a class: an object of the class
• The class declaration specifies the instance variables:

  public class Counter
  {
     private int value;
     ...
  }

Instance Variables

• An instance variable declaration consists of the following parts:
  • access specifier (private)
  • type of variable (such as int)
  • name of variable (such as value)
• Each object of a class has its own set of instance variables
• You should declare all instance variables as private

Instance Variables

Syntax 3.1 Instance Variable Declaration

Accessing Instance Variables

• The count method advances the counter value by 1:

  public void count() 
  {  
     value = value + 1; 
  }

• The getValue method returns the current value:

  public int getValue() 
  { 
     return value; 
  }

• Private instance variables can only be accessed by methods of the same class

Encapsulation

• Encapsulation is the process of hiding object data and providing methods for data access
• To encapsulate data, declare instance variables as private and declare public methods that access the variables
• Encapsulation allows a programmer to use a class without having to know its implementation
• Information hiding makes it simpler for the implementor of a class to locate errors and change implementations

Lectrure 6 Clicker Question 1

Consider the Counter class, that Coder Carla refines over time. Suppose Programmer Paul's code uses that class, and in his code, the statement

System.out.println(someCounter.getValue())

prints a negative number.  Which of the following statements applies?

1. This can never happen. A counter’s value starts at 0 and is advanced by the count method, so it should never be negative.
2. This is a consequence of integer overflow.
3. This is caused by a bug in Carla's code
4. This is caused by a bug in Paul's code

Specifying the Public Interface of a Class

Behavior of bank account (abstraction):

• deposit money
• withdraw money
• get balance

Specifying the Public Interface of a Class: Methods

Methods of BankAccount class:

• deposit
• withdraw
• getBalance

We want to support method calls such as the following:

harrysChecking.deposit(2000);
harrysChecking.withdraw(500);
System.out.println(harrysChecking.getBalance());

Specifying the Public Interface of a Class: Method Declaration

• A method declaration contains a header and a body consisting of statements that are executed when the method is called

• public void deposit(double amount) 
  {  
     implementation - filled in later 
  }

Specifying the Public Interface of a Class: Method Header

• access specifier (usually public)
• return type (such as void or double)
• method name (such as deposit)
• list of parameter variables (such as double amount)

Examples:

• public void deposit(double amount)
• public void withdraw(double amount)
• public double getBalance()

Specifying the Public Interface of a Class: Constructor Declaration

• A constructor initializes the instance variables
• Constructor name = class name
  

  public BankAccount()
  {
     // body--filled in later
  }

• Constructor body is executed when new object is created
• Statements in constructor body set the internal data of the object that is being constructed
• All constructors of a class have the same name
• Compiler can tell constructors apart because they take different parameters

BankAccount Public Interface

The public constructors and methods of a class form the public interface of the class:

public class BankAccount
{
   // private variables--filled in later

   // Constructors
   public BankAccount()
   {
      // body--filled in later
   }
   public BankAccount(double initialBalance)
   {
      // body--filled in later
   }

   // Methods
   public void deposit(double amount)
   {
      // body--filled in later
   }
   public void withdraw(double amount)
   {
      // body--filled in later
   }
   public double getBalance()
   {
      // body--filled in later
   }
}

Syntax 3.2 Class Declaration

Lecture 6 Clicker Question 2

What does the following code print?

BankAccount harrysChecking = new BankAccount(10000); 
harrysChecking.withdraw(harrysChecking.getBalance());
harrysChecking.deposit(harrysChecking.getBalance());
System.out.println(harrysChecking.getBalance());

1. 10000
2. 0
3. Something else
4. Nothing—there is a compile-time error

Lecture 6 Clicker Question 3

Suppose you want a more powerful bank account abstraction that keeps track of an account number in addition to the balance. The following are proposed to accommodate this enhancement?

1. Add a getAccountNumber method
2. Add an accountNumber parameter to the constructor
3. Add an accountNumber parameter to the getBalance method

Which should be adopted?

1. a only
2. b only
3. a and b
4. a, b, and c

Commenting the Public Interface

/**
   Withdraws money from the bank account.
   @param amount the amount to withdraw
*/
public void withdraw(double amount)
{
   //implementation filled in later 
}

/**
   Gets the current balance of the bank account.
   @return the current balance
*/
public double getBalance()
{
   //implementation filled in later
}

Class Comment

/**
   A bank account has a balance that can be changed by
   deposits and withdrawals.
*/
public class BankAccount
{
   . . .
}

• Provide documentation comments for
  • every class
  • every method
  • every parameter
  • every return value

Javadoc Method Summary

Javadoc Method Detail

Self Check 3.9

Provide documentation comments for the Counter class of Section 3.1.

• Answer:

  /** 
     This class models a tally counter. 
  */ 
  public class Counter 
  { 
     private int value; 
     /** 
        Gets the current value of this counter. 
        @return the current value 
     */ 
     public int getValue() 
     { 
        return value; 
     } 
     /** 
        Advances the value of this counter by 1. 
     */ 
     public void count() 
     { 
        value = value + 1; 
     } 
  }

Lecture 6 Clicker Question 4

Why is the following documentation comment questionable?

/**
   Each account has an account number.
   @return the account number of this account
*/
public int getAccountNumber()

1. The description does not specify the purpose of the method
2. There is no @param statement
3. The @return statement does not include the name of the parameter
4. The @return statement does not end in a period