Abstract Classes

• A class may also be defined that contains some abstract methods and some fully defined methods
  • Both the class and the abstract methods need to be so labelled

  				public abstract class AbstractCollection {
  					...
  					public abstract void add();
  					public abstract void length();
  					...
  					boolean isEmpty() {return length() == 0;}
  				}
  				
  				public Set extends AbstractCollection {
  					public void add() {...}
  					public void length() {...}
  				}
  			

Immutable classs

• class whose instances can't have their state (instance variables) modified
• String is immutable

  				String s1 = "Hello", s2 = s1;
  				s1 = s1.replace('H', 'J');		// Returns a NEW, different String
  			

Wrapper classes

• One per primitive type
  • Integer, Short, Double, Boolean, ...
• Provides support for primitive types in contexts requiring objects
  • 'Wraps' the primitive type in an object
• Also provides a 'home' for primitive-type-related methods
• Immutable
• Usage became more convenient in 1.5

  				// Pre 1.5
  				Vector v = new Vector();
  				v.add(new Integer(5));
  				...
  				Integer num = new Integer(12);
  				int i = 	num.intValue();
  			

  				// Post 1.5
  				Vector v = new Vector();
  				v.add(5);
  				...
  				Integer num = 12;
  				int i = num;
  			

String Class

• Read about it in the text
• Text also discusses basic file I/O
• The toString Method
  • Allows a class to define a string representation of its state
  • Once defined, allows code such as

    Employee e;
    ...
    System.out.println(e);
    				

    and

    Employee e;
    ...
    String s = "The value of e is: " + e;
    				

  Packages

  • Java applications are organized into
    • Files - usually one class per file
      • Basic compilation unit
    • Packages - related classes and interfaces
      • Used to oganize large applications/systems
  • Declaring packages

    	package java.lang;
    	
    	class String {
    		...
    	}
    

  • Referring to class in a package
    • Use fully qualified name

      	class MyApp {
      		...
      		java.util.Vector v = new java.util.Vector();	// fully qualified name
      		..
      	}
      

    • Import either the individual class ... or entire package

      	import java.util.Vector;
      	
      	class MyApp {
      		...
      		Vector v = new Vector();
      	}
      

    • ... or the entire package

      	import java.util.*;
      	
      	class MyApp {
      		...
      		Vector v = new Vector();
      	}
      

  • Package java.lang
    • Fundamental and basic classes:
      • String
      • Primitive wrappers
      • System-wide information class (System)
    • Need not be imported explicitly
  • Packages partition the Java namespace

    			java.util.Date = new java.util.Date(); // Date as used by the Java runtime
    			java.sql.Date = new java.sql.Date(); // Date as required for database work
    		

  • Packages form a hierarchy...
    • ... whose structure is reflected by the directory structure of the class path
    • Don't need to know (yet) -- interested? -- Section 4.5.3/4

  Exceptions

  • Unexpected conditions
  • Thrown exception
  • Catching (i.e., handling or taking care of) the exception
  • Originate from
    • JVM (divide by zero, out of memory)
    • Program (via .throw statement
  • Exception Hierarchy
    • Exceptions are represented via exception classes
    • Such classes form a hierarchy
    • At the top is Throwable (i.e., something that can be thrown
    • Two subclasses
      • Error - Serious and fatal problems -- usually not caught
        • OutOfMemoryError
      • Exception
        • user-defined (and Java library-defined) exceptions go below here
          • IOException
        • Also has subclass RuntimeException
          • Parent of all JVM-related exceptions
            • IndexOutOfBoundException
            • NullPointerException
  • Throwing Exceptions
    • Use the throw statement:

      		class Stack {
      			Object pop() throws StackException {
      				...
      				if (isEmpty()) throw new StackException("pop attempted on empty stack");
      				...
      			}
      			...
      		}
      

    • The object being trhown MUST be a subclass (descendant) of Throwable
    • As shown above, exceptions that may be thrown MUST be declared in the method header
  • Catching (Handling) Exceptions
    • Use try/catch blocks
    • Possibly offending code place in tryblock

      		class MyApp {
      			...
      			Stack s = new Stack();
      			...
      			try {
      				...
      				System.err.println(s.pop());
      				...
      			} catch (StackException e) {
      				System.err.println("Ooops! + e);		// Handle the exception
      				System.exit(1);
      			}