1.  public abstract class Prod {
    2.    public abstract void prmth1();
    3.    public static void prmth2() {
    4.      int mth2 = 30;
    5.      System.out.println("prmth2 = " + mth2);
    6.    }
    7.    public abstract void prmth3();
    8.  }

What is the result?

 
    1.  public class ClassA {
    2.    public static void main(String [] args) {
    3.   
    4.      switch(x) {
    5.        default:
    6.        System.out.println("Here it is.");
    7.      }
    8.    }
    9.  }

The ClassA class can be compiled successfully by inserting one of three possible
options on line 3. When inserted separately, which three will allow compilation
to succeed? (Choose three.)

 
    1.  public class NewGarb {
    2.    public static Object getIt() {
    3.      Object rg = new Integer(3);
    4.      Object dg[][] = new Object[1][2];
    5.      dg[0][1] = rg;
    6.      dg[0][0] = rg;
    7.      rg = null;
    8.      return rg;
    9.    }
    10.  }

Which statement is true?

 
    1.  public class SetFor {
    2.
    3.    public static void main(String [] args) {
    4.
    5.      System.out.println("You will need to use " + c);
    6.    }
    7.  }

Which two additions will individually allow compilation to succeed? (Choose two.)

 
 1.  public class TeSet {
 2.    public static void main(String args[]) {
 3.      int m = 2;
 4.      int p = 1;
 5.      int t = 0;
 6.      for(;p < 5;p++) {
 7.        if(t++ > m) {
 8.          m = p + t;
 9.        }
10.      }
11.      System.out.println("t equals " + t);
12.    }
13.  }

What is the resulting value of t?

 
 1.  class IntType {
 2.    public String getType(String a, int b, char c) {
 3.      String holdit1 = new String();
 4.      holdit1 = a;
 5.      return holdit1;
 6.    }
 7.  }
 8.
 9.  class OverType extends IntType {
10.
11.      String holdit2 = new String();
12.      holdit2 = holdit2.concat("This is ").concat(a);
13.      return holdit2;
14.    }
15.
16.    public static void main(String args[]) {
17.      OverType ot = new OverType();
18.      String x = new String("x");
19.      int y = 1;
20.      char z = 'b';
21.      System.out.println(ot.getType(x, y, z));
22.    }
23.  }

When inserted on line 10, which line will override the getType method, allowing compilation to succeed and the output "This is x"?

 
 1.  public class MyThread implements Runnable {
 2.    private String holdA = "This is ";
 3.    private int[] holdB = {1,2,3,4,5,6,7,8,9,10};
 4.
 5.    public static void main(String args[]) {
 6.      MyThread z = new MyThread();
 7.      (new Thread(z)).start();
 8.      (new Thread(z)).start();
 9.    }
10.
11.    public synchronized void run() {
12.      for(int w = 0;w < 10;w++) {
13.        System.out.println(holdA + holdB[w] + ".");
14.      }
15.    }
16.  }

What is the result?

 
 1.  import java.awt.*;
 2.  
 3.  public class Birthdays extends Frame {
 4.    Birthdays() {
 5.      super("Birthday Reminder");
 6.      String lblsP1[] = {"Name:", "Birthday:", "Address:"};
 7.      String butnsP2[] = {"Add", "Save", "Exit"};
 8.      Panel panelTop = new Panel();
 9.      Panel panelBot = new Panel();
10.      panelTop.setLayout(new GridLayout(3,2,3,3));
11.      for(int x = 0; x < lblsP1.length; x++) {
12.        panelTop.add(new Label(lblsP1[x]));
13.        panelTop.add(new TextField());
14.      }
15.      for(int y = 0; y < butnsP2.length; y++) {
16.        panelBot.add(new Button(butnsP2[y]));
17.      }
18.      add(panelTop, BorderLayout.NORTH);
19.      add(panelBot, BorderLayout.SOUTH);
20.    }
21.  }

Which main method should you add to the Birthdays class to allow the program to compile and run with all defined fields properly displayed?

 
 1.  public class GetIt {
 2.    public static void main(String args[]) {
 3.      double x[] = {10.2, 9.1, 8.7};
 4.      int i[] = new int[3];
 5.      for(int a = 0;a < (x.length);a++) {
 6.
 7.        System.out.println(i[a]);
 8.      }
 9.    }
10.  }

The GetIt class should print the following:
    11
    10
    9

Which line should you insert on line 6 to accomplish this?

 
1. public class Test1 {
2.   public float aMethod(float a, float b) {
3.   }
4.
5. }

Which of the following methods would be legal if added (individually) at line 4?

 
1. public class Test1 {
2.   public float aMethod(float a, float b)
       throws IOException {
3.   }
4. }

1. public class Test2 extends Test1 {
2.
3. }

Which of the following methods would be legal (individually) at line 2 in class Test2?

"A pet has an owner, a registration date, and a vaccination-due date. 
A cat is a pet that has a flag indicating if it has been neutered, and a 
textual description of its markings." 

Given that the Pet class has already been defined, which of the following fields would be appropriate for inclusion in the Cat class as members?

 
 1. public class Base {
 2.   public void method(int i) {
 3.     System.out.println("Value is " + i);
 4.   }
 5. }

 1. public class Sub extends Base {
 2.   public void method(int j) {
 3.     System.out.println("This value is " + j);
 4.   }
 5.   public void method(String s) {
 6.     System.out.println("I was passed " + s);
 7.   }
 8.   public static void main(String args[]) {
 9.     Base b1 = new Base();
10.     Base b2 = new Sub();
11.     b1.method(5);
12.     b2.method(6);
13.   }
14. }

What output results when the main method of the class Sub is run?

 
1. public class Test extends Base {
2.   public Test(int j) {
3.   }
4.   public Test(int j, int k) {
5.     super(j, k);
6.   }
7. }

Which of the following are legitimate calls to construct instances of the Test class?

 
1. public class Test extends Base {
2.   public Test(int j) {
3.   }
4.   public Test(int j, int k) {
5.     super(j, k);
6.   }
7. }

Which of the following forms of constructor must exist explicitly in the definition of the Base class?

 
 1. public class Outer {
 2.   public int a = 1;
 3.   private int b = 2;
 4.   public void method(final int c) {
 5.     int d = 3;
 6.     class Inner {
 7.       private void iMethod(int e) {
 8.
 9.       }
10.     }
11.   }
12. }

Which variables may be referenced correctly at line 8?

new Outer().new Inner()

 class J {
  private static int notFinalized;
  public static int notFinalized() {return notFinalized;}
  private K k;
  private int name;
  public int name() {return name;}
  public J(K k, int i) {this.k = k; name = i; notFinalized++;}
  public void finalize() {
    synchronized (k) {
      System.out.print(name);
      notFinalized--;
      k.notify();
    }
  }
}

class K {
  private void m1() {
    J j = null;
    for (int i = 0; i < 5; i++) {
      j = new J(this, i);       // 1
    }
    Runtime.getRuntime().gc();  // 2
    synchronized (this) {
      while (J.notFinalized() > 0) {
        try {wait();} catch (InterruptedException ie) {}
      }
    }
  }
  public static void main(String[] args) {
    new K().m1();
  }
}

When the processing of line 2 begins how many objects of type J that were created at line 1 are eligible for garbage collection?

public class TechnoSample {
	public static void main(String[] args) throws Exception {
		int i=2;
		boolean b = true;
		throw new Exception("Values are:"+(b!=b)+","+(i=args.length)+","+(b=i==2));
	}
}

class A{}
class B extends A implements E{}	//line 1
class C extends A{}
class D extends B{}
interface E{}
public class Question07 {
	public static void main(String[] args) {
		A a = new D();	//line 2
		C c = new C();	//line 3
		E e = (E)a;	//line 4
		B b = (B)e;	//line 5
	}
}

 
public class TechnoSample {
	public static void main(String[] args) {
		StringBuffer buf1 = new StringBuffer("Hello W");
		addSomeStuff(buf1);
		System.out.println(buf1.toString());
	}

	public static void addSomeStuff(StringBuffer buf){
		StringBuffer b = buf.replace(6,10,"orld");
		System.out.println(b.delete(0,1).toString());
	}
}

	Hello World
        Hello World

	Hello orld
        ello orld

import java.util.*;
public class TechnoSample {
	public static void main(String[] args) {
		Vector col = new Vector();
		col.add(new Integer(1));
		col.add(new Integer("2"));
		col.add(new Float(3.2d));	//line 1
		col.add(col.elementAt(1));
		col.setElementAt(col.elementAt(2),0);
		System.out.println(col);
	}
}

public class TechnoSample {
	public static void main(String[] args) {
		String s = "\u0048ello\u000aWorld!";
		System.out.println(s);
	}
}

	Hello
        World!

public class TechnoSample {
	public static void main(String[] args) {
		int i = 2;
		try {
			if((i/=(int)Math.floor(Math.random())) > 1)
				System.out.println("No arithmetic exception");
		} catch (ArithmeticException ae){
			System.err.println("Arithmetic exception caught");
		}
	}
}

public class TechnoSample {
	public static void main(String[] args) throws Exception{
		Thread t1 = new Thread(getRunnable(3));
		Thread t2 = new Thread(getRunnable(4));
		t1.join();
		System.out.println("End");
	}

	public static Runnable getRunnable(final int id){
		return new Runnable(){
			public void run(){
				for(int i = 0; i < id; i++){
					System.out.print(" "+i);
				}
			}
		};
	}
}

 
public class TechnoSample {
	public static void main(String[] args){
		for(int i = 0;  i < 10; i++){
			System.out.println(getPrimitive(127));	//line 1
		}
	}
	public static int getPrimitive(byte b){	//line 2
		return (short)(Math.random()*b);	//line 3
	}
}

  
public class TechnoSample  {
	public static void main(String[] args) {
		TechnoSample myref = new TechnoSampleSub();
		try{
			myref.test();
		}catch(Exception e){}
	}
	void test() throws Exception{
		System.out.println("In TechnoSample");
		throw new Exception();
	}
}
class TechnoSample Sub extends TechnoSample {
	void test() {
		System.out.println("In TechnoSampleSub");
	}
}

import java.util.Date;
      
public class Example {
        public static void main(String args[]) {
                Date d1 = new Date (99, 11, 31);
                Date d2 = new Date (99, 11, 31);
                method(d1, d2);
                System.out.println("d1 is " + d1 
                                + "\nd2 is " + d2);
        }
      
        public static void method(Date d1, Date d2) {
                d2.setYear (100);
                d1 = d2;
        }
}

Which one or more of the following correctly describe the behavior when this program is compiled and run?

d1 is Fri December 31 00:00:00 GMT 1999 d2 is Sun December 31 00:00:00 GMT 2000