Exceptions - Revision history

Suhridk: /* Exception Handling */

2011-09-07T10:45:32Z

Exception Handling

2011-09-07T10:43:42Z

Exception Handling

2011-09-04T12:43:23Z

2011-09-04T12:20:21Z

Exception Handling

2011-07-21T05:47:00Z

2011-07-21T05:45:04Z

2011-07-20T09:15:28Z

2011-07-20T07:56:42Z

2011-07-20T07:55:01Z

2011-07-20T07:47:47Z

@@ Line 24: / Line 24: @@
 * The compiler will check if the code within the try block can throw any checked exceptions in the catch block, if not it will flag an error. See below:
-* This is true explicitly for checked exceptions. The compiler wont complain for catch clauses for Exception, Error and Throwable.
+** This is '''true only for checked exceptions'''. The compiler wont complain for catch clauses for Exception, Error and Throwable.
 <syntaxhighlight lang="java5">

@@ Line 23: / Line 23: @@
 * Each method must follow the handle or declare law for checked exceptions.
-* The compiler will check if the code within the try block can throw the exceptions in the catch block, if not it will flag an error. See below:
+* The compiler will check if the code within the try block can throw any checked exceptions in the catch block, if not it will flag an error. See below:
 <syntaxhighlight lang="java5">

← Older revision		Revision as of 12:43, 4 September 2011
Line 81:		Line 81:

	}		}
		+
		+	</syntaxhighlight>
		+
		+	== finally block ==
		+
		+	* The finally block is always called, no matter what. (Other than a System.exit() ! )
		+
		+	<syntaxhighlight lang="java5">
		+
		+	import java.io.IOException;
		+
		+	public class Finale {
		+
		+	public static void main(String[] args) {
		+
		+	try {
		+	foo();
		+	} catch (Exception e) {
		+	System.out.println("EEE");
		+	return;
		+	} finally {
		+	System.out.println("Finale");
		+	}
		+	}
		+
		+	private static void foo() throws IOException {
		+	throw new IOException();
		+	}
		+
		+	/* Output:
		+	*
		+	* EEE
		+	* FINALE
		+	*/
		+
		+	}

	</syntaxhighlight>		</syntaxhighlight>

← Older revision		Revision as of 12:20, 4 September 2011
Line 65:		Line 65:


		+	* Although a finally block is always executed, it cannot "handle" exceptions, a catch block '''must be present'''.
		+
		+	<syntaxhighlight lang="java5">
		+
		+	public static void main(String[] args) {
		+
		+	try {
		+	foo(); //ILLEGAL, CATCH BLOCK MUST BE PRESENT
		+	} finally {
		+
		+	}
		+	}
		+
		+	private static void foo() throws IOException {
		+
		+	}
		+
		+	</syntaxhighlight>


	[[Category:OCPJP]]		[[Category:OCPJP]]

← Older revision	Revision as of 05:47, 21 July 2011
Line 43:	Line 43:


	+	* Any exceptions thrown from within a catch block will not be handled by the other catch clauses of the main try block.
	+	* These exceptions have to be handled or declared separately.

	+	<syntaxhighlight lang="java5">
	+
	+	public static void main(String[] args) {
	+	try {
	+	f();
	+	} catch(FileNotFoundException f) {
	+	throw new IOException(); //The below catch block will not handle this IOException. It has to be caught here or the method has to declare that it throws IOException.
	+	} catch(IOException e) {
	+
	+	}
	+	}
	+
	+	private static void f() throws FileNotFoundException {
	+
	+	}
	+
	+	</syntaxhighlight>

@@ Line 22: / Line 22: @@
 * If exceptions are in different class hierarchy, then the order does not matter.
 * Each method must follow the handle or declare law for checked exceptions.
 [[Category:OCPJP]]

@@ Line 16: / Line 16: @@
 * Both Error and Exception classes are derived from the java.lang.Throwable class.
-== Exception Matching ==
+== Exception Handling ==
 * The order of catch clauses is important.
 * If the exceptions are in the same class hierarchy, The most-specific exception type should be first, followed by the more general exceptions. Otherwise, the code will not compile.
 * If exceptions are in different class hierarchy, then the order does not matter.
 [[Category:OCPJP]]

@@ Line 18: / Line 18: @@
 == Exception Matching ==
-* The order of catch clauses is important. The most-specific exception type should be first, followed by the least specific.
+* The order of catch clauses is important. The most-specific exception type should be first, followed by the more general exceptions. Otherwise, the code will not compile.
+*
 [[Category:OCPJP]]