Java Lecture 4

import java.io.*;

class LowerCaseReader extends FilterReader {
    public LowerCaseReader(Reader in) {
        super(in);
    }

    public int read()
        throws IOException
    {
        int c = in.read();
        if (c >= 0)
            c = Character.toLowerCase((char) c);
        return c;
    }

    public int read(char buf[], int off, int len)
        throws IOException
    {
        int nRead = in.read(buf, off, len);
        if (nRead > 0)
            for (int i = off; i < off + nRead; i++)
                buf[i] = Character.toLowerCase(buf[i]);
        return nRead;
    }
}

Packages

• used to organize classes and avoid name conflicts
• the package statement:
        package mun.lib;
  says all following classes are in the package called mun.lib
• the default package is the unnamed one

• package sources live in a directory named after the package: dots in package name become slashes, e.g., mun/lib/Complex.java
• packages must be compiled from `above' the package directory

• only public classes and interfaces are accessible from outside the class
• non-public, non-private, non-protected class members are fully accessible within the packages, and not accessible outside the package.
• access classes in a package by giving the full package & class name

     mun.lib.Complex a
  	= new mun.lib.Complex(1,2);
  

• or by importing the package

  import mun.lib.*;
  
     Complex a = new Complex(1,2);
  

Access Control

Two levels of control on classes/interfaces:

	Package	Outside Package
public	yes	yes
default	yes	no

Notes on Arrays

• java has only single dimension arrays:

  int[] a; // declares a, no memory allocated
  int b[]; // same as int [] b;
  a = new int[10]; // now we have some int's
  

• can have an array of arrays

  char[][] screen = new char[24][80];
  

• arrays can be initialized:

  int[] a = { 1, -2, 3, 10, 2, 0 };
  

  this implicitly calls new int[6] and initializes the elements of a.
• arrays have a length field (not a method)

  int [][] aa = new int[3][5];
  System.out.println(aa.length);
  System.out.println(aa[0].length);
  

  prints 3 and 5.
• using an invalid index causes an ArrayIndexOutOfBoundsException exception

Final Keyword

When applied to:

instance variable, class variable, parameter, local variable

variable is never re-assigned

• final Object variables always refer to the same object; contents of object can be changed
• different from C's const, which (when used in the same location) means the contents of the object won't be changed.
• used to create symbolic constants
• used to allow nested classes access to parameters and local variables

instance or class method

derived classes can't override the method

class

no derived classes can be created

Inner (Nested) Classes

1. static inner class:
   declared inside a class using static
   • behaves like a nested structure or record in C or Modula-2
   • can be public, private, etc.
   • accessed from outside the class as
     enclosingClass.nestedClass
2. inner (instance) class:
   delcared in a class (no static)
   
   • like above but...
   • tied to a particular instance of the `outer' class
   • can access the outer instance's variables, methods
   • which instance it is tied to decided when new called (usually the current this)
   • can't have static members
3. local inner classes:
   declared in a method
   • like above but ...
   • can't be static, public, private, etc.
   • can access final parameters and final local variables
4. anonymous (local) inner classes:
   delcared in a new expression
   • like above but ...
   • has no name
   • has no constructors

class Expr {
  public static Expr create(String exprStr) {
      ExprTokenizer t = new ExprTokenizer(exprStr);

      Expr expr = parseOr(t);
      if (expr == null)
          return null;

      if (!t.currentMatches(ExprTokenizer.T_END))
          return null;

      return expr;
  }
  // ... rest of Expr

  static private class ExprTokenizer {
      public static final int T_END = 0;
      // ...

      public ExprTokenizer(String str) {
          // ...
      }

      public boolean currentMatches(int tok) {
          if (type == tok) {
              getNext();
              return true;
          }
          return false;
      }
      // ...
  }
}

class Vector {
  // ...
  // Inner class
  class VectorEnum implements Enumeration {
      private int pos = 0;
      public boolean hasMoreElements() {
          return pos < size();
      }
      public Object nextElement()
          throws NoSuchElementException
      {
          if (pos >= size())
            throw new NoSuchElementException();
          return elementAt(pos++);
      }
  }

  public Enumeration elements() {
      // Creates VectorEnum tied to `this'
      return new VectorEnum();
  }

  // ...
}

class Vector {
  // ...

  public Enumeration elements() {
      // Local inner class
      class VectorEnum implements Enumeration {
          private int pos = 0;
          public boolean hasMoreElements() {
              return pos < size();
          }
          public Object nextElement()
              throws NoSuchElementException
          {
              if (pos >= size())
                throw new NoSuchElementException();
              return elementAt(pos++);
          }
      }
      // Creates VectorEnum tied to `this'
      return new VectorEnum();
  }

  // ...
}

class Vector {
  // ...

  public Enumeration elements() {
      // anonymous inner class
      return new Enumeration() {
          // class is expected to implement
          // the Enumeration interface
          private int pos = 0;
          public boolean hasMoreElements() {
              return pos < size();
          }
          public Object nextElement()
              throws NoSuchElementException
          {
              if (pos >= size())
                throw new NoSuchElementException();
              return elementAt(pos++);
          }
      }
  }

  // ...
}

Javadoc Comments

• special comment introduced with /**
• used in certain places
  • before classes
  • before class members (i.e., instance variables, methods, class methods, etc)
• comments have embedded tags:
  • @see something : creates link to something (class, member function, etc)
  • @param paramName : documents a method parameter
  • @return : documents the method return value
  • @exception exceptionName : documents an exception thrown by the method
  • also @deprecated exceptionName, @author, @version, @since
• comments often also have html tags
• comments processed by javadoc program, which generates html
• javadoc normally generates documents for public classes, public/protected class members
  
• -private option generates docs for everything:

      javadoc -private *.java

/* Copyright (c) 1995, 1996 Sun Microsystems,
 * Inc. All Rights Reserved.
 * ...
 */

package java.util;

/**
 * The <code>Stack</code> class represents a
 * last-in-first-out (LIFO) stack of objects. 
 *
 * @author  Jonathan Payne
 * @version 1.16, 01/28/97
 * @since   JDK1.0
 */
public
class Stack extends Vector {
  /**
   * Pushes an item onto the top of this stack. 
   *
   * @param   item   the item to be pushed onto
   *          this stack.
   * @return  the <code>item</code> argument.
   * @since   JDK1.0
   */
  public Object push(Object item) {
      // ...
  }

  /**
   * Removes the object at the top of this
   * stack and returns that object as the value
   * of this function. 
   *
   * @return     The object at the top of this
   *             stack.
   * @exception  EmptyStackException  if this
   *             stack is empty.
   * @since      JDK1.0
   */
  public synchronized Object pop() {
      // ...
  }
  // ...

  /**
   * Returns where an object is on this stack. 
   *
   * @param   o   the desired object.
   * @return  the distance from the top of the
   *          stack where the object is]
   *          located; the return value
   *          <code>-1</code> indicates that
   *          the object is not on the stack.
   * @since   JDK1.0
   */
  public synchronized int search(Object o) {
      // ...
  }
}