Announcements

• Quiz this Thursday. Basically, I will give you a set of classes and their methods and then a set of method invocations (calls) to these classes and ask you to identify which calls are valid or not.
• Homework due this Friday at midnight.
• Read chapter 5 of the book. This chapter discusses designing and using classes. It should not be hard to follow and gives some tips in developing classes.

Public vs. Private

Here it comes finally. Until now, everything has been public this and public that. What does that really mean?

• public methods and variables of a class are accessible by all other classes.
• private methods and variables of a class are only accessible inside that class definition. In particular, methods for that class can use the private variables freely.
• Rule of thumb: In general it is good programming practice to make all variables private and most methods public.
• Keep as much to yourself (private) as possible. The less the outside classes need to know about the inner workings the better. Easier for them (less to know), easier for you (to change the inner workings).

public class WeaponList {
  private int tally;
  private String[] weaponName;

  public WeaponList(int maxSize) {
    weaponName = new String[maxSize];
    tally = 0;
  }

  public void addWeapon(String weaponToAdd) {
    if (tally < weaponName.length) {
      // Still space left to add more names
      weaponName[tally] = weaponToAdd;
      tally++;
    } else {
      // No space let, we'll do nothing (for now)
    }
  }

  public void printWeaponList() {
    int i;
    while (i < tally) {
      System.out.println("Weapon " + i + 
        ": " + weaponName[i]);
      i++;
    }
  }

  public String getWeaponAt(int i) {
    if ((i < 0) || (i >= tally)) {
      // Out of range
      return null;
    } else {
      return weaponName[i];
    }
  }

  public int getTally() {
    return tally;
  }
}

   WeaponList wList = 
     new WeaponList(100);	  // Valid, constructor is PUBLIC
   wList.addWeapon("Sling");	  // Valid, method is PUBLIC
   wList.addWeapon("Mace");	  // Valid, method is PUBLIC
   wList.printWeaponList();	  // Valid...
   wList.tally = 10;		  // Invalid... variable is PRIVATE
				  // why is this very IMPORTANT?
   wList.weaponName[20] = "Axe";  // Invalid... again why is this IMPORTANT?

Of course, we could expect the outside class to increment the tally as well. But this defeats the purpose of writing a class to handle the task. Second, if the outside class had access to the tally variable, they could mistakenly change that value. For example, setting it to 10 when there are only 5 weapons, or 5 when there are in fact 10 on the list. In both cases, printing out the list (or whatever other methods there are for the class) would not work.

But, what if the outside class really wants to access a value or change one. And you also want the outside world to have some (limited) access to these variables. Sometimes this is necessary. You solve this by writing accessor methods.

Accessor Methods

In the above example, getTally() and getWeaponAt(int index) are both accessor methods to tally and the weaponName array. You may also have methods to set variables. In general, the naming convention is as follows:

• setVar(int value)... would set the value of variable var
• int getVar()... would return the value of variable var

   public int getTally() {
     return tally;
   }

   public void setTally(int newTally) {
     tally = newTally;
   }

• It could check if the value is outside of acceptable ranges
• It could check if the new value violates other constraints.
• It could update other structures that also rely on the value of this variable.
• It could update other structures keeping track of the previous value... maybe to "undo" the change if necessary?
• You have the freedom to change what is actually stored for that class. For exampe, the list could be a Vector instead of an array.
• There are many reasons. The main one is that typically variables should be private and only used by that class. So accessors are needed if the variable can be changed.

Private Methods

This is a harder rule to describe. If the method should be accessible outside, then make it public, if not, make it private. So, in practice, try to follow these rules and you'll be fine:

• Variables are always private
• Methods are typically public

Interfaces

public interface Locatable {
  public int getLocationX();
  public int getLocationY();
}

public class Human implements Locatable {
  Stats theStats;
  int positionX;
  int positionY;
  
  // ...
  // Insert lots of methods and other variables here
  // ...
  // ...

  public int getLocationX() {
    return positionX;
  }

  public int getLocationY() {
    return positionY;
  }
}

In fact, somewhere inside the definition we actually implement these methods, getLocationX() and getLocationY(). In this case, we ignored all the other methods, but they would be there as well. Now, we can say that Human is Locatable.

Note: when it comes to naming interfaces, it is customary to use adjective names ending in "able"... e.g., Enumerable, Countable, Throwable, etc.

Using interfaces it is possible for another unrelated class to also implement the same interface. For example,

public class Item implements Locatable {
  String itemName;
  int coordinateX;
  int coordinateY;

  // ...
  // Insert lots of methods and other variables here
  // ...
  // ...

  public int getLocationX() {
    return coordinateX;
  }

  public int getLocationY() {
    return coordinateY;
  }
}

• A class may implement more than one interface. An Item may be Locatable and, say, Tossable (it can be tossed - in a given direction for example).
• A variable may be of an interface type, but it cannot be created using a constructor. Interfaces are not classes.

   Human personOne = new Human("Miss Scarlet");
   Human personTwo = new Human("Colonel Mustard");
   Item itemOne = new Item("Candlestick");
   Item itemTwo = new Item("Wrench");

   int x;
   int y;

   // These methods all work
   x = personOne.getLocationX();
   y = personOne.getLocationY();
   x = itemOne.getLocationX();
   y = itemOne.getLocationY();
   
   Locatable objectToLocate;
   objectToLocate = personTwo;
   x = objectToLocate.getLocationX();
   y = objectToLocate.getLocationY();

   objectToLocate = itemTwo;
   x = objectToLocate.getLocationX();
   y = objectToLocate.getLocationY();

  // The following does NOT work
  objectToLocate = new Locatable();
  // Locatable objects cannot be created.