Java
 

  1. Question: What will be the output of the program?
    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 caught

    B
    Compilation fails

    C
    hello throwit RuntimeException caught after

    D
    hello throwit caught finally after

    Note: 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 handled exceptions do not cause the program to stop executing.
    1. Report

  2. Question: What will be the output of the program?
    public class Test 
{  
    public static void aMethod() throws Exception 
    {
        try /* Line 5 */
        {
            throw new Exception(); /* Line 7 */
        } 
        finally /* Line 9 */
        {
            System.out.print("finally "); /* Line 11 */
        } 
    } 
    public static void main(String args[]) 
    {
        try 
        {
            aMethod();  
        } 
        catch (Exception e) /* Line 20 */
        {
            System.out.print("exception "); 
        } 
        System.out.print("finished"); /* Line 24 */
    } 
}

    A
    finally

    B
    exception finished

    C
    finally exception finished

    D
    Compilation fails

    Note: This is what happens: (1) The execution of the try block (line 5) completes abruptly because of the throw statement (line 7). (2) The exception cannot be assigned to the parameter of any catch clause of the try statement therefore the finally block is executed (line 9) and "finally" is output (line 11). (3) The finally block completes normally, and then the try statement completes abruptly because of the throw statement (line 7). (4) The exception is propagated up the call stack and is caught by the catch in the main method (line 20). This prints "exception". (5) Lastly program execution continues, because the exception has been caught, and "finished" is output (line 24).
    1. Report

  3. Question: What will be the output of the program?
    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() {} 
}

    A
    AC

    B
    BC

    C
    ACD

    D
    ABCD

    Note: There is no exception thrown, so all the code with the exception of the catch statement block is run.
    1. Report

  4. Question: What will be the output of the program?
    public class X 
{  
    public static void main(String [] args) 
    {
        try 
        {
            badMethod(); /* Line 7 */
            System.out.print("A"); 
        } 
        catch (Exception ex) /* Line 10 */
        {
            System.out.print("B"); /* Line 12 */
        } 
        finally /* Line 14 */
        {
            System.out.print("C"); /* Line 16 */
        }  
        System.out.print("D"); /* Line 18 */
    } 
    public static void badMethod() 
    {
        throw new RuntimeException(); 
    } 
}

    A
    AB

    B
    BC

    C
    ABC

    D
    BCD

    Note: (1) A RuntimeException is thrown, this is a subclass of exception. (2) The exception causes the try to complete abruptly (line 7) therefore line 8 is never executed. (3) The exception is caught (line 10) and "B" is output (line 12) (4) The finally block (line 14) is always executed and "C" is output (line 16). (5) The exception was caught, so the program continues with line 18 and outputs "D".
    1. Report

  5. Question: What will be the output of the program?
    public class MyProgram 
{
    public static void main(String args[])
    {
        try 
        {
            System.out.print("Hello world ");
        }
        finally 
        {
            System.out.println("Finally executing ");
        }
    }
}

    A
    Nothing. The program will not compile because no exceptions are specified.

    B
    Nothing. The program will not compile because no catch clauses are specified.

    C
    Hello world.

    D
    Hello world Finally executing

    Note: Finally clauses are always executed. The program will first execute the try block, printing Hello world, and will then execute the finally block, printing Finally executing. Option A, B, and C are incorrect based on the program logic described above. Remember that either a catch or a finally statement must follow a try. Since the finally is present, the catch is not required.
    1. Report

  6. Question: What will be the output of the program?
    class Exc0 extends Exception { } 
class Exc1 extends Exc0 { } /* Line 2 */
public class Test 
{  
    public static void main(String args[]) 
    { 
        try 
        {  
            throw new Exc1(); /* Line 9 */
        } 
        catch (Exc0 e0) /* Line 11 */
        {
            System.out.println("Ex0 caught"); 
        } 
        catch (Exception e) 
        {
            System.out.println("exception caught");  
        } 
    } 
}

    A
    Ex0 caught

    B
    exception caught

    C
    Compilation fails because of an error at line 2.

    D
    Compilation fails because of an error at line 9.

    Note: An exception Exc1 is thrown and is caught by the catch statement on line 11. The code is executed in this block. There is no finally block of code to execute.
    1. Report

  7. Question: What is the name of the method used to start a thread execution?

    A
    init();

    B
    start();

    C
    run();

    D
    resume();

    Note: Option B is Correct. The start() method causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread. Option A is wrong. There is no init() method in the Thread class. Option C is wrong. The run() method of a thread is like the main() method to an application. Starting the thread causes the object's run method to be called in that separately executing thread. Option D is wrong. The resume() method is deprecated. It resumes a suspended thread.
    1. Report

  8. Question: Which two are valid constructors for Thread? Thread(Runnable r, String name) Thread() Thread(int priority) Thread(Runnable r, ThreadGroup g) Thread(Runnable r, int priority)

    A
    1 and 3

    B
    2 and 4

    C
    1 and 2

    D
    2 and 5

    Note: (1) and (2) are both valid constructors for Thread. (3), (4), and (5) are not legal Thread constructors, although (4) is close. If you reverse the arguments in (4), you'd have a valid constructor.
    1. Report

  9. Question: Which three are methods of the Object class? notify(); notifyAll(); isInterrupted(); synchronized(); interrupt(); wait(long msecs); sleep(long msecs); yield();

    A
    1, 2, 4

    B
    2, 4, 5

    C
    1, 2, 6

    D
    2, 3, 4

    Note: (1), (2), and (6) are correct. They are all related to the list of threads waiting on the specified object. (3), (5), (7), and (8) are incorrect answers. The methods isInterrupted() and interrupt() are instance methods of Thread. The methods sleep() and yield() are static methods of Thread. D is incorrect because synchronized is a keyword and the synchronized() construct is part of the Java language.
    1. Report

  10. Question: 
    class X implements Runnable 
{ 
    public static void main(String args[]) 
    {
        /* Missing code? */
    } 
    public void run() {} 
}
    Which of the following line of code is suitable to start a thread ?

    A
    Thread t = new Thread(X);

    B
    Thread t = new Thread(X); t.start();

    C
    X run = new X(); Thread t = new Thread(run); t.start();

    D
    Thread t = new Thread(); x.run();

    Note: Option C is suitable to start a thread.
    1. Report
First7891011Last
/14
Copyright © 2025. Powered by Intellect Software Ltd