More on Methods
(Example code and figures from Computing Concepts with Java Essentials, 3rd edition, by Cay Horstmann.
Visit www.wiley.com/college/horstmann for information on the current edition of this excellent text.)

• Coupling

  • A class depends on another if it calls one of its methods
  • consider this refactoring of the Purse class
    • Purse.java
    • Coin.java
  • Purse depends on Coin because it calls getValue( ) on coins
  • Coin does not depend on Purse
    
  • High Coupling = many class dependencies
  • Minimize coupling to minimize the impact of interface changes

• Accessor method: does not change the state of the implicit parameter (e.g. getBalance)
• Mutator method: changes the state of the implicit parameter (e.g. deposit )
• Rule of thumb: Mutator should return void
  
• Immutable class: all methods are accessors (e.g. String)

• Side Effect: any observable change outside the implicit parameter
• Example: modify an explicit parameter

  public void transfer(double amount, BankAccount other) { balance = balance - amount; other.balance = other.balance + amount; }

  
  
• Example: printing in method

  public void deposit(double amount) {       if (amount < 0)       System.out.println("Bad value");    . . . }

  
  
  • Undesirable: couples with System, PrintStream

• Example:

  void transfer(double amount, double otherBalance) { balance = balance - amount; otherBalance = otherBalance + amount; }

  
  
• a scenario that will not work:

  double savingsBalance = 1000; harrysChecking.transfer(500, savingsBalance);

• Publish preconditions so the caller won't call methods with bad parameters

• /**
     Deposits money into this account.
     @param amount the amount of money to deposit
     (Precondition: amount >= 0)
  */
  

• Typical use:
• To restrict the parameters of a method
• To require that a method is only called when the object is in an appropriate state
  
  
• What if the method is called when precondition not fulfilled?
  • method could throw an exception
  • method could assume precondition is met - error is callers fault

• Condition that's true after a method has completed.

• /**
     Deposits money into this account.
     (Postcondition: getBalance() >= 0)
     @param amount the amount of money to deposit
     (Precondition: amount >= 0)
  */

• Don't document trivial postconditions that repeat the @return clause
• Contract: If caller fulfills precondition, method must fulfill postcondition

• Every method must be in a class
• Some methods do not require an implicit parameter
• Example:

  class Numeric {  public static boolean approxEqual(double x, double y) {  . . . } }

  
  
  
• Call a static method with the class name instead of object:

  if (Numeric.approxEqual(a, b)) . . .

  
  
• Note that main( ) is static--there aren't any objects yet
• now that you know about static methods...
  • main( ) is a static method
  • any class can have a main( )
  • you can have multiple classes in a file
  • there can only be one public class in a file
  • the public class is where main( ) must be
  • when you run the launcher
    
    java ClassName
    
    the launcher looks in ClassName.class for main( ) and invokes it
    
    
• too many static methods are a sign of procedural, rather than object-oriented, thinking

• Scope of variable: region of program where you can refer to the variable by its name
• Local variable scope: from definition to end of block
• Class scope: all methods of the class
• Must qualify public members outside scope, e.g. Math.sqrt
• Overlapping scope: local scope wins over class scope

  public class Coin { public void draw(Graphics2D g2) { String name = "SansSerif"; // local scope g2.setFont(new Font(name, . . .)); // local name g2.drawString(this.name, . . .); // field name } private String name; // class scope . . . }