Object-Oriented Programming with Java Lecture Notes

12 February 2009 • Methods

---

Outline

Finding Methods

• Here’s a method call:

  classInstance.moo("ha ha", 2)
  

• Where is this method? How do you find it?

  1. Find the class C associated with classInstance.

  2. Find the method named moo within C.

• Simple. Except, it fails. Why?

Constructors

• Method-name matching is ambiguous with repeated method names.

  • Which moo() will do?

• So? Make method names unique.

• Constructors gum up the works.

  • Constructor names are fixed and can’t be (conventionally) changed.

  • Only one constructor per class is untenable.

Method Signatures

• Given a method, the signature associated with the method is

  1. the method’s name, and

  2. the ordered list of parameter types.

• A method’s signature does not include the return type or the exceptions thrown.

Signature Examples

• The method

  void min(int a, int b)

  has signature

  min(int, int)

• The method

  public static void main(String args[])

  has signature

  main(String [])

Method Overloading

Ambiguous Overloads

• Type compatability can lead to overload ambiguity.

  class t
    void m(int i, double d) { ... }
    void m(double d, int i) { ... }
  
    void m() { m(1, 1) }
  

  • Type-ambiguous method calls are illegal.

• Remove ambiguity with specific argument types.

  void m() { m(1.0, 1) }
  

Varying Parameter Counts

• By default, methods have a fixed number of parameters.

  int max(int a, int b) { ... }
  

• On occasion, this can be inconvenient.

  int mx = max(max(a, b), max(c, d));
  

• Methods accepting a variable number of parameters can relieve this unbearable inconvience.

  int mx1 = max(a, b, c, d);
  int mx2 = max(e, f);
  

Varying Parameters and Overloading

• Overloading methods is one obvious way to provide a varying number of parameters.

  int max() { return Integer.MAX_VALUE; }
  int max(int a) { return a; }
  int max(int a, int b) { ... }
  int max(int a, int b, int c) { ... }
  // and so on
  

• But there’s always going to be an arbitrary maximum number of parameters.

  • It’s also tedious and mistake-prone coding.

Varying Parameters and Arrays

• An array parameter and anonymous array declarations can fake variable-length parameter lists.

  int max(int [] values) { ... }
  
  int mx = max(new int [] { a, b, c })
  

• This is effective, but not particulary convenient for the caller.

• The compiler could help make this easier for both the caller and the method.

Variable Parameters

• A method has variable parameters if the last parameter type is followed by “...”.

  int max(int... values) { ... }
  

  • This is effectively equivalent to declaring an array of values.

• The compiler wraps the apropriate actual values in an array.

  int mx = max(a, b, c);
  

Using Variable Parameters

• The variable parameters are an array of values inside the method.

  int max(int... values) { 
    int mx = Integer.MAX_VALUE;
    if (values.length > 0) {
      mx = values[0];
      for (int i: values)
        if (i > mx)
  	mx = i;
      }
    return mx;
    }