Exception v Bff d

7/30/2019 Exception v Bff d

1/22

1) Which package contains exception handling related classes?java.lang

2) What are the two types of Exceptions?

Checked Exceptions and Unchecked Exceptions.

3) What is the base class of all exceptions?

java.lang.Throwable

4) What is the difference between Exception and Error in java?

Exception and Error are the subclasses of the Throwable class. Exception class is used for

exceptional conditions that user program should catch. Error defines exceptions that are not

excepted to be caught by the user program. Example is Stack Overflow.

5) What is the difference between throw and throws?

Throw is used to explicitly raise a exception within the program, the statement would be throw

new Exception(); throws clause is used to indicate the exceptions that are not handled by the

method. It must specify this behavior so the callers of the method can guard against the

exceptions.

Throws is specified in the method signature. If multiple exceptions are not handled, then they

are separated by a comma. the statement would be as follows: public void doSomething()

throws IOException,MyException{}

6) Differentiate between Checked Exceptions and Unchecked Exceptions?

Checked Exceptions are those exceptions which should be explicitly handled by the calling

method. Unhandled checked exceptions results in compilation error.

Unchecked Exceptions are those which occur at runtime and need not be explicitly handled.

RuntimeException and it's subclasses, Error and it's subclasses fall under unchecked exceptions.

7) What are User defined Exceptions?

Apart from the exceptions already defined in Java package libraries, user can define his own

exception classes by extending Exception class.


2/22

What is the importance of finally block in exception handling?

Finally block will be executed whether or not an exception is thrown. If an exception is thrown,

the finally block will execute even if no catch statement match the exception. Any time a

method is about to return to the caller from inside try/catch block, via an uncaught exception or

an explicit return statement, the finally block will be executed. Finally is used to free up

resources like database connections, IO handles, etc.

9) Can a catch block exist without a try block?

No. A catch block should always go with a try block.

10) Can a finally block exist with a try block but without a catch?

Yes. The following are the combinations try/catch or try/catch/finally or try/finally.

11) What will happen to the Exception object after exception handling?

Exception object will be garbage collected.

12) The subclass exception should precede the base class exception when used within the catch

clause. True/False?

True.

13) Exceptions can be caught or rethrown to a calling method. True/False?

True.

14) The statements following the throw keyword in a program are not executed. True/False?

True.

15) How does finally block differ from finalize() method?

Finally block will be executed whether or not an exception is thrown. So it is used to free

resoources. finalize() is a protected method in the Object class which is called by the JVM just

before an object is garbage collected.

16) What are the constraints imposed by overriding on exception handling?


3/22

An overriding method in a subclass may only throw exceptions declared in the parent class or

children of the exceptions declared in the parent class.

2) ****************************************************************************1. What will be the output of the program?

public class Foo{

public static void main(String[] args){

try{

return;}finally{

System.out.println( "Finally" );}

}}

A. inally

B. ompilation fails.

C. he code runs with no output.D.An exception is thrown at runtime.

Answer & Explanation

Answer: Option A

Explanation:

If you put a finally block after a try and its associated catch blocks, then once execution entersthe try block, the code in that finally block will definitely be executed except in the following

circumstances:

1. An exception arising in the finally block itself.2. The death of the thread.3. The use ofSystem.exit()4. Turning off the power to the CPU.

I suppose the last three could be classified as VM shutdown.

View AnswerWorkspaceReportDiscuss in Forum

2. What will be the output of the program?

try{

int x = 0;int y = 5 / x;

}
http://www.indiabix.com/java-programming/exceptions/discussion-106http://www.indiabix.com/java-programming/exceptions/discussion-106http://www.indiabix.com/java-programming/exceptions/discussion-106http://www.indiabix.com/java-programming/exceptions/discussion-106


4/22

catch (Exception e){

System.out.println("Exception");}catch (ArithmeticException ae){

System.out.println(" Arithmetic Exception");}System.out.println("finished");

A. inished B.ExceptionC. ompilation fails. D.Arithmetic Exception


Answer: Option C

Explanation:

Compilation fails because ArithmeticException has already been caught. ArithmeticException

is a subclass ofjava.lang.Exception, by time the ArithmeticException has been specified it hasalready been caught by the Exception class.

IfArithmeticException appears before Exception, then the file will compile. When catchingexceptions the more specific exceptions must be listed before the more general (the subclasses

must be caught before the superclasses).



public class X{

public static void main(String [] args){

try{

badMethod();System.out.print("A");

}catch (Exception ex){

System.out.print("B");}finally{

System.out.print("C");}System.out.print("D");

}public static void badMethod(){

throw new Error(); /* Line 22 */}


5/22

}

A.ABCD

B. ompilation fails.

C. is printed before exiting with an error message.D. C is printed before exiting with an error message.


Answer: Option C

Explanation:

Erroris thrown but not recognised line(22) because the only catch attempts to catch an

Exception andException is not a superclass ofError. Therefore only the code in the finally

statement can be run before exiting with a runtime error (Exception in thread "main"

ava.lang.Error).



public class X{


try{


}

catch (RuntimeException ex) /* Line 10 */{System.out.print("B");

}catch (Exception ex1){

System.out.print("C");}finally{

System.out.print("D");}System.out.print("E");

}

public static void badMethod(){

throw new RuntimeException();}

}

A. D B.BCD

C. DE D.BCDEAnswer & Explanation


6/22

Answer: Option C

Explanation:

A Run time exception is thrown and caught in the catch statement on line 10. All the codeafter the finally statement is run because the exception has been caught.



public class RTExcept{

public static void throwit (){

System.out.print("throwit ");

throw new RuntimeException();}public static void main(String [] args){

try{

System.out.print("hello ");throwit();

}catch (Exception re ){

System.out.print("caught ");}finally

{System.out.print("finally ");

}System.out.println("after ");

}}

A.hello throwit caughtB. ompilation fails

C.hello throwit RuntimeException caught after

D.hello throwit caught finally after


Answer: Option D

Explanation:

The main() method properly catches and handles the RuntimeException in the catch block,

finally runs (as it always does), and then the code returns to normal.

A, B and C are incorrect based on the program logic described above. Remember that properly


7/22

handled exceptions do not cause the program to stop executing.


public class Foo{public static void main(String[] args){

try{

return;}finally{

System.out.println( "Finally" );}

}}

A. inallyB. ompilation fails.

C. he code runs with no output.

D.An exception is thrown at runtime.


Answer: Option A

Explanation:

If you put a finally block after a try and its associated catch blocks, then once execution enters

the try block, the code in that finally block will definitely be executed except in the followingcircumstances:

1. An exception arising in the finally block itself.2. The death of the thread.3. The use ofSystem.exit()4. Turning off the power to the CPU.

I suppose the last three could be classified as VM shutdown.



try{

int x = 0;int y = 5 / x;

}catch (Exception e)


8/22

{System.out.println("Exception");

}catch (ArithmeticException ae){

System.out.println(" Arithmetic Exception");}System.out.println("finished");

A. inished B.ExceptionC. ompilation fails. D.Arithmetic Exception


Answer: Option C

Explanation:

Compilation fails because ArithmeticException has already been caught. ArithmeticException

is a subclass ofjava.lang.Exception, by time the ArithmeticException has been specified it has

already been caught by the Exception class.

IfArithmeticException appears before Exception, then the file will compile. When catching

exceptions the more specific exceptions must be listed before the more general (the subclasses

must be caught before the superclasses).



public class X

{public static void main(String [] args){

try{


}catch (Exception ex){

System.out.print("B");}finally{

System.out.print("C");}System.out.print("D");

}public static void badMethod(){

throw new Error(); /* Line 22 */}

}


9/22

A.ABCD

B. ompilation fails.C. is printed before exiting with an error message.

D. C is printed before exiting with an error message.


Answer: Option C

Explanation:

Erroris thrown but not recognised line(22) because the only catch attempts to catch an

Exception andException is not a superclass ofError. Therefore only the code in the finally

statement can be run before exiting with a runtime error (Exception in thread "main"

ava.lang.Error).



public class X{


try{


}catch (RuntimeException ex) /* Line 10 */

{ System.out.print("B");}catch (Exception ex1){

System.out.print("C");}finally{

System.out.print("D");}System.out.print("E");

}public static void badMethod()

{throw new RuntimeException();

}}

A. D B.BCD

C. DE D.BCDE



10/22

Answer: Option C

Explanation:

A Run time exception is thrown and caught in the catch statement on line 10. All the codeafter the finally statement is run because the exception has been caught.



public class RTExcept{

public static void throwit (){

System.out.print("throwit ");

throw new RuntimeException();}public static void main(String [] args){

try{

System.out.print("hello ");throwit();

}catch (Exception re ){

System.out.print("caught ");}finally

{System.out.print("finally ");

}System.out.println("after ");

}}

A.hello throwit caughtB. ompilation fails

C.hello throwit RuntimeException caught after

D.hello throwit caught finally after


Answer: Option D

Explanation:

The main() method properly catches and handles the RuntimeException in the catch block,

finally runs (as it always does), and then the code returns to normal.

A, B and C are incorrect based on the program logic described above. Remember that properly


11/22

handled exceptions do not cause the program to stop executing.

1.which package contains exception handling related classes?

Ans: java. Lang

2. what are the two types of Exceptions?Ans: Checked Exceptions and Unchecked Exceptions.

3 what is the base class of all exceptions?

Ans: java.lang.Throwable

4 what is the difference between Exception and Error in java?

Ans: Exception and Error are the subclasses of the Throw able class. Exception

class is used for exceptional conditions that user program should catch. Error

defines exceptions that are not excepted to be caught by the user program.

Example is Stack Overflow.

5 what is the difference between throw and throws?

Ans: throw is used to explicitly raise a exception within the program, the statementwould be throw new Exception (); throws clause is used to indicate the exceptions

that are not handled by the method. It must specify this behavior so the callers of

the method can guardagainst the exceptions. Throws is specified in the method

signature.

If multiple exceptions are not handled, then they are separated by a comma. The

statement would be as follows: public void do something () throws IOException,

MyException {}

6 Differentiate between Checked Exceptions and Unchecked Exceptions?

Ans: Checked Exceptions are those exceptions which should be explicitly handled by

the calling method. Unhandled checked exceptions results in compilation error.Unchecked Exceptions are those which occur at runtime and need not be explicitly

handled. Runtime Exception and its subclasses, Error and its subclasses fall under

unchecked exceptions.

7 what are User defined Exceptions?

Ans: Apart from the exceptions already defined in Java package libraries, user can

define his own exception classes by extending Exception class.

8 what is the importance of finally block in exception handling?

Ans: Finally block will be executed whether or not an exception is thrown. If an

exception is thrown, the finally block will execute even if no catch statement match

the exception. Any time a method is about to return to the caller from inside

try/catch block, via an uncaught exception or an explicit return statement, the

finally block will be executed. Finally is used to free up resources like database

connections, IO handles, etc.

9 Can a catch block exist without a try block?

Ans: No. A catch block should always go with a try block.

10 Can a finally block exist with a try block but without a catch?


12/22

Ans: Yes. The following are the combinations try/catch or try/catch/finally or

try/finally.

11 what will happen to the Exception object after exception handling?

Ans: Exception object will be garbage collected.

12 The subclass exception should precede the base class exception when

used within the catch clause. True/False?

Ans: True.

13 Exceptions can be caught or rethrown to a calling method. True/False?

Ans: True.

14 The statements following the throw keyword in a program are not

executed. True/False?

Ans: True.

15 How does finally block differ from finalize () method?

Ans: Finally block will be executed whether or not an exception is thrown. So it is

used to free resoources. Finalize () is a protected method in the Object class which

is called by the JVM just before an object is garbage collected.

16 what are the constraints imposed by overriding on exception handling?

Ans: An overriding method in a subclass May only throw exceptions declared in the

parent class or children of the exceptions declared in the parent cla

1) If the overridden method in super class A throws FileNotFoundException,then the overriding method present in class B which is a subclass of class A

can throw IOException. If the above statement true?

Ans: The overriding method can not throw any checked exception other than

the exception classes or sub-classes of those classes which are thrown bythe overridden method.

In the scenario described in question, the method in class B can not throw

IOException but can throw FileNotFoundException exception.

2) What is the difference between checked and unchecked exception

handling in Java? What are the disadvantages of checked exceptionhandling?

Ans: Checked exceptions are the one for which there is a check by thecompiler that these exceptions have to be caught or specified with throwskeyword. These kind of exceptions occur because of conditions which are outof control of the application like Network error, File Access Denied etc.

Unchecked exceptions are the one which arise because of logic written bythe developer. e.g. Trying to access an array element which doesnt exist.


13/22

3) If there is common code to be executed in the catch block of 10

exceptions which are thrown from a single try block, then how that commoncode can be written with minimum effort?

Ans: In pre JDK 7, a method can be written and all catch blocks can invokethis method containing the common code.

In JDK 7, the | operator can be used in catch block in order to executecommon code for multiple exceptions. e.g. catch(SQLException sqle |

IOException ioe){}

4) Have you every created custom exceptions? Explain the scenario?

Ans: Custom exceptions are useful when the JDK exception classes dontcapture the essence of erroneous situation which has come up in the

application. A custom exception can be created by extending any subclass ofException class or by implementing Throwable interface.

E.g. A custom exception can be thrown when the custom JSP tag has valuefor the attribute which is not expected.

5) What is the difference between Validation, Exception and Error?

Ans: Validation is the process of making user enter data in a format which

the application can handle.

Exception handling is the process when the application logic didnt work asexpected by the Java compiler.

Error occurs in a situation where the normal application execution can not

continue. For e.g. out of memory.

6) What is the purpose of finally block? In which scenario, the code in finallyblock will not be executed?


14/22

Ans: finally block is used to execute code which should be executed

irrespective of whether an exception occurs or not. The kind of code writtenin a finally block consists of clean up code such as closing of database/file

connection.

But JDK 7 has come up with try with resources block which automatically

handles the closing of resources.

7) What do you understand by Exception chaining?

Ans: I have written a blog post for this answer here

8) How will you make the client code to be transparent from business logic

exceptions?

Ans: The use of Business Delegate design pattern makes the client invisible

from business logic exceptions. This helps in decoupling the client fromserver which helps in better maintainability of the application in terms of

future changes in client or business logic code.

9) What are the differences between NoClassDefFoundError and

ClassNotFoundException?

Ans: NoClassDefFoundError occurs when a class was found during

compilation but could not be located in the classpath while executing the

program.

For example: class A invokes method from class B and both compile fine but

before executing the program, an ANT script deleted B.class by mistake.Now on executing the program NoClassDefFoundError is thrown.

ClassNotFoundException occurs when a class is not found while dynamicallyloading a class using the class loaders.

For example: The database driver is not found when trying to load the driverusing Class.forName() method.


15/22

10) What is the purpose of throw keyword? What happens if we write throw

null; statement in a Java program?

Ans: throw keyword is used to re-throw an exception which has been

caught in a catch block. The syntax is throw e; where e is the reference tothe exception being caught. The exception is re-thrown to the client.

This keyword is useful when some part of the exception is to be handled bythe caller of the method in which throw keyword is used.

The use of throw null; statement causes NullPointerException to bethrown.

The answers are brief. Do post your comments if you think I have missedanything or discuss any other exception handling question.

******************************************************************************

// : c09:FullConstructors.java

// From 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002

// www.BruceEckel.com. See copyright notice in CopyRight.txt.

class MyException extends Exception {

public MyException() {}

public MyException(String msg) {

super(msg);

}

}

public class FullConstructors {

public static voidf() throws MyException {

System.out.println("Throwing MyException from f()");

throw new MyException();}

public static voidg() throws MyException {

System.out.println("Throwing MyException from g()");

throw new MyException("Originated in g()");

}


16/22

public static voidmain(String[] args) {

try {

f();

} catch (MyException e) {

e.printStackTrace();

}

try {

g();

} catch (MyException e) {

e.printStackTrace();

}

}

} ///:~

Creating Your Own Exception Classes

When you design a package of Java classes that collaborate to provide some useful function to

your users, you work hard to ensure that your classes interact well together and that theirinterfaces are easy to understand and use. You should spend just as much time thinking about

and designing the exceptions that your classes throw.

Suppose you are writing a linked list class that you're planning to distribute as freeware. Among

other methods, your linked list class supports these methods:

objectAt(int n)

Returns the object in the nth position in the list.firstObject()

Returns the first object in the list.

indexOf(Object o)Searches the list for the specified Object and returns its position in the list.

What Can Go Wrong?

Because many programmers will be using your linked list class, you can be assured that many

will misuse or abuse your class and its methods. Also, some legitimate calls to your linked list'smethods may result in an undefined result. Regardless, in the face of errors, you want your

linked list class to be as robust as possible, to do something reasonable about errors, and to

communicate errors back to the calling program. However, you can't anticipate how each user of

your linked list class will want the object to behave under adversity. So, often the best thing to do

when an error occurs is to throw an exception.

Each of the methods supported by your linked list might throw an exception under certainconditions, and each method might throw a different type of exception than the others. For

example,

objectAt()


17/22

will throw a exception if the integer passed into the method is less than 0

or larger than the number of objects currently in the listfirstObject()

will throw a exception if the list contains no objectsindexOf()

will throw a exception if the object passed into the method is not in the list

But what type of exception should each method throw? Should it be an exception provided withthe Java development environment? Or should you roll your own?

Choosing the Exception Type to Throw

When faced with choosing the type of exception to throw, you have two choices:

1. Use one written by someone else. For example, the Java developmentenviroment provides a lot of exception classes that you could use.

2. Write one of your own.You should go to the trouble of writing your own exception classes if you answer "yes" to any ofthe following questions. Otherwise, you can probably get away with using someone else's:

Do you need an exception type that isn't represented by those in the Javadevelopment environment?

Would it help your users if they could differentiate your exceptions fromthose thrown by classes written by other vendors?

Does your code throw more than one related exception? If you use someone else's exceptions, will your users have access to those

exceptions? A similar question is "Should your package be independent

and self-contained?"

Your linked list class can throw multiple exceptions, and it would be convenient to be able to

catch all exceptions thrown by the linked list with one handler. Also, if you plan to distribute

your linked list in a package, all related code should be packaged together. Thus for the linkedlist, you should roll your own exception class hierarchy.

The following diagram illustrates one possible exception class hierarchy for your linked list:


18/22

LinkedListException is the parent class of all the possible exceptions that can be thrown by the

linked list class. Users of your linked list class can write a single exception handler to handle all

linked list exceptions with a catch statement like this:

catch (LinkedListException) {. . .

}

Or, users could write more specialized handlers for each subclass of LinkedListException.

Choosing a Superclass

The diagram above does not indicate the superclass of the LinkedListException class. As you

know, Java exceptions must be Throwable objects (they must be instances of Throwable or a

subclass of Throwable). So, your temptation might be to make LinkedListException a subclassof Throwable. However, the java.lang package provides two Throwable subclasses that further

divide the type of problems that can occur within a Java program: Errors and Exceptions. Most

of the applets and applications that you write will throw objects that are Exceptions. (Errors arereserved for serious hard errors that occur deep in the system.)

Theoretically, any Exception subclass could be used as the parent class of LinkedListException.However, a quick perusal of those classes show that they are either too specialized or completely

unrelated to LinkedListException to be appropriate. Thus, the parent class of

LinkedListException should be Exception.

Because runtime exceptions don't have to be specified in the throws clause of a method, many

packages developers ask: "Isn't it just easier if I make all of my exception inherit fromRuntimeException?" The answer to this question is covered in detail onRuntime Exceptions--

The Controversy. The bottom line is that you shouldn't subclass RuntimeException unless your

class really is a runtime exception! For most of you, this means "No, your exceptions shouldn't

inherit from RuntimeException."

Naming Conventions

It's good practice to append the word "Exception" to the end of all classes that inherit (directly or

indirectly) from the Exception class. Similarly, classes that inherit from the Error class shouldend with the string "Error".

Every application fails once in while. Even the ones built with Java, using design patterns, best

practices, and a lot of good intentions. So we better prepare our applications for these situations,right? The first thing an application should do if it fails is to tell as much as possible about the

error situation. For example: where exactly in the application did the error occur, what was the

Java-method calling sequence, what data was being processed, and so on.

In this article I'll present a simple, systematic approach which will help Java developers

implement some solid error handling in their code. The building blocks are Java's Exception-classes.
http://www.karlin.mff.cuni.cz/network/prirucky/javatut/java/exceptions/runtime.htmlhttp://www.karlin.mff.cuni.cz/network/prirucky/javatut/java/exceptions/runtime.htmlhttp://www.karlin.mff.cuni.cz/network/prirucky/javatut/java/exceptions/runtime.htmlhttp://www.karlin.mff.cuni.cz/network/prirucky/javatut/java/exceptions/runtime.htmlhttp://www.karlin.mff.cuni.cz/network/prirucky/javatut/java/exceptions/runtime.htmlhttp://www.karlin.mff.cuni.cz/network/prirucky/javatut/java/exceptions/runtime.html


19/22

The basic stuff about Java Exceptions

I'll not go through all the details of Java's exceptions, there are lot of good books and articlesabout this. But a short intro might be nice as a starter.

Java uses exceptions to report severe errors. If a Java statement fails to execute, the Java VMwill create a new instance of an Exception class--or subclass thereof--and then "throw" it. Aprogram can "catch" such an exception, inspect it using its methods, and then try to do something

sensible to handle the error.

By "severe errors" I refer to situations in a program which the programmer does not consider

"normal". This could be a database connection that suddenly drops, an attempt to divide by zero,

or anything else that is vital to the proper functioning of a program. What is NOT a severe erroris for example when you get end-of-file reading a sequential file. Even if it does not occurfrequently it's expected that it will occur, and you should therefore add code in your program to

handle this situation.

It's a tradition in Java literature to illustrate the use of exceptions by a "division by zero" case, so

why change this approach:

public float myDivide(int a, int b) {float r;try {r = a / b;

}catch (ArithmeticException e) {System.out.println(e.getMessage());r = Float.POSITIVE_INFINITY;

}

return r;}

In this code a divison by zero is caught, and the result is set to Java's value for "infinity". Theexample is merely to illustrate the technique. It would be simpler--and more correct--to test if "b"

had the value zero before making the division.

An "ArithmeticException" is a subclass of "RuntimeException", which again is a subclass of

class "Exception". All exceptions of class "Exception" or subclasses thereof--except

"RuntimeException"s--must be caught. "FileNotFoundException" is not a "RuntimeException",

so if you try to read a file with a statement like this

FileInputStream f = new FileInputStream("mydata.txt");

then the Java compiler would ask you to either "try-catch" "FileNotFoundException" or declareit in the throws clause of the method, like this:

public float someMethod() throws FileNotFoundException {...


20/22

Using the latter setup the caller of "someMethod" would again need to either catch this exception

or to declare it in its own throws clause. If no-one catches an exception it'll end up in the"container" that runs the Java classes. This could be the Java VM, a servlet engine, or something

else. The net result would be that the program stops and some error messages are written out,

probably a Java-method stack trace containing the error information from the exception class

which was thrown. This is indeed useful to the programmer (notto the end-user), but very oftennot enough to locate the problem.

When you catch an error you have some choices:

repair the situation so the program can continue to run normally (as in the example above) throw a new exception which the caller of the failing method then must handle ignore the error (not recommended!) pull the emergency break by calling System.exit()--probably after having written information to

log files etc.

A really useful feature is the ability to create your own exception classes. This is done bycreating a subclass of class "Exception". If you detect a problem in your application you may

now throw one of your own exceptions. By doing this you simplify your error handling code,

since you can now handle system errors and application errors in the same, consistent way.

So much for the basics.

When things go wrong - collect data!

I'll now describe a general technique, using your own exception classes, that can be used to

handle severe, non-repairable errors. This means that your application has detected a situation

that can not be neglected, so what's important now is this:

1. collect as much information as possible about what has happened2. write this data to some persistent media--e.g. a log file or a data base3. give the user--assuming there is one--some explanatory information about what has happened4. keep the application alive if this makes sense and you're sure that this will not introduce further

damage

The reason for "1" and "2" is obvious: in order for the support people to be able to find out whatwent wrong, so a program bug can be fixed, and to be able to tell the user what has happened and

what the consequences are, you need all the information that you can get. We have all

experienced the frustration by receiving error message like "System error at unknown location".

If this is all the information the support people get, then it might be impossible to locate theproblem.

So how do we collect data in a systematic way?

Let's consider the general situation where your "top-level" program (which could be a servlet, a

JSP-page, or any Java class) calls method "a" in class "A", which again calls method "b" in class"B", where an exception is thrown. Let's for simplicity limit the example to these three levels.


21/22

What we should do when the exception in "b" is thrown is this:

1. let "b" catch the exception2. let the catch-code save all essential data in our own exception class (see the specs below) and...3. throw this exception4. let "a" catch it5. let the catch-code in "a" save its own essential data in a new instance of our own exception class

and...6. throw this exception7. let the top-level program catch it8. this program should now ensure that all collected data is written to the proper log files, and9. give the user at the PC an understandable message of what's going on

class NumberRangeException extends Exception

{

String msg;

NumberRangeException()

{msg = new String("Enter a number between 20 and 100");

}

}

public class My_Exception

{

public static void main (String args [ ])

{ try

{

int x = 10;

if (x < 20 || x >100) throw new NumberRangeException( );}

catch (NumberRangeException e)

{

System.out.println (e);

}


22/22

}

}

Exception v Bff d

Documents

Transcript of Exception v Bff d