What will the following code snippet print:

Float f = null;
try{
f = Float.valueOf("12.3");
String s = f.toString();
int i = Integer.parseInt(s);
System.out.println("i = "+i);
}catch(Exception e){
System.out.println("trouble : "+f);
}

Select 1 option

A. 12
B. 13
C. trouble : null
D. trouble : 12.3
E. trouble : 0.0

What will be the result of compiling and running the following program?

class NewException extends Exception {}
class AnotherException extends Exception {}
public class ExceptionTest{
public static void main(String [] args) throws Exception{
try{
m2();
}
finally{ m3(); }
}
public static void m2() throws NewException{ throw new NewException(); public static void m3() throws AnotherException{ throw new AnotherException(); }

Select 1 option

A. It will compile but will throw AnotherException when run.
B. It will compile but will throw NewException when run.
C. It will compile and run without throwing any exceptions.
D. It will not compile.
E. None of the above.

What will be the result of attempting to compile and run the following program?

class TestClass{
public static void main(String args[]){
int i = 0;
loop : // 1
{
System.out.println("Loop Lable line");
try{
for ( ; true ; i++ ){
if( i >5) break loop; // 2
}
}
catch(Exception e){
System.out.println("Exception in loop.");
}
finally{
System.out.println("In Finally"); // 3
}
} } }

Select 1 option

A. Compilation error at line 1 as this is an invalid syntax for defining a label.
B. Compilation error at line 2 as 'loop' is not visible here.
C. No compilation error and line 3 will be executed.
D. No compilation error and line 3 will NOT be executed.
E. Only the line with the label Loop will be printed.

What two changes can you do, independent of each other, to make the following code compile:

//assume appropriate imports

class PortConnector {
public PortConnector(int port) {
if (Math.random() > 0.5) {
throw new IOException();
}
throw new RuntimeException();
}
} public class TestClass {
public static void main(String[] args) {
try {
PortConnector pc = new PortConnector(10);
} catch (RuntimeException re) {
re.printStackTrace();
}
}  }

Select 2 options

A. add throws IOException to the main method.
B. add throws IOException to PortConnector constructor.
C. add throws IOException to the main method as well as to PortConnector constructor.
D. Change RuntimeException to java.io.IOException.
E. add throws Exception to PortConnector constructor and change catch(RuntimeException re) to catch(Exception re) in the main method.

What will be the output when the following code is compiled and run?

//in file Test.java

class E1 extends Exception{ }
class E2 extends E1 { }
class Test{
public static void main(String[] args){
try{
throw new E2();
}  catch(E1 e){
System.out.println("E1");
}   catch(Exception e){
System.out.println("E");
}  finally{
System.out.println("Finally");
}
}
}

Select 1 option

A. It will not compile.
B. It will print E1 and Finally.
C. It will print E1, E and Finally.
D. It will print E and Finally.
E. It will print Finally.