ITEC 120 2008spring ibarland, jdymacek

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

lect09a
public vs private

Review: we can write a method swapAge (which modifies fields), but we can't write a method swapDogs (which modifies local variables).

public vs. private

Consider the class Die from lab08b—printing: Pair O' Dice. It has a method void roll(), which chooses a random number in 1..6, and sets the current face to be that. In turn, the method setFace actually does that. There is a difference between these two methods though: one we intend for other people to use, and the other is for internal use, and it would be cheating for other people to call it!

Die myd6 = new Die();
myd6.roll();
myd6.getFace()
myd6.setFace(93); // Setter will make sure this is at least sane (if not fair)

myd6.face = 93;  // Cheating, from the Code Pad!

class Die {
  int NUM_SIDES = 6;

  private int face = NUM_SIDES;

  //...
  }

Similarly, the Date methods isInLeapYear() and isValid() are arguably for internal-use-only (users of the class might reasonable expect that they only ever see valid Date objects, and yet still inside the class we need to do internal checks for validity; in turn isInLeapYear() was just a helper function for isValid()).

We can make these assumptions clear: every field and method can be labeled with an adjective public or private:

• A public method (or field) can be called by any other class.

  In our example, Die's method roll should be public, because our whole purpose is to let people roll the die. getFace also needs to be public. What other methods should be public?

  In PizzaServer, work and tip would all be public. On the other hand, spend and addToBalance probably aren't public -- those are actions which the PizzaServer might choose to do itself, but can't be initiated by EmCees or Dogs.

  In particular, constructors are usually public!

• A private method (or field) can only be called from within that same class (the same file).

  That is, if PizzaServer's getBalance() is private, then that method can only be called by PizzaServers. A PizzaServer can call its own getBalance() (which it needs to do from inside addToBalance(), which might be public). This is perfectly reasonable.

  In addition, a PizzaServer can also call getBalance on any other PizzaServer that it happens knows about. (For example, the following fragment works just fine:

  public class PizzaServer { // comment omitted... private getSalary() { /* body omitted */ } // comment omitted... private hasHigherSalary( PizzaServer other ) { // It's legal for one PizzaServer to call another's private method. return (this.getSalary() > other.getSalary()); } }

  Even if getSalary is declared to be a private method, the method boolean hasHigherSalaryThan( PizzaServer other) can call both this.getSalary() and other.getSalary()). (So Java's “private” is not a perfect match for what we socially think of privacy.) ¹

• (optional) “package protected” is what happens when you don't specify public or private. It means that the method/field can be accessed by any other class in the same package -- that is, the same Project. So in what you turned in, every ClockDisplay. We discourage use of this modifier, at this point.
• BlueJ note: the Code Pad is like its own class: separate from the classes in the project, but part of the same package. So if you declare a field or method as private, it can't be called from the Code Pad.

What this means for us: From now on, every method and field should be declared either public or private.

• Virtually every field will be private (since everybody -- even ourselves -- should be using the getters/setters), …

• … while most of the methods will be public (since most methods we write are ones whose behavior we want others to use).

  Only methods which are helpers to the primary methods (like setFace) will be private.

  Rule of thumb: If you modify an object's internal implementation, you should not need to change any of the public signatures.
  (Only code which dealt with non-public methods should have to worry about the new implementation.)

  For example, if we modify Date to have only one field int daysSince1900, others will still call getMonth just the same as before. But if they'd been calling accessing the month field directly, suddenly this our internal modification would break their code, oops! The problem is that really, they should not have been calling getHours anyway. By making that getter private, we ensure that nobody else could be calling it.

• Named constants (which are actually a type of field) are sometimes public (like Math.PI and PizzaServer's MINIMUM_WAGE, and sometimes private.

home—info—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

©2008, Ian Barland, Radford University Last modified 2008.Mar.17 (Mon)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu