Thinking in Java from Chapter 11

// Simple container example (produces compiler warnings.)
// {ThrowsException}
import java.util.*;

class Apple {
	private static long counter;
	private final long id = counter++;
	public long id() { return id;}
}

class Orange {}

public class ApplesAndOrangesWithoutGenerics {
	@SuppressWarnings("unchecked")
	
	public static void main(String[] args) {
		ArrayList apples = new ArrayList();
		for(int i = 0; i < 3; ++i)
			apples.add(new Apple());
		
		// Not prevented from adding an Orange to apples:
		apples.add(new Orange());
		for(int i = 0; i < apples.size(); ++i)
			((Apple)apples.get(i)).id();
			// Orange is detected only at run time
	}
}

if(t == null)
	throw new NullPointerException();

throw new NullPointerException("t = null");

try {
	// Code that might generate exceptions
} catch(Type1 id1) {
	// Handle exceptions of Type1
} catch(Type2 id2) {
	// Handle exceptions of Type2
} catch(Type3 id3) {
	// Handle exceptions of Type3
}

// etc...

// Creating your own exceptions.
class SimpleException extends Exception {}

public class InheritingExceptions {
	public void f() throws SimpleException {
		System.out.println("Throw SimpleException from f()");
		throw new SimpleException();
	}
	
	public static void main(String[] args){
		InheritingExceptions sed = new InheritingExceptions();
		try {
			sed.f();
		} catch(SimpleException e) {
			System.out.println("Caught it!");
		}
	}
} /* Output:
Throw SimpleException from f()
Caught it!
*/ 

class MyException extends Exception {
	public MyException() {}
	public MyException(String msg) { super(msg);}
}

public class FullConstructors {
	public static void f() throws MyException {
		System.out.println("Throwing MyException from f()");
		throw new MyException();
	}
	
	public static void g() throws MyException {
		System.out.println("Throwing MyException from g()");
		throw new MyException("Originated in g()");
	}
	
	public static void main(String[] args){
		try {
			f();
		} catch(MyException e) {
			e.printStackTrace(System.out);
		}
		
		try {
			g();
		} catch(MyException e) {
			e.printStackTrace(System.out);
		}
	}
} /* Output:
Throwing MyException from f()
MyException
		at FullConstructors.f(FullConstructors.java:11)
		at FullConstructors.main(FullConstructors.java:19)
Throwing MyException from g()
MyException: Originated in g()
		at FullConstructors.g(FullConstructors.java:15)
		at FullConstructors.main(FullConstructors.java:24)
*/

void f() throws TooBig, TooSmall, DivZero { 
	// ... 
}

void f() {
	// ... 
}

catch (Exception e) {
	System.out.println("Caught an exception");
}

import static net.mindview.util.Print.*;

public class ExceptionMethods {
	public static void main(String[] args){
		try {
			throw new Exception("My Exception");
		} catch (Exception e) {
			print("Caught Exception");
			print("getMessage():" + e.getMessage());
			print("getLocalizedMessage()" + e.getLocalizedMessage());
			print("toString():" + e);
			print("printStackTrace():");
			e.printStackTrace(System.out);
		}
	}
}

public class WhoCalled {
	static void f() {
		// Generate an exception to fill in the stack trace
		try {
			throw new Exception();
		} catch(Exception e) {
			for(StackTraceElement ste : e.getStackTrace())
				System.out.println(ste.getMethodName());
		}
	}
	
	static void g() { f();}
	static void h() { g();}
	
	public static void main(String[] args){
		f();
		System.out.println("-----------------------");
		g();
		System.out.println("-----------------------");
		h();
		System.out.println("-----------------------");
	}
} /* Output:
f
main
-----------------------
f
g
main
-----------------------
f
g
h
main
*/

public class Rethrowing {
	public static void f() throws Exception {
		System.out.println("originating the exception in f()");
		throw new Exception("thrown from f()");
	}
	
	public static void g() throws Exception {
		try {
			f();
		} catch(Exception e) {
			System.out.println("Inside g(), e.printStackTrace()");
			e.printStackTrace(System.out);
			throw e;
		}
	}
	
	public static void h() throws Exception {
		try {
			f();
		} catch(Exception e) {
			System.out.println("Inside h(), e.printStackTrace()");
			e.printStackTrace(System.out);
			throw (Exception)e.fillInStackTrace();
		}
	}
	
	public static void main(String[] args){
		try {
			g();
		} catch(Exception e) {
			System.out.println("main: printStackTrace()");
			e.printStackTrace(System.out);
		}
		
		try {
			h();
		} catch(Exception e) {
			System.out.println("main: printStackTrace()");
			e.printStackTrace(System.out);
		}
	}
} /* Output:
originating the exception in f()
Inside g(), e.printStackTrace()
java.lang.Exception: thrown from f()
	at Rethrowing.f(Rethrowing.java:7)
	at Rethrowing.g(Rethrowing.java:11)
	at Rethrowing.main(Rethrowing.java:29)
main: printStackTrace()
java.lang.Exception: thrown from f()
	at Rethrowing.f(Rethrowing.java:7)
	at Rethrowing.g(Rethrowing.java:11)
	at Rethrowing.main(Rethrowing.java:29)
originating the exception in f()
Inside h(), e.printStackTrace()
jva.lang.Exception: thrown from f()
	at Rethrowing.f(Rethrowing.java:7)
	at Rethrowing.g(Rethrowing.java:20)
	at Rethrowing.main(Rethrowing.java:35)
main: printStackTrace()
java.lang.Exception: thrown from f()
	at Rethrowing.h(Rethrowing.java:24)
	at Rethrwoing.main(Rethrowing.java:35)
*/

class OneException extends Exception {
	public oneException(String s) { super(s);}
}

class TwoException extends Exception {
	public TwoException(String s) { super(s);}
}

public class RethrowNew {
	public static void f() throws OneException {
		System.out.println("originating the exception in f()");
		throw new OneException("thrown from f()");
	}
	
	public static void main(String[] args){
		try {
			try {
				f();
			} catch(OneExceptione) {
				System.out.println("Caught in inner try, e.printStackTrace()");
				e.printStackTrace(System.out);
				throw new TwoException("from inner try");
			}
		} catch(TwoException) {
			System.out.println("Caught in outer try, e.printStackTrace()");
			e.printStackTrace(System.out);
		}
	}
} /* Output:
originating the exception in f()
Caught in inner try, e.printStackTrace()
OneException: thrown from f()
	at RethrowNew.f(RethrowNew.java:15
	at RethrowNew.main(RethrowNew.java:20)
Caught in outer try, e.printStackTrace()
TwoException: from inner try
	at RethrowNew.main(RethrowNew.java:25)
*/

import static net.mindview.util.Print.*;

class DynamicFieldsException extends Exception {}

public class DynamicFields {
	private Object[][] fields;
	
	public DynamicFields(int initialSize) {
		fields = new Object[initialSize][2];
		
		for(int i = 0; i < initialSize; ++i)
			fields[i] = new Object[] {null, null};
	}
	
	public String toString() {
		StringBuilder result = new StringBuilder();
		
		for(Object[] obj : fields) {
			result.append(Obj[0]);
			result.append(": ");
			result.append(Obj[1]);
			result.append("\n");
		}
		
		return result.toString();
	}
	
	private int hasField(String id) {
		for(int i = 0; i < fields.length; ++i)
			if(id.equals(fields[i][0]))
				return i;
		
		return -1;
	}
	
	private int getFieldNumber (String id) throws  NoSuchFieldException {
		int fieldNum = hasField(id);
		if(fieldNum == -1)
			throw new NoSuchFieldException();
		
		return fieldNum;
	}
	
	private int makeField(String id) {
		for(int i = 0; i < fields.length; ++i)
			if(fields[i][0] == null){
				field[i][0] = id;
				return i;
			}
		
		// No empty fields. Add one:
		Object[][] tmp = new Object[fields.length + 1][2];
		for(int i = 0; i < fields.length; ++i)
			tmp[i] = fieldsp[i];
		for(int i = fields.length; i < tmp.length; ++i)
			tmp[i] = new Object[] {null, null};
		fields = tmp;
		
		// Recursive call with expanded fields:
		return makeField(id);
	}
	
	public Object getField(String id) throws NoSuchFieldException {
		return fields[getFieldNumber(id)][1];
	}
	
	public Object setField(String id, Object value) throws DynamicFieldsException {
		if(null == value) {
			// Most exceptions don‘t have a "cause" constructor.
			// In these cases you must use initCause().
			DynamicFieldsException dfe = new DynamicFieldsException();
			dfe.initCause(new NullPointerException());
			throw dfe;
		}
		
		int fieldNumber = hasField(id);
		if(-1 == fieldNumber)
			fieldNumber = makeField(id);
		Object result = null;
		
		try {
			result = getField(id);	// Get old value
		} catch(NoSuchFieldException e) {
			// Use constructor that takes "cause":
			throw new RuntimeException(e);
		}
		
		fields[fieldNumber][1] = value;
		return result;
	}
	
	public static void main(String[] args){
		DynamicFields df = new DynamicFields(3);
		print(df);
		
		try {
			df.setField("d", "A value for d");
			df.setField("number", 47);
			df.setField("number2", 48);
			print(df);
			
			df.setField("d", "A new value for d");
			df.setField("number3", 11);
			print("df: " + df);
			
			print("df.getField(\"d\") : " + df.getField("d"));
			Object field = df.setField("d", null);	// Exception
		} catch(NoSuchFieldException e) {
			e.printStackTrace(System.out);
		} catch(DynamicFieldsException e) {
			e.printStackTrace(System.out);
		}
	}	
} /* Output:
null: null
null: null
null: null

d: A value for d
number: 47
number2: 48

df: d: A new value for d
number: 47
number2: 48
number3: 11

df.getField("d") : A new value for d
DynamicFieldsException
	at DynamicFields.setField(DynamicFields.java:64);
	at DynamicFields.main(DynamicFields.java:94);
Caused by: java.lang.NullPointerException
	at DynamicFields.setFields(DynamicFields.java:66);
*/

try {
	// The guarded region: Dangerous activities
	// that might throw A, B or C
} catch(A a1) {
	// Handler for situation A
} catch(B b1) {
	// Handler for situation B
} catch(C c1) {
	// Handler for situation C
} finally {
	// Activities that happen every time
}

class ThreeException extends Exception {}

public class FinallyWorks {
	static int count = 0;
	public static void main(String[] args){
		while(true) {
			try {
				// Post-increment is zero first time:
				if(count++ = 0)
					throw new ThreeException();
				System.out.println("No exception");
			} catch(ThreeException e) {
				System.out.println("ThreeException");
			} finally {
				System.out.println("In finally clause");
				if(2 == count) break; // out of "while"
			}
		}
	}
} /* Output:
ThreeException
In finally clause
No exception
In finally clause
*/

import static net.mindview.uti.Print.*;

public class Switch {
	private boolean state = false;
	public boolean read() { return state; }
	public void on() { state = true; print(this); }
	public void off() { state = false; print(this); }
	public String toString() { return state ? "on" : "off"; }
}

public class OnOffException1 extends Exception {}
public class OnOffException2 extends Exception {}

// Why use finally?
public class OnOffSwitch {
	private static Switch sw = new Switch();
	public static void f() throws OnOffException1, OnOffException2 {}
	
	public static void main(String[] args){
		try {
			sw.on();
			
			// Code that can throw exceptions ...
			f();
			
			sw.off();			
		} catch(OnOffException1 e){
			System.out.println("OnOffException1");
			sw.off();
		} catch(OnOffException2 e){
			System.out.println("OnOffException2");
			sw.off();
		}
	}
} /* Output:
on
off
*/

public class WithFinally {
	static Switch sw = new Switch();
	
	public static void main(String[] args){
		try {
			sw.on();
			// Code that can throw exceptions ...
			OnOffSwitch.f();
		} catch(OnOffException1 e){
			System.out.println("OnOffException1");
		} catch(OnOffException2 e){
			System.out.println("OnOffException2");
		} finally {
			sw.off();
		}
	}
} /* Output:
on
off
*/

import static net.mindview.util.Print.*;

class FourException extends Exception {}

public class AlwaysFinally {
	public static void main(String[] args){
		print("Entering first try block");
		try {
			print("Entering second try block");
			try {
				throw new FourException();
			} finally {
				print("finally in 2nd try block");
			}
		} catch(FourException e){
			System.out.println("Caught FourException in 1st try block");
		} finally {
			System.out.println("finally in 1st try block");
		}
	}
} /* Output:
Entering first try block
Entering second try block
finally in 2nd try block
Caught FourException in 1st try block
finally in 1st try block
*/

import static net.mindview.util.Print.*;

public class MultipleReturns {
	public static void f(int i) {
		print("Initialization that requires cleanup");
		try {
			print("Point 1");
			if(1 == i) return;
			
			print("Point 2");
			if(2 == i) return;
			
			print("Point 2");
			if(2 == i) return;
			
			print("Point 3");
			if(3 == i) return;
			
			print("End");
			return;
		} finally {
			print("Performing cleanup");
		}
	}
	
	public static void main(String[] args){
		for(int i = 1; i <= 4; ++i)
			f(i);
	}
} /* Output:
Initialization that requires cleanup
Point 1
Performing cleanup
Initialization that requires cleanup
Point 1
Point 2
Performing cleanup
Initialization that requires cleanup
Point 1
Point 2
Point 3
Performing cleanup
Initialization that requires cleanup
Point 1
Point 2
Point 3
End
Performing cleanup
*/

class VeryImportantException extends Exception {
	public String toString() {
		return "A very important exception!";
	}
}

class HoHumException extends Exception {
	public String toString() {
		return "A trivial exception";
	}
}

public class LostMessage {
	void f() throws VeryImportantException {
		throw new VeryImportantException();
	}
	
	void dispose() throws HoHumException {
		throw new HoHumException();
	}
	
	public static void main(String[] args){
		try {
			LostMessage lm = new LostMessage();
			try {
				lm.f();
			} finally {
				lm.dispose();
			}
		} catch(Exception e){
			System.out.println(e);
		}
	}
} /* Output:
A trivial exception
*/

public class ExceptionSilencer {
	public class void main(String[] args){
		try {
			throw new RuntimeException();
		} finally {
			// Using ‘return‘ inside the finally block
			// will silence any thrown exception
			return;
		}
	}
}

class BaseballException extends Exception {}
class Foul extends BaseballException {}
class Strike extends BaseballException {}

abstract class Inning {
	public Inning() throws BaseballException {}
	public void event() throws BaseballException {
		// Doesn‘t actually have to throw anything
	}
	
	public abstract void atBat() throws Strike, Foul;
	public void walk(){} // Throws no checked exceptions
}

class StormException extends Exception {}
class RainedOut extends StormException {}
class PopFoul extends Foul {}

interface Storm {
	public void event() throws RainedOut;
	public void rainHard() throws RainedOut;
}

public class StormyInning extends Inning implements Storm {
	// OK to add new exceptions for constructors, but you
	// must deal with the base constructor exceptions;
	public StormyInning() throws RainedOut, BaseballException {}
	public StormyInning(String s) throws Foul, BaseballException {}
	
	// Regular methods must conform to base class:
	//! void walk() throws PopFoul {}	// Compile error
	
	// Interface CANNOT add exceptions to existing
	// methods from the base class:
	//! public void event() throws RainedOut {}
	
	// If the method doesn‘t already exist in the
	// base class, the exception is OK:
	public void rainHard() throws RainedOut {}
	
	// You can choose to not throw any exceptions,
	// even if the base version does:
	public void event() {}
	
	// Overridden methods can throw inherited exceptions:
	public void atBat() throws PopFoul {}
	
	public static void main(String[] args){
		try {
			StormyInning si = new StormyInning();
			si.atBat();
		} catch(PopFoul e) {
			System.out.println("Pop foul");
		} catch(RainedOut e){
			System.out.println("Rained out");
		} catch(BaseballException e){
			System.out.println("Generic baseball exception");
		}
		
		// Strike not thrown in derived version.
		try {
			// What happens if you upcast?
			Inning i = new StormyInning();
			i.atBat();
			// You must catch the exceptions from the
			// base-class version of the method:
		} catch(Strike e){
			System.out.println("Strike");
		} catch(Foul e){
			System.out.println("Foul");
		} catch(RainedOut e){
			System.out.println("Rained Out");
		} catch(BaseballException e){
			System.out.println("Generic baseball exception");
		}
	}
}

public StormyInning() throws RainedOut, BaseballException {}

//! void walk() throws PopFoul {}	// Compile error， because the method in base class throws no checked exceptions

//! public void event() throws RainedOut {}    // event() method in base class only throws BaseballException

public void event() throws RainedOut, BaseballException {}

public void rainHard() throws RainedOut {}

public void event() {}

public void atBat() throws PopFoul {}    // because PopFoul is inherited from Foul which is the exception throws from atBat() in base class

import java.io.*;

public class InputFile {
	private BufferReader in;
	
	public InputFile(String fname) throws Exception {
		try {
			in = new BufferedReader(new FileReader(fname));
			// Other code that might throw exceptions
		} catch(FileNotFoundException e) {
			System.out.println("Could not open " + fname);
			// Wasn‘t open, so don‘t close it
			throw e;
		} catch(Exception e) {
			// All other exceptions must close it
			try {
				in.close();
			} catch(IOException e2) {
				System.out.println("in.close() unsuccessful");
			}
			
			throw e;	// Rethrow
		} finally {
			// Don‘t close it here!!!
		}
	}
	
	public String getLine() {
		String s;
		
		try {
			s = in.readLine();
		} catch(IOException e) {
			throw new RuntimeException("readLine() failed");
		}
		
		return s;
	}
	
	public void dispose() {
		try {
			in.close();
			System.out.println("dispose() successful");
		} catch(IOException e) {
			throw new RuntimeException("in.close() failed");
		}
	}	
}

public class Cleanup {
	public static void main(String[] args){
		try{
			InputFile in = new InputFile("Cleanup.java");
			try {
				String s;
				int i = 1;
				while((s = in.getLine()) != null)
					;	// Perform line-by-line processing here...
			} catch(Exception e) {
				System.out.println("Caught Exception in main");
				e.printStackTrace(System.out);
			} finally {
				in.dispose();
			}
		} catch(Exception e) {
			System.out.println("InputFile construction failed.");
		}
	}
} /* Output:
dispose() successful
*/

// Each disposable object must be followed by a try-finally

class NeedsCleanup {	// Construction can‘t fail
	private static long counter = 1;
	private final long id = counter++;
	
	public void dispose() {
		System.out.println("NeedsCleanup " + id + " disposed");
	}
}

class ConstructionException extends Exception {}

class NeedsCleanup2 {
	// Construction can fail:
	public NeedsCleanup2() throws ConstructionException {}
}

public class CleanupIdiom {
	public static void main(String[] args){
		// Section 1:
		NeedsCleanup nc1 = new NeedsCleanup();
		
		try{
			// ...
		} finally {
			nc1.dispose();
		}
		
		// Section 2:
		// If construction cannot fail you can group objects
		NeedsCleanup nc2 = new NeedsCleanup();
		NeedsCleanup nc3 = new NeedsCleanup();
		
		try {
			// ...
		} finally {
			nc3.dispose();	// Reverse order of construction
			nc2.dispose();
		}
		
		// Section 3:
		// If construction can fail you must guard each one:
		try {
			NeedsCleanup2 nc4 = new NeedsCleanup2();
			
			try {
				NeedsCleanup2 nc5 = new NeedsCleanup2();
				
				try {
					// ...
				} finally {
					nc5.dispose();
				}
			} catch(ConstructionException e) {	// nc5 constructor
				System.out.println(e);
			} finally {
				nc4.dispose();
			}
		} catch(ConstructionException e) {	// nc4 constructor
			System.out.println(e);
		}
	}
} /* Output:
NeedsCleanup 1 disposed
NeedsCleanup 3 disposed
NeedsCleanup 2 disposed
NeedsCleanup 5 disposed
NeedsCleanup 4 disposed
*/

// Catching exception hierarchies

class Annoyance extends Exception {}
class Sneeze extends Annoyance {}

public class Human {
	public static void main(String[] args){
		// Catch the exact type:
		try {
			throw new Sneeze();
		} catch(Sneeze s) {
			System.out.println("Caught Sneeze");
		} catch(Annoyance a) {
			System.out.println("Caught Annoyance");
		}
		
		// Catch the base type:
		try {
			throw new Sneeze();
		} catch(Annoyance a) {
			System.out.println("Caught Annoyance");
		}
	}
} /* Output:
Caught Sneeze
Caught Annoyance
*/

try {
	throw new Sneeze();
} catch(Annoyance a) {
	// ...
} catch(Sneeze s) {
	// ...
}

import java.io.*;

public class MainException {
	// Pass all exceptions to the console:
	public static void main(String[] args) throws Exception {
		// Open the file
		FileInputStream file = new FileInputStream("MainException.java");
		
		// Use the file ...
		
		// Close the file:
		file.close();
	}
}

try {
	// ... to do something useful
} catch(IDontKnowWhatToDoWithThisCheckedException e) {
	throw new RuntimeException(e);
}

// "Turn off" checked exceptions
import java.io.*;
import static net.mindview.util.Print.*;

class WrapCheckedException {
	void throwRuntimeException(int type) {
		try {
			switch(type) {
				case 0: throw new FileNotFoundException();
				case 1: throw new IOExceptin();
				case 2: throw new RuntimeException("Where am I?");
				default: return;
			}
		} catch(Exception e) { // Adapt to unchecked:
			throw new RuntimeException(e);
		}
	}
}

class SomeOtherException extends Exception {}

public class TurnOffChecking {
	public static void main(String[] args){
		WrapCheckedException wce = new WrapCheckedException();
		
		// You can call throwRuntimeExceptino() without a try
		// block, and let RuntimeExceptions leave the method:
		wce.throwRuntimeException(3);
		
		// Or you can choose to catch exceptions:
		for(int i = 0; i < 4; ++i) 
			try {
				if(i < 3)
					wce.throwRuntimeException();
				else
					throw new SomeOtherException();
			} catch(SomeOtherException e) {
				print("SomeOtherException: " + e);
			} catch(RuntimeException re) {
				try {
					throw re.getCause();
				} catch(FileNotFoundException e) {
					print("FileNotFoundException: " + e);
				} catch(IOException e) {
					print("IOException: " + e);
				} catch(Throwable e) {
					print("Throwable: " + e);
				}
			}
		
	}
} /* Output:
FileNotFoundException: java.io.FileNotFoundException
IOException: java.io.IOException
Throwable: java.lang.RuntimeException: Where am I?
SomeOtherException: SomeOtherException
*/