460 likes | 470 Views
Handling Errors. What happens if someone attempts to push an item into a stack that is full? Many times it is the client that knows what the appropriate thing to do is in the case of an error.
E N D
Handling Errors • What happens if someone attempts to push an item into a stack that is full? • Many times it is the client that knows what the appropriate thing to do is in the case of an error. • Exceptions provide a method of informing a client that an error has occurred and provides a mechanism for handling the error cleanly. • Many languages provide support for exceptions. Intermediate Java
Java Exception Handling • An exception occurs, thrown, when something goes wrong while a program is running. • If an exception is not handled, caught, the program will terminate. • When an exception is thrown, the exception is passed to the caller of the method. • The caller can then handle the exception or allow it to propagate back up the call chain. Intermediate Java
Java Exceptions • An exception object stores information about the case of an exception and can be passed as a value to an exception handler. • All exception classes must be a direct or indirect subclass of class Throwable. • An exception class, despite its name, is an ordinary class defined in the normal way. Intermediate Java
Exception Class Hierarchy Object serious errors that are typically non-recoverable these exceptions must be explicitly dealt with. Throwable Exception Error other classes ... other classes ... RunTimeException other classes ... Intermediate Java
What Exceptions are Thrown? • How do you figure out what exception will be thrown that you must handle? • read the documentation for the class you are using • read the documentation about the various exception classes • I often simply use the methods I want and let the compiler tell me when I missed something!! • Example: FileReader Intermediate Java
Try, Catch, and Finally • A try block is wrapped around code that may cause an exception. • catch blocks following the try block can contain code to deal with the exception. • A finally block contains code that will be executed whether or not an exception occurs. • In most cases try and catch blocks suffice Intermediate Java
Syntax try { statementSequence } catch ( parameter ) { statementSequence } finally { statementSequence } Intermediate Java
CmdLine public class CmdLine { public static void main( String args[] ) { for ( int i=0; i<args.length; i++ ) { int val; try { val = Integer.parseInt( args[i] ); System.out.println( val ); } catch ( NumberFormatException e ) { System.out.println( "??" ); } } } } Intermediate Java
Streams • Java provides many stream classes that let you work with data in the forms that you usually use rather than at the low, byte level. • These are implemented in the abstract classes InputStream and Outputstream. • The methods in these classes provide the ability to do simple, byte oriented operations. Intermediate Java
Streams and Files • Data files are handled using two abstractions: • the basic file abstraction is provided by the library class File. This encapsulates all the details of what a file is and how it is named. • The stream abstraction provides a way of reading and writing data to and from a file. • Reader streams deal with input and are subclasses of Reader, while writer streams perform output and are subclasses of Writer. Intermediate Java
BufferedReader • A BufferedReader reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines. • The buffer size may be specified, or the default size may be used. • A BufferedReader is usually wrapped around any Reader whose read() operations may be costly. Intermediate Java
FileEcho import java.io.*; public class FileEcho { public static void main( String args[] ) { if ( args.length>0 ) { BufferedReader in = null; try { in = new BufferedReader( new FileReader( args[0] ) ); while ( in.ready() ) { char ch = (char)in.read(); System.out.print( ch ); } } catch ( FileNotFoundException e ) { System.out.println( "File not found" ); } catch( IOException e ) { System.out.println( "Read error" ); System.exit(1); }}}} Intermediate Java
InputStreamReader • An InputStreamReader is a bridge from byte streams to character streams: it reads bytes and translates them into characters according to a specified character encoding. • Each invocation of one of an InputStreamReader's read() methods may cause one or more bytes to be read from the underlying byte-input stream. Intermediate Java
PrintWriter • A PrintWriter prints formatted representations of objects to a text-output stream. • Flushing does not occur until the flush() method is invoked. It is possible to enable automatic flushing, which causes a flush to take place after any println() method is invoked. The output of a newline character does not cause a flush. • Methods in this class never throw I/O exceptions. Intermediate Java
Building a Simple Expression Evaluator • Consider building an expression evaluator for the following: • identifiernumber; • identifier ; • The code to do this follows. It uses the following classes: • InputStreamReader • StreamTokenizer • HashTable Intermediate Java
ExprEval import java.io.*; import java.util.*; public class ExprEval { public static void main( String args[] ) { StreamTokenizer lex = new StreamTokenizer( new InputStreamReader( System.in ) ); final int WANT_WORD = 0; final int WANT_NUM = 1; final int WANT_SEMI = 2; int curState = WANT_WORD; String curId = null; Hashtable symTbl = new Hashtable(); lex.ordinaryChar( '-' ); // '-' is treated normally lex.lowerCaseMode( true ); // make case insensitive Intermediate Java
ExprEval try { while ( lex.nextToken() != StreamTokenizer.TT_EOF ) { switch ( lex.ttype ) { case lex.TT_WORD: if ( curState == WANT_WORD ) { curId = lex.sval; curState = WANT_NUM; } else curState = WANT_SEMI; break; case lex.TT_NUMBER: if ( curState == WANT_NUM ) symTbl.put( curId, new Integer( (int)lex.nval) ); curState = WANT_SEMI; break; case ';': if ( curState == WANT_NUM ) System.out.println( symTbl.get( curId ) ); curState = WANT_WORD; break; default: curState = WANT_SEMI; }}} catch( Exception e ) { System.out.println( "I/O Error" ); }}} Intermediate Java
Classes • The class declaration introduces a new class. • A class describes the structure and behavior of its instance objects in terms of instance variables and methods. • Like variables, classes may be declared at different scopes. The scope of a class directly affects certain properties of the class. • We will start with top-level classes. Intermediate Java
Class Syntax classmodifier identifier{ constructorDeclarations methodDeclarations staticMemberDeclarations instanceVariableDeclarations staticVariableDeclarations } Intermediate Java
Class Modifiers • Top-level classes can optionally be declared as: • public • a public class is globally accessible. A single source file can have only one public class or interface. • abstract • an abstract class can have no instance objects. • final • a final class cannot be subclasses. • A class that does not have a modifier, can only be accessed by classes in the same package. Intermediate Java
Public, Private and Protected • Any declaration at class scope can be proceeded by one of the following: • public • a declaration is accessible by any class • protected • a declaration is accessible to any subclass, or to any class in the same package. • private • a declaration is only accessible within the class it is declared in. Intermediate Java
Instance Variables • Instance variables form the state of an instance object. • An instance variable can be declared as final, meaning that it is a constant. class Class1 { public String hello = “Hello”; public final String world = “World”; protected int count = 0; private float length = 2.345f; } Intermediate Java
Methods • Class methods define the behavior of the object. They are where the control statements go. • A method name is an identifier. Following the method name is a parenthesized formal parameter list, which may be empty (the parenthesis are still required). • Each parameter consists of a type name followed by a parameter variable name. Intermediate Java
Constructors • A constructor is a method that can be used to control initialization. • A constructor is declared like a method: • constructors have no return type • the constructor name is the same as the class • A constructor with an empty parameter list is known as a default constructor. • If a class does not define a constructor, the compiler will automatically insert one. Intermediate Java
IntStack import java.util.*; public class IntStack { private Vector data; public IntStack() { data = new Vector(); }; public void push( int newValue ) { data.addElement( new Integer( newValue ) ); } public int top() { return ((Integer)data.lastElement()).intValue(); } public void pop() { data.removeElementAt( data.size()-1 ); } public boolean isEmpty() { return data.isEmpty(); } public boolean isFull() { return false; } } Intermediate Java
this • this is a final variable that holds reference to the object in which it exists (i.e. this points to the current object) • The type of this is the reference type of the object • It is sometimes necessary to pass a reference to the current object as a parameter to another method. Intermediate Java
StackNode public class StackNode { private Object data; private StackNode next, prev; public StackNode( Object o ) { this( o, null ); } public StackNode( Object o, StackNode n ) { data = o; next = n; } public StackNode getNext() { return next; } public Object getData() { return data; } } Intermediate Java
LinkedStack public class LinkedStack { private StackNode tos = null; public boolean isEmpty() { return tos == null; } public boolean isFull() { return false; } public void push( Object o ) { tos = new StackNode( o, tos ); } public void pop() { tos = tos.getNext(); } public Object top() { return tos.getData(); } } Intermediate Java
TestStack public class testStack { public static void main( String args[] ) { int i; LinkedStack stack=new LinkedStack(); for (i=0; i<10; i++) stack.push( new Integer( i ) ); while (!stack.isEmpty()) { System.out.println( stack.top() ); stack.pop(); } } } Intermediate Java
Static or Class Variables • A static variable belongs to a class and is not part of the state of individual instance objects. • Only one copy of each static variable exists. • Class variables have several uses: • they are global to the class and can be shared by all objects of the class. • class constants (using final) • Static variables must be explicitly initialized (because no constructor can do it). Intermediate Java
Elevator public class Elevator { private static int nextId = 0; public final static int UP = 0; public final static int DOWN = 1; private int direction = UP; private int myId; public Elevator() { myId = nextId++; } public int getId() { return myId; } public int getDirection() { return direction; } public void setDirection( int dir ) { switch ( dir ) { case UP: case DOWN: direction = dir; }}} Intermediate Java
TestElevator public class TestElevator { public static void main( String args[] ) { Elevator a = new Elevator(); Elevator b = new Elevator(); Elevator c = new Elevator(); a.setDirection( a.DOWN ); b.setDirection( Elevator.DOWN ); System.out.println( "Elevator A: Id=" + a.getId() + ", Dir=" + a.getDirection() ); System.out.println( "Elevator B: Id=" + b.getId() + ", Dir=" + b.getDirection() ); System.out.println( "Elevator C: Id=" + c.getId() + ", Dir=" + c.getDirection() ); } } Intermediate Java
Static Methods • Static methods generally follow the same rules as methods: • a static method belongs to a class not its instance objects. • a static method can be called both directly and for an object of the same class • a static method cannot access any instance variables or methods (since it does not belong to an instance object) • this cannot be used Intermediate Java
Static Methods • There is one special use of static methods in the form of static main. • When a class defines a public static method main, it provides a starting point for execution of a program using that class. • Any class can have a static main method. • Static methods are generally used to provide utility or helper methods. For examples see java.lang.Math. Intermediate Java
Packages • A package allows a collection of classes to be grouped together into a single named unit which also acts as a scope. • A package is declared using a package statement (must be the first statement in a source file) • packagepackageName; • Packages are imported using an import statement • importpackageName.className; • importpackageName.* ; Intermediate Java
Packages • It is also possible to specify the name of a zip file in the CLASSPATH as well as directories containing class files. • Any class from another package must be imported. for all Java classes this must be done explicitly with the exception of java.lang. • If a class is not defined as part of a package, then it is considered to be part of the unnamed default package. Intermediate Java
Mapping Packages to Files • Package names map to directory names. Each directory contains all the .class files for a given package • mcc.examples.stack would map to mcc\examples\stack • the relative pathname is then appended to each entry in the CLASSPATH variable to create a full pathname • Check this out: • edu.rit.cs.ptt.classes.mcc.examples Intermediate Java
Inner Classes • Inner, or Nested, classes are standard classes declared within the scope of a standard top-level class. • There are different kinds of inner class • nested top-level class • member class • local class • anonymous class Intermediate Java
Nested Top-Level Classes class outer { private static class NestedTopLevel { normal class stuff } normal class stuff } • Nested top-level classes are declared as static within a standard top-level class (sort of like a standard class member). • They follow the same rules as standard classes • private static classes cannot be seen the enclosing class • public static allows the class to be seen outside Intermediate Java
LinkedStack2 public class LinkedStack2 { private StackNode tos = null; private static class StackNode { private Object data; private StackNode next, prev; public StackNode( Object o ) { this( o, null ); } public StackNode( Object o, StackNode n ) { data = o; next = n; } public StackNode getNext() { return next; } public Object getData() { return data; } } public boolean isEmpty() { return tos == null; } public boolean isFull() { return false; } public void push( Object o ) { tos = new StackNode( o, tos ); } public void pop() { tos = tos.getNext(); } public Object top() { return tos.getData(); } } Intermediate Java
Member Classes • A member class is a nested top-level class that is not declared static. • This means the member class has a this reference which refers to the enclosing class object. • Member classes cannot declare static variables, methods or nested top-level classes. • Member objects are used to create data structures that need to know about the object they are contained in. Intermediate Java
Class5 class Class5 { private class Member { public void test() { i = i + 10; System.out.println( i ); System.out.println( s ); } } public void test() { Member n = new Member(); n.test(); } private int i = 10; private String “Hello”; } Intermediate Java
this Revisited • To support member classes several extra kinds of expressions are provided • x = this.y is valid only if y is an instance variable declared by the member class, not if y belongs to the enclosing class. • x = TestClass.this.y allows access to y that belongs to the enclosing class. • Inner classes can be nested to any depth and the this mechanism can be used with nesting. Intermediate Java
new Revisited • Member class objects can only be created if they have access to an enclosing class object. • This happens by default if the member class object is created by an instance method belonging to its enclosing class. • Otherwise it is possible to specify an enclosing class object using the new operator as follows • B b = a.new B(); Intermediate Java
Local Classes • A local class is a class declared within the scope of a compound statement, like a local variable. • Local classes follow the member class syntax but cannot include static variables, methods or classes. In additional they cannot be declared public, protected, private or static. • A local class has the ability to access final variables and parameters in the enclosing scope. • Handy in the AWT. Intermediate Java
Anonymous Classes • An anonymous class is a local class that does not have a name. • An anonymous class allows an object to be created using an expression that combines object creation with the declaration of the class. • This avoids naming a class, at the cost of only ever being able to create one instance of that anonymous class. • Again this is handy in the AWT. Intermediate Java