Copyright © 2013
Robert W. Hasker

Object-Oriented Programming Details

• Ch. 7

Constructors, References

• Consider

          public class ItemCounter
          {
             private int tally = 0; // explicit initialization, though default is 0
             private String category;
          
             public void setCategory(String category)
             {
                this.category = category;
             }
             public String getCategory()
             {
                return category;
             }
             public void increment()
             {
                tally++;
             }
             public void decrement()
             {
                tally--;
             }
             public int count()
             {
                return tally;
             }
  
             //improvement: initialize during creation
             public ItemCounter(String category)
             {
                this.category = category;
             }
          }
  
          //....
  
          public static void main(String[] args)
          {
             ItemCounter a = new ItemCounter();
             a.setCategory("apples");
             a.increment();
             a.increment();
             a.increment();
             System.out.println("Value of a: " + a.count() + " " + a.getCategory());
          }
  

• [Draw picture]
• General rules for constructors:
  • Same name as class
  • No return type
  • Can execute any code, but rare to do much more than set private variables
• Suppose we have a second counter:

          public static void main(String[] args)
          {
             ItemCounter a = new ItemCounter("apples");
             ItemCounter b = new ItemCounter("bananas");
             a.increment();
             a.increment();
             b.increment();
             a.increment();
             System.out.println("Value of a: " + a.count() + " " + a.getCategory());
             System.out.println("Value of b: " + b.count() + " " + b.getCategory());
          }
  

• What happens if assign a and b to same thing?

          public static void main(String[] args)
          {
             ItemCounter a = new ItemCounter("apples");
             ItemCounter b = new ItemCounter("bananas");
             b = a;
             a.increment();
             a.increment();
             b.increment();
             a.increment();
             System.out.println("Value of a: " + a.count() + " " + a.getCategory());
             System.out.println("Value of b: " + b.count() + " " + b.getCategory());
          }
  

  • draw picture
  • What happens to the bananas?

Equality, overloading

• ==: check if two variables refer to the same object
• Checking if two strings are the same:

          String name = ...
          if ( name.equals("Johnny") )
             Systtem.out.println("Run!");
  

• Checking if two counters are the same:

             public boolean equals(ItemCounter otherCounter)
             {
                return this.category.equals(otherCounter.getCategory())
                    && this.tally == otherCounter.tally;
             }
  

  • Note could just compare categories; depends on what you need!
  • Note passing an object as a parameter
  • Other examples of passing objects:

               public void steal(ItemCounter otherCounter)
               {
                  this.tally += otherCounter.tally;
                  otherCounter.tally = 0;
               }
    

• Suppose we want to count by twos?

             public void increment(int amount)
             {
                tally += amount;
             }
  

  • Known as overloading
  • Must have distinct number of arguments or distinct types
  • Another example:

               public boolean equals(int number)
               {
                  return tally == number;
               }
    

  • Common: overloading constructors

Multiple classes

• Member data can be a class type:

          public class ProduceInventory
          {
             ItemCounter appleCount  = new ItemCounter("apples");
             ItemCounter pearCount   = new ItemCounter("pears");
             ItemCounter orangeCount = new ItemCounter("oranges");
             ItemCounter mysteryCount = new ItemCounter("unknown");
          
             public void receiveShipment(int apples, int pears,
                                         int oranges, int mysteries)
             {
                appleCount.increment(apples);
                pearCount.increment(pears);
                orangeCount.increment(oranges);
                mysteryCount.increment(mysteries);
             }
  
             public void printInventory()
             {
                // you write this!
             }
          }
  

• Guidelines for working with multiple classes
  • Make sure each class has a clear job
  • Keep methods short and simple

Review

• constructors - never create uninitialized data
• references
• checking equality
• passing references as parameters
• overloaded methods