Finally block: Finally block contains block of code and the block is executed after a try-catch block. If there is no errors in try block, finally statement is executed after try block executed. If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement. If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code. Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed. Rethrowing the exception: An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement. It allows many handlers to access the exception. However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement. In following class, first catch statement catches exception and rethrows it to another catch statement: class Rethrow_exp { try { //... Try block statement } Catch statement rethrows the exception. catch(Excep_type excep_obj) { //... Catch block statement // Rethrow the exception throw excep_obj } //... } Catch statement catches the rethrown the exception. class rethrow_main { //... catch(Excep_typeexcep_obj) { // Recatch block statement catches rethrown //exception } } Therefore, an inner catch rethrow an exception to an outer catch. Given code: //Try block try { statement1; statement2; statement3; } //Catch block catch (Exception1 ex1) { } //Catch block catch (Exception2 ex2) { } //Finally block finally { statement4; } statement5;

Question

Want to see the full answer?

Answer 1

Question

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Students have asked these similar questions

Please do this in Java! 3. RetailItem Exceptions Programming Challenge 4 of Chapter 6 required you to write a RetailItem class that holds data pertaining to a retail item. Write an exception class that can be instantiated and thrown when a negative number is given for the price. Write another exception class that can be instantiated and thrown when a negative number is given for the units on hand. Demonstrate the exception classes in a program. /** *Description: This program will displays a string without any user interaction *Class: Fall - COSC 1437.81002 *Assignment1: Hello World *Date: 08/15/2011 *@author Zoltan Szabo *@version 0.0.0 */ For each method, you will also be required to create docstring as follows: /** * @param String as args * @return Termination code as int, 0 for normal, anything else is error condition * @throws Nothing is implemented */ Flowcharts/UML and Pseudo code All assignment questions must show design flowchart/UML and/or pseudo code unless otherwise…

JAVA EXCEPTION HANDLING:Define a new exception, called ExceptionLineTooLong, that prints out the error message "The strings is too long". Write a program that reads phrase and throws an exception of type ExceptionLineTooLong in the case where a string is longer than 80 characters. For example: Input Result The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs.The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs.The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs.The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs.The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs.The quick brown fox jumped over the lazy dogs. The quick brown fox jumped over the lazy dogs.The quick brown fox jumped…

Q4: Write a program that performs exception handling. A class should have two exception handling classes. This program throws an exception of type both classes (user defined data types) and they are catched in a catch block. This class also throws an exception of built-in data types (of your choice). Also in your program include a catch block for all data types. Write a simple C++ code as i am a begineer.

Answer 2

Question

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 3

Question

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 4

Question

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 5

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 6

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 7

Chapter 12.7, Problem 12.7.1CP

a.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 8

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 9

b.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 10

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 11

c.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 12

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 13

d.

Program Plan Intro

Finally block:

Finally block contains block of code and the block is executed after a try-catch block.

If there is no errors in try block, finally statement is executed after try block executed.

If there is error in try block, then catch block caught the exception, rest of try block is skipped, and then executes the finally statement.

If there is error in try block, then catch block does not caught that exception, rest of try block is skipped, executes only finally statement, and then skip the rest of the code.

Thus, finally block handle such case and it contains block of statement. Once try-catch block gets executed, finally block is executed.

Rethrowing the exception:

An exception can be rethrown by a catch statement because; it can catch and handled by another catch statement.

It allows many handlers to access the exception.

However, the rethrown exception should not recaught by the same exception and should propagate to next catch statement.

In following class, first catch statement catches exception and rethrows it to another catch statement:

class Rethrow_exp

{

try

{

//... Try block statement

}

Catch statement rethrows the exception.

catch(Excep_type excep_obj)

{

//... Catch block statement

// Rethrow the exception

throw excep_obj

}

//...

}

Catch statement catches the rethrown the exception.

class rethrow_main

{

//...

catch(Excep_typeexcep_obj)

{

// Recatch block statement catches rethrown //exception

}

}

Therefore, an inner catch rethrow an exception to an outer catch.

Given code:

//Try block

try

{

statement1;

statement2;

statement3;

}

//Catch block

catch (Exception1 ex1)

{

}

//Catch block

catch (Exception2 ex2)

{

throw ex2;

}

//Finally block

finally

{

statement4;

}

statement5;

Answer 14

Expert Solution & Answer

Answer 15

Expert Solution & Answer

Answer 16

Want to see the full answer?

Check out a sample textbook solution

See solution

Answer 17

Ch. 12.2 - Prob. 12.2.1CP Ch. 12.2 - Prob. 12.2.2CP Ch. 12.2 - Prob. 12.2.3CP Ch. 12.2 - Prob. 12.2.4CP Ch. 12.2 - Prob. 12.2.5CP Ch. 12.2 - Show the output of the following code:Ch. 12.3 - Prob. 12.3.1CP Ch. 12.3 - Prob. 12.3.2CP Ch. 12.4 - Prob. 12.4.1CP Ch. 12.4 - Prob. 12.4.2CP

Solution Summary: The author explains that finally block contains block of code and the block is executed after a try-catch block.

Concept explainers

Want to see the full answer?

Chapter 12 Solutions