1

Nested Classes

O

2

Nested Classes

• Possible to declare a class within another class; called nested classes

• Nested class should have some specific association with the enclosing class, otherwise not sensible to do so

• Can be static or non-static • A non-static nested class is called an inner class public class Outside { //top-level class

public class Inside{//nested class//details of Inside class…

}//more members of Outside class…

}

3

Nested Classes

• An inner class (i.e. non-static) has access to all the variables and methods of its outer class and may refer to them directly in the same way that other non-static members of the outer class do

• Reverse not true• Static nested classes seldom used because they

can only access members of the enclosing class through an object, rather than directly

• Methods of outer class can create objects of inner class. Outer class is responsible for creating inner class objects

4

Nested Classes

class Outer { int outer_x = 100; void test() { Inner inner = new Inner(); inner.display(); } // this is an inner class class Inner { int y = 10; // y is local to Inner void display() { System.out.println("display: outer_x = " + outer_x); } } /* void showy() { System.out.println(y); // error, y not known here! } */} class InnerClassDemo { public static void main(String args[]) { Outer outer = new Outer(); outer.test(); }}Output: display: outer_x = 100

5

Nested Classes

• Or in class InnerClassDemo’s main( ):Outer o = new Outer ( );

Outer.Inner i = o.new Inner ( ); /* enclosing class name used as qualifier */

i.display( ); //same output now

• We create an object of inside class in the context of an outer class’s object

• A nested class can have an access attribute (public, private, protected, default) just like other class members, and the accessibility from outside the enclosing class is determined by the attributes in the same way

6

Nested Classes

• What are the access attributes for normal classes? e.g. if we make private class Inner then not accessible from InnerClassDemo

• Inside any block: Can have inner classes within any block scope e.g. methods or even a for loop (the inner class now cannot have any access specifier)

• When so defined, inner class can access only final local variables or method parameters that are in the scope of the block that declares the class

7

Exception Handling

O

8

Introduction

• Errors can be dealt with at place error occurs– Easy to see if proper error checking implemented

– Harder to read application itself and see how code works

• Exception handling – Makes clear, robust, fault-tolerant programs

– Java removes error handling code from "main line" of program

• Common failures– Out of bounds array subscript

– Division by zero

– Memory exhaustion

– Invalid method parameters

9

Introduction

• Exception handling– Catch errors before they occur

– Used when system can recover from error• Exception handler - recovery procedure

• Error dealt with in different place than where it occurred

– Useful when program cannot recover but must shut down cleanly

10

When Exception Handling Should Be Used

• Exception handling used for– Processing exceptional situations where a method is unable

to complete task for reasons beyond its control

– Processing exceptions for components (methods, libraries, classes) that are to be widely used and that cannot handle them directly (unique needs of each user)

– Large projects that require project wide uniform error processing

11

The Basics of Java Exception Handling

• Exception handling– Java exception is an object– Built-in class Throwable is superclass of all exception

subclasses– 2 subclasses of Throwable: Exception and Error– User generated errors handled by Exception — extend it to

create your own exception types– Run-time environment errors by Error (will not cover) e.g.

stack overflow, or JVM error– Method detects error it cannot deal with

• Throws an exception

– Exception handler• Code to catch exception and handle it

12

The Basics of Java Exception Handling

• Useful to see what happens when you don’t handle exceptions in your program

class Exc0 {

public static void main(String args[]) {

int d = 0;

int a = 42 / d;

}

}

Output from default exception handler: Exception in thread “main”

java.lang.ArithmeticException: / by zero

at Exc0.main(Exc0.java:4)

13

The Basics of Java Exception Handling

• Format– Enclose code that may have an error in try block

– Follow with one or more catch blocks• Each catch block has an exception handler

– On exception, try block exited (and not returned to)

– If exception occurs and matches parameter in catch block• Code in catch block executed

– If no exception thrown• Exception handling code skipped

• Control resumes after catch blockstry{ code that may throw exceptions

}

catch (ExceptionType ref) { exception handling code}

14

The Basics of Java Exception Handling

• Java uses Termination model of exception handling (cf Resumption model)– throw point

• Place where exception occurred – can be from statements in a method, or from a called method in at try block

• Control cannot return to throw point

– Block which threw exception expires

• Key to Java exception handling is that the exception handler can be distant from the exception generating code

15

An Exception Handling Example: Divide by Zero

• Example program– We want to catch division by zero errors

– Exceptions• Objects derived from class Exception

– Look in Exception classes in java.lang• Subclass RuntimeException has exceptions automatically

defined for your program and include divide by zero• ArithmeticException extends RuntimeException

and handles divide by zero for integers. If float, Java allows it by positive or negative infinity. Can still handle by writing your own extended class

public class MyException extends ArithmeticException{…}

16

An Exception Handling Example: Divide by Zero

class Exc2 { public static void main(String args[]) { int d, a;

try { // monitor a block of code. d = 0; a = 42 / d; System.out.println("This will not be printed."); } catch (ArithmeticException e) { // catch divide-

//by-zero error System.out.println("Division by zero."); } System.out.println("After catch statement."); }}

• Output:Division by zero.After catch statement.

17

Catching an Exception• Catching exceptions

– To catch all exceptions, catch an exception object:catch( Exception e )

– First handler to catch exception does• All other handlers skipped

– If exception not caught• Searches enclosing try blocks for appropriate handler

– If still not caught, default exception handler runs

try{ try{ throw Exception2 } catch ( Exception1 ){...}}catch( Exception2 ){...}

18

Multiple catch Clauses

// Demonstrate multiple catch statements.

class MultiCatch { public static void main(String args[]) { try { int a = args.length; System.out.println("a = " + a); int b = 42 / a; int c[] = { 1 }; c[42] = 99; } catch(ArithmeticException e) { System.out.println("Divide by 0: " + e); } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Array index oob: " + e); } System.out.println("After try/catch blocks."); }}

19

Multiple catch Clauses• Exception subclasses before any superclass. Otherwise

unreachable code compile time error.

class SuperSubCatch {

public static void main(String args[]) {

try {

int a = 0;

int b = 42 / a;

} catch(Exception e) {

System.out.println("Generic Exception catch.");

}

/* This catch is never reached because

ArithmeticException is a subclass of Exception. */

catch(ArithmeticException e) { // ERROR - unreachable

System.out.println("This is never reached.");

}

}

}

20

Nested try Statements

class NestTry { public static void main(String args[]) { try { int a = args.length;

/* If no command line args are present, the following statement will generate a divide-by-zero exception. */ int b = 42 / a;

System.out.println("a = " + a);

try { // nested try block /* If one command line arg is used, then a divide-by-zero exception will be generated by the following

code. */ if(a= =1) a = a/(a-a); // division by zero

/* If two command line args are used then generate an out-of-bounds

exception. */ if(a = =2) { int c[ ] = { 1 }; c[42] = 99; /* generate an out-of-bounds

exception */ } }//end of inner try

catch(ArrayIndexOutOfBoundsException e) {

System.out.println("Array index out-of-bounds: " + e);

}

} catch(ArithmeticException e) { System.out.println("Divide by 0: " + e); } }}

21

/* Try statements can be implicitly nested via

calls to methods. */class MethNestTry { static void nesttry(int a) { try { // nested try block if(a= =1) a = a/(a-a); // division

//by zero if(a= =2) { int c[] = { 1 }; c[42] = 99; // generate an out-of-

bounds exception } }

catch(ArrayIndexOutOfBoundsException e) {

System.out.println("Array index out-of-bounds: " + e);

} }

public static void main(String args[]) { try { int a = args.length; int b = 42 / a; System.out.println("a = " + a); nesttry(a); } catch(ArithmeticException e) { System.out.println("Divide by 0: "

+ e); } }}

22

Throwing an Exception

• throw– So far have seen exceptions thrown by the Java run-time

system

– Can throw an exception explicitly too– throw ThrowableInstance;

• Object of any class derived from Throwable

e.g. throw new MyException();

• When exception thrown– Control exits current try block

– Proceeds to catch handler (if exists)

23

class ThrowDemo { static void demoproc() { try { throw new NullPointerException("demo"); } catch(NullPointerException e) { System.out.println("Caught inside

demoproc."); throw e; // re-throw the exception } } public static void main(String args[]) { try { demoproc(); } catch(NullPointerException e) { System.out.println("Recaught: " + e); } }}Output: Caught inside demoproc.

Recaught: java.lang.NullPointerException: demo

24

Rethrowing an Exception

• Rethrowing exceptions– Use if handler cannot process exception

– Rethrow exception with the statement:throw e; • Detected by next enclosing try block

– Handler can always rethrow exception, even if it performed some processing

25

throws Clause

• Checked Exceptions: – All non-RuntimeExceptions and all non-Error exceptions

• If a method is capable of causing a checked exception that it does not catch itself, it must use a throws clausetype methodName(parameter list) throws exception list{…}

• If a method calls another method that explicitly throws such exceptions, the calling method’s throws clause must include those exceptions or the calling method must catch those exceptions

• A method that overrides a subclass method cannot list more exceptions in the throws clause than in the superclass method (has to be a subset)

26

throws Clause

class ThrowsDemo { static void throwOne() throws IllegalAccessException

{ System.out.println("Inside throwOne."); throw new IllegalAccessException("demo"); } public static void main(String args[]) { try { throwOne(); } catch (IllegalAccessException e) { System.out.println("Caught " + e); } }}• Output:inside throwOne

Caught java.lang.IllegalAccessException: demo

27

finally Block

• finally block– Placed after last catch block

– Always executed, regardless whether exceptions thrown or not thrown or caught i.e. always executed at the conclusion of the try/catch block

– If catch blocks there, finally block executed after them

– Must be there if no catch block

– Ideal place for code that releases resources

– If exception thrown in finally block, processed by enclosing try block

28class FinallyDemo { // Through an exception out of the method. static void procA( ) { try { System.out.println("inside procA"); throw new RuntimeException("demo"); } finally { System.out.println("procA's finally"); } } // Return from within a try block. static void procB( ) { try { System.out.println("inside procB"); return; } finally { System.out.println("procB's finally"); } }// Execute a try block normally. static void procC( ) { try { System.out.println("inside procC"); } finally { System.out.println("procC's finally"); } }

public static void main(String args[ ]) { try { procA( ); } catch (Exception e) { System.out.println("Exception caught"); } procB(); procC(); }}Output: inside procAprocA’s finallyException caughtinside procBprocB’s finallyinside procCprocC’s finally

2000 Prentice Hall, Inc. All rights reserved.

Outline29

1. main

1.1 throwException

1.2 catch

2. Define throwException

2.1 try

2.2 catch

2.3 finally

1 // Fig. 14.9: UsingExceptions.java

2 // Demonstration of stack unwinding.

3 public class UsingExceptions {

4 public static void main( String args[] )

5 {

6 try {

77 throwException();

8 }

9 catch ( Exception e ) {

10 System.err.println( "Exception handled in main" );

11 }

12 }

13

14 public static void throwException() throws Exception

15 {

16 // Throw an exception and catch it in main.

17 try {

18 System.out.println( "Method throwException" );

1919 throw new Exception(); // generate exception

20 }

21 catch( RuntimeException e ) { // nothing caught here

22 System.out.println( "Exception handled in " +

23 "method throwException" );

24 }

25 finally {

26 System.err.println( "Finally is always executed" );

27 }

28 }

29 }

Call method throwException (enclosed in a try block).

Throw an Exception. The catch block cannot handle it, but the finally block executes irregardless.

2000 Prentice Hall, Inc. All rights reserved.

Outline30

Program Output

Method throwExceptionFinally is always executedException handled in main

31

Creating Your Own Exception Subclasses

• To handle specific situations not covered by built-in exceptions

• Extend Exception or some other subclass of it

32

class MyException extends Exception { private int detail; MyException(int a) { detail = a; } public String toString() {/*override

this method of Throwable*/ return "MyException[" + detail + "]"; }}class ExceptionDemo { static void compute(int a) throws

MyException { System.out.println("Called

compute(" + a + ")"); if(a > 10) throw new MyException(a); System.out.println("Normal exit"); }

public static void main(String args[]) {

try { compute(1); compute(20); } catch (MyException e) { System.out.println("Caught " +

e); } }}Output:Called compute(1)Normal exitCalled compute(20)Caught MyException[20]