In java many times we required to throw our own custom Exception. We can throw our custom Exception by creation our own Exception class which will extend from class java.lang.Exception.
Before going to example lets look at few points about Exception Handling from book "Sun Certified Java Programmer SCJP 5" by Kathy sierra.
Handling Exceptions
Lets see a simple example which will throw a custom Exception.
In this example we have a method
Here our class MyException extends java.lang.Exception also observe the constructor
To know more look API
/*
Output
When Even Number
#>java MyException
It is Even number
When Odd Number
#>java MyException
MyException: Odd number not allowed
at MyException.acceptsEvenNumber(MyException.java:16)
at MyException.main(MyException.java:25)
Before going to example lets look at few points about Exception Handling from book "Sun Certified Java Programmer SCJP 5" by Kathy sierra.
Handling Exceptions
- Exceptions come in two flavors: checked and unchecked.
- Checked exceptions include all subtypes of Exception, excluding classes
that extend RuntimeException. - Checked exceptions are subject to the handle or declare rule; any method
that might throw a checked exception (including methods that invoke methods
that can throw a checked exception) must either declare the exception
using throws, or handle the exception with an appropriate try/catch. - Subtypes of Error or RuntimeException are unchecked, so the compiler
doesn't enforce the handle or declare rule. You're free to handle them, or to
declare them, but the compiler doesn't care one way or the other. - If you use an optional finally block, it will always be invoked, regardless of
whether an exception in the corresponding try is thrown or not, and regardless
of whether a thrown exception is caught or not. - The only exception to the finally-will-always-be-called rule is that a finally
will not be invoked if the JVM shuts down. That could happen if code
from the try or catch blocks calls System.exit(). - Just because finally is invoked does not mean it will complete. Code in the
finally block could itself raise an exception or issue a System.exit(). - Uncaught exceptions propagate back through the call stack, starting from
the method where the exception is thrown and ending with either the first
method that has a corresponding catch for that exception type or a JVM
shutdown (which happens if the exception gets to main(), and main() is
"ducking" the exception by declaring it). - You can create your own exceptions, normally by extending Exception or
one of its subtypes. Your exception will then be considered a checked exception,
and the compiler will enforce the handle or declare rule for that exception. - All catch blocks must be ordered from most specific to most general.
If you have a catch clause for both IOException and Exception, you must
put the catch for IOException first in your code. Otherwise, the IOException
would be caught by catch(Exception e), because a catch argument
can catch the specified exception or any of its subtypes! The compiler will
stop you from defining catch clauses that can never be reached. - Some exceptions are created by programmers, some by the JVM.
Lets see a simple example which will throw a custom Exception.
In this example we have a method
acceptsEvenNumber(int number)
which accepts only even number, it it encounters odd number it throws our custom Exception ie "MyException".Here our class MyException extends java.lang.Exception also observe the constructor
MyException(String message)
which calls its super constructor.To know more look API
.
/*
MyException.java
*/public class MyException extends Exception {
public MyException(String message) {
super(message);
}
//This method throws custom Exception
public static void acceptsEvenNumber(int number) throws MyException {
if(number %2 == 0) {
System.out.println("It is Even number");
}
else {
throw new MyException("Odd number not allowed");
}
}
public static void main(String[] args) {
try {
//acceptsEvenNumber(23);
//odd number
acceptsEvenNumber(22); //even number
} catch (MyException e) {
e.printStackTrace();
}
}
}
Output
When Even Number
#>java MyException
It is Even number
When Odd Number
#>java MyException
MyException: Odd number not allowed
at MyException.acceptsEvenNumber(MyException.java:16)
at MyException.main(MyException.java:25)