Java Throwtest - Print out text

Submitted by:Andery Smith

Date added:19 February, 2012


Throwtest an application that demonstrates how to define, throw, and handle exceptions. This application doesn't do anything other than print out some text, but if you might want to study it and play around with it to learn more about how exceptions work in Java. See the usage instructions in the source code.

Tags: java throwtest

Code Snippet:

// Here we define some exception types of our own.
// Exception classes generally have constructors but no data or
// other methods. All these do is to call their superclass constructors.
class MyException extends Exception {
public MyException() { super(); }
public MyException(String s) { super(s); }
class MyOtherException extends Exception {
public MyOtherException() { super(); }
public MyOtherException(String s) { super(s); }
class MySubException extends MyException {
public MySubException() { super(); }
public MySubException(String s) { super(s); }

// This class demonstrates defining, throwing and handling exceptions.
// Try invoking it in the following ways and try to understand the
// output:
// java throwtest
// java throwtest one
// java throwtest 0
// java throwtest 1
// java throwtest 99
// java throwtest 2
// java throwtest 3
public class throwtest {
// This is the main() method. Note that it uses two
// catch clauses to handle two standard Java exceptions.
public static void main(String argv[]) {
int i;

// First, convert our argument to an integer
// Make sure we have an argument and that it is convertible.
try {
i = Integer.parseInt(argv[0]);
catch (ArrayIndexOutOfBoundsException e) { // argv is empty
System.out.println("Must specify an argument");
catch (NumberFormatException e) { // argv[0] isn't an integer
System.out.println("Must specify an integer argument.");

// Now, pass that integer to method a().

// This method invokes b(), which is declared to throw
// one type of exception. We handle that one exception.
public static void a(int i) {
try {
catch (MyException e) { // Point 1.
// Here we handle MyException and
// its subclass MyOtherException
if (e instanceof MySubException)
System.out.print("MySubException: ");
System.out.print("MyException: ");
System.out.println("Handled at point 1");

// This method invokes c(), and handles one of the
// two exception types that that method can throw. The other
// exception type is not handled, and is propagated up
// and declared in this method's throws clause.
// This method also has a finally clause to finish up
// the work of its try clause. Note that the finally clause
// is executed after a local catch clause, but before a
// a containing catch clause or one in an invoking procedure.
public static void b(int i) throws MyException {
int result;
try {
System.out.print("i = " + i);
result = c(i);
System.out.print(" c(i) = " + result);
catch (MyOtherException e) { // Point 2
// Handle MyOtherException exceptions:
System.out.println("MyOtherException: " + e.getMessage());
System.out.println("Handled at point 2");
finally {
// Terminate the output we printed above with a newline.

// This method computes a value or throws an exception.
// The throws clause only lists two exceptions, because
// one of the exceptions thrown is a subclass of another.
public static int c(int i) throws MyException, MyOtherException {
switch (i) {
case 0: // processing resumes at point 1 above
throw new MyException("input too low");
case 1: // processing resumes at point 1 above
throw new MySubException("input still too low");
case 99:// processing resumes at point 2 above
throw new MyOtherException("input too high");
return i*i;