Java Lecture 2

Documentation & Naming Convention

• in html format
• link to local copy on from course web page:

  http://www.cs.mun.ca/~michael/java/jdk1.1.5-docs/api/packages.html

• generated from Java library source code using special comments and the javadoc program

• ClassName: classes are capitalized, embedded words capitalized
• methodName, variableName: methods and variables start with lowercase
• CONSTANT_NAME: constants are uppercase, _ between words

How Javac Finds Classes

Abc.java                 Xyz.java
class Abc {              class Xyz {
  public Abc() {           public Xyz(int i) {
    // ...                   // ...
    aVar = new Xyz(3);     }
  }                        // ...
  // ...                 }
  private Xyz aVar;
}

1. looks inside Abc.java
2. looks in . for Xyz.java or Xyz.class (compiles Xyz.java if newer than Xyz.class)
3. looks in system directories for Xyz.class

1. search each package for Xyz (including the unnamed package)
2. for each package, looks for the file packageName/ClassName.[class|java] (dots in packageName are changed to /)
3. CLASSPATH environment variable lists directories to search (by default, CLASSPATH contains . and system directories)

Notes on Exceptions

• used as a way of handling errors
• one tries to execute some statements, and catches any exceptions generated
• the called method may throw an exception
• `exceptions' are instances of some class (derived from the Throwable class)
• any exceptions thrown (or not caught) by a method must be explicitly declared:

    int myMethod(String filename)
  	  throws IOException
    {
        // ...
    }
  

class Sum {
   public static void main(String av[]) {
      int i;
      int total = 0;

      for (i = 0; i < av.length; i++) {
          try { total += Integer.parseInt(av[i]);
          } catch (NumberFormatException e) {
              System.out.println(av[i] + " is not an integer");
              return;
          }
      }
      System.out.println("Sum of arguments: " + total);
   }
}

Classes for Scalar Types

Numbers:
    Float, Double, Integer, Byte, Short, Long

• useful when you need an Object (not a scalar)
• useful for converting numbers to/from strings
• contain MAX/MIN constants

Character:

• useful for lexical analysis (is this a leter?)
• useful for converting characters to numbers (what number is '1'?)

Vector class

• A `container class' (growing array)
• Can only contain Objects (not ints, doubles, etc.)
• Extracted objects must be cast to the appropriate type
• Common methods:
  • int size(): how many elements?
  • Object elementAt(int i): retrieve an elements
  • void addElement(Object o): add to end
  • void insertElementAt(Object o, int i): shifts i+1.. up
  • void setElementAt(Object o, int i): replaces i
  • void removeElementAt(int i): shifts i+1.. down
  • Enumeration elements(): returns an `iterator'

import java.util.Vector;

class VectorTest {
  public static void main(String args[]) {
      Vector v = new Vector();

      v.addElement(new MyPoint(1, 2));
      v.addElement(new MyPoint(2, 4));
      v.addElement(new MyPoint(-2, 3));

      for (int i = 0; i < v.size(); i++) {
	      MyPoint p = (MyPoint) v.elementAt(i);
	      p.moveBy(4, 4);
      }

      for (int i = 0; i < v.size(); i++)
	      System.out.println(v.elementAt(i));
  }
}

Intro to Interfaces

[ public ] [ abstract ]
interface name [ extends type [,...]] {
    methods...
    constants...
}

• Needed because classes can have only one super class
• Used to define a completely abstract class containing
  • Methods (implicitly public, abstract)
  • Constants (implicitly public, static, final)
  Can't contain static methods, non-final variables
• Interfaces define types (e.g., can be used as type of a variable)
• Example - the Enumeration interface in java.util:

  public
  interface Enumeration {
      public boolean hasMoreElements();
      public Object nextElement();
  }

• Classes implement interfaces:

  public
  class VectorEnum
      implements Enumeration
  {
      public boolean hasMoreElements() {
  	// ...
      }
      // ...
  }

import java.util.Enumeration;
import java.util.NoSuchElementException;

class ArrayEnumeration implements Enumeration {
    public ArrayEnumeration(Object a[]) {
        array = a;
    }
    public boolean hasMoreElements() {
        return pos < array.length;
    }
    public Object nextElement() 
        throws NoSuchElementException
    {
        if (pos >= array.length)
            throw new NoSuchElementException();
        return array[pos++];
    }
    private Object array[];
    private int pos = 0;
}

import java.util.*;

class EnumTest {
    public static void main(String args[]) {
        System.out.println("Arguments:");
        printEnum(new ArrayEnumeration(args));

        System.out.println("Integers:");
        Integer iArray[] = new Integer[10];
        for (int i = 0; i < iArray.length; i++)
            iArray[i] = new Integer(i * 10);
        printEnum(new ArrayEnumeration(iArray));

        System.out.println("Doubles:");
        Vector v = new Vector();
        for (int i = 1; i < 20; i++)
            v.addElement(new Double(1.0 / i));
        printEnum(v.elements());
    }
    private static void printEnum(Enumeration e)
    {
        int i = 0;
        while (e.hasMoreElements()) {
            Object o = e.nextElement();
            System.out.println("\t" + i + ": " + o);
            i++;
        }
    }
}