1  public class Derived extends Demo {
2    int L, M, N;
3    public Derived(int x, int y) {
4        M = x; N = y;
5    }
6    public Derived(int x) {
7        super(x);
8    }
9  }

public void setCalorieContent(float f)

Exception
    +-- RuntimeException
            +-- IndexOutOfBoundsException
                    +-- ArrayIndexOutOfBoundsException
                    +-- StringIndexOutOfBoundsException

1  public boolean strCvrt(String s){
2	try {
3		factor = Double.valueOf(s).doubleValue();
4		return (true);
5	} catch(NumberFormatException e) {
6		System.out.println("Bad Number " + s);
7	} finally {
8		System.out.println("Finally");
9	}
10	return (false);
11  }

XXXX x; // variable x is declared and initialized here

switch(x) {
	case 100: 
		System.out.println("One Hundred");
		break;
	case 200: 
		System.out.println("Two Hundred");
		break;
	case 300: 
		System.out.println("Three Hundred");
		break;
}

1  public class Base {
2	private static final int ID = 3;
3	private String name;
4	public void methodA(final int nn) {
5		int serialN = 11;
6		class inner {
7			void showResult() {
8				System.out.println("Result = " + XX);
9			}
10		} // inner
11		new inner();
12	} // methodA
13  }

1  public class Logic {
2	static int minusOne = -1;
3	static public void main(String[] arguments) {
4		int N = minusOne >> 31;
5		System.out.println("N = " + N);
6	}
7  }

	public class AssertTest
	{
		public void methodA(int i)
		{
			assert i >= 0 : methodB();
			System.out.println(i);
		}
	
		public void methodB()
		{
			System.out.println("The value must not be negative");
		}

		public static void main(String args[])
		{
			AssertTest test = new AssertTest();
			test.methodA(-10); 
		}	
	}

public class Static
{
	static
	{
		int x = 5;
	}

	static int x,y;
	public static void main(String args[])
	{
        		x--;
		myMethod();
        		System.out.println(x + y + ++x);
	}

	public static void myMethod()
	{
		 y = x++ + ++x;
	}
}

1.    boolean a = true;
2.    boolean b = false;
3.    boolean c = true;
4.    if (a == true)
5.    if (b == true)
6.    if (c == true) 
7.		System.out.println("Some things are true in this world");
8.    else      
9.		System.out.println("Nothing is true in this world!");
10.    else if (a && (b = c))
11.		System.out.println("It's too confusing to tell what is true and what is false");
12.    else   
13.	 	System.out.println("Hey this won't compile");

interface MyInterface
{

}
public class MyInstanceTest implements MyInterface
{
	static String s;

	public static void main(String args[])
	{
		MyInstanceTest t = new MyInstanceTest();

		if(t instanceof MyInterface)
		{
			System.out.println("I am true interface");
		}
		else 
		{
			System.out.println("I am false interface");
		}

		if(s instanceof String)
		{
			System.out.println("I am true String");
		}
		else 
		{
			System.out.println("I am false String");
		}
	}	
}

public class Ternary
{
	public static void main(String args[])
	{
		int a = 5;
		System.out.println("Value is - " + ((a < 5) ? 9.9 : 9));
	}
}

A: StringBuffer sb1 = "abcd"; 
B: Boolean b = new Boolean("abcd"); 
C: byte b = 255; 
D: int x = 0x1234; 
E: float fl = 1.2;

class MyThread extends Thread
{
	public void run()
	{
		System.out.println("MyThread: run()");
	}

	public void start()
	{
		System.out.println("MyThread: start()");
	}
}

class MyRunnable implements Runnable
{
	public void run()
	{
		System.out.println("MyRunnable: run()");
	}

	public void start()
	{
		System.out.println("MyRunnable: start()");
	}
}

public class MyTest 
{
	public static void main(String args[])
	{
		MyThread myThread  =  new MyThread();
		MyRunnable myRunnable = new MyRunnable();
		Thread thread  =  new Thread(myRunnable);
		myThread.start();
		thread.start();
	}
}

// Filename; SuperclassX.java
package packageX;

public class SuperclassX
{
	protected void superclassMethodX()
	{
	}
	int superclassVarX;
}


// Filename SubclassY.java
1.	package packageX.packageY;
2.	
3.	public class SubclassY extends SuperclassX
4.	{
5.		SuperclassX objX = new SubclassY();
6.		SubclassY objY = new SubclassY();
7.		void subclassMethodY()
8.		{
9.			objY.superclassMethodX();
10.			int i;
11.			i = objY.superclassVarX;
12.		}	
13.	}

      public class Test{ 
         public static void main(String[] args) { 
            Object a = new Object();  // the object original referenced by object reference a
            Object b = new Object(); 
            Object c = new Object(); 
            Object d = new Object(); 

            d=c=b=a; 
            d=null; 
         } 
      }

abstract class TestClass 
{
   transient int j;
   synchronized int k;

   final void TestClass(){}
   static void f(){} 
}

public class MyFor {
    public static void main(String argv[]){
     	int i;
      	int j;
    outer:
      	for (i=1;i <3;i++)
	    inner:
	for(j=1; j<3; j++) {
	    if (j==2) 
		continue outer;
	    System.out.println("Value for i=" + i + " Value for j=" +j);
	}
    }
}

public class TestClass 
{
   public static void main(String args[ ] ) 
   {
      A o1 = new C( );
      B o2 = (B) o1;
      System.out.println(o1.m1( ) );
      System.out.println(o2.i );
   }
}

class A { int i = 10;  int m1( ) { return i; } } 
class B extends A { int i = 20;  int m1() { return i; } } 
class C extends B { int i = 30;  int m1() { return i; } } 

Consider the following lines of code:

   System.out.println(null + true); //1
   System.out.println(true + null); //2
   System.out.println(null + null); //3

Which of the following statements are correct?  Select 1 correct option

/* this comment /* // /** is not valid */

class Outer
{
    private void Outer() { }
    protected class Inner
    {
    }
}

public float parseFloat( String s )
{
   float f = 0.0f; 
   try
   {
      f = Float.valueOf( s ).floatValue();
      return f ; 
   }
   catch(NumberFormatException nfe)   
   {
      f = Float.NaN ;  
      return f; 
   }
   finally 
   {
      f = 10.0f;
      return f;
   }
}

int i = 10;
System.out.println( i<20 ? out1() : out2() );

class SelfReferencingClassToPreventGC
{
    private SelfReferencingClassToPreventGC a;
    Object obj = new Vector();
    public SelfReferencingClassToPreventGC()
    {    
        a = this; //reference itself to make sure that this is not garbage collected.
    }

    public void finalize()
    {
        System.out.println("Object GCed");
    }
}

public class TestClass
{
      public static void main(String[] args) throws Exception
      {
            int a = Integer.MIN_VALUE;
            int b = -a;
            System.out.println( a+ "   "+b);
      }
}

void m1() throws Exception
{
   try
   {
      // line1 
   }
   catch (IOException e)
   {
       throw new SQLException();
   }
   catch(SQLException e)
   {
       throw new InstantiationException();
   }
   finally 
   {
      throw new CloneNotSupportedException()   // this is not a RuntimeException.
   }
}

A
|
+----B1, B2
    |
    +----C1, C2

class InOut{
String s= new String("Between");
       public void amethod(final int iArgs){
       int iam;
              class Bicycle{
                       public void sayHello(){
                        //Here
                        }//End of bicycle class
              }
       }//End of amethod
       public void another(){
          int iOther;
       }
}

class A extends Thread
{
    static protected int i = 0;
    public void run()
    {
        for(; i<5; i++) System.out.println("Hello");  
    }
}

public class TestClass extends A
{
    public void run()
    {
        for(; i<5; i++)    System.out.println("World");
    }

    public static void main(String args []) 
    {
        Thread t1 = new A();
        Thread t2 = new TestClass();
        t2.start(); t1.start();
    }
}

// file A.java
package p1; 
public class A
{
      protected int i = 10;
      public int getI()
      { 
          return i;
      }
}

// file B.java
package p2;
import p1.*;
public class B extends p1.A
{
   public void process(A a)
   {
      a.i = a.i * 2;
   }

   public static void main(String[] args)
   {
      A a = new B();
      B b = new B();
      b.process(a);
      System.out.println( a.getI() );
   }
}

public class Arg{
    String[] MyArg;
    public static void main(String argv[]){
        MyArg=argv;
    }

    public void amethod(){
	System.out.println(argv[1]);
    }
}

public class TechnoSample {
  public static void main(String[] args) {
    int a = 2, b = 3, c = 4;

    a = b++ + c;
    c += b;
    b += a * 2;

    System.out.println("a: " + a + " b: " + b + " c: " + c); 
  }
}

abstract class TestClass 
{
   transient int j;
   synchronized int k;

   final void TestClass(){}
   static void f() 
   {
      k = j++;
   } 
}

class TechnoSample 
{
   public static void main(String[] args) 
   {
      int i = 4;
      int ia[][][] = new int[i][i = 3][i];
      System.out.println(ia.length + ", " + ia[0].length+", "+ ia[0][0].length);
   }
}

//in file A.java
package p1; 
public class A
{
      protected int i = 10;
      public int getI() { return i; }
}

//in file B.java
package p2;
import p1.*;
public class B extends p1.A
{
   public void process(A a)
   {
      a.i = a.i*2;
   }
   public static void main(String[] args)
   {
      A a = new B();
      B b = new B();
      b.process(a);
      System.out.println(a.getI());
   }
}