A.double getSalesAmount（） { return 1230.45； }
B.public double getSalesAmount（） { return 1230.45； }
C.private double getSalesAmount（） { return 1230.45； }
D.protected double getSalesAmount（） { return 1230.45； }

A.int foo（） { /* more code here */ }
B.void foo（） { /* more code here */ }
C.public void foo（） { /* more code here */ }
D.private void foo（） { /* more code here */ }
E.protected void foo（） { /* more code here */ }

A.Compilation fails.
B.An exception is thrown at runtime.
C.The code executes normally and prints "bar".
D.The code executes normally， but nothing prints.

A.Cat
B.Dog
C.Compilation fails.
D.The code runs with no output.
E.An exception is thrown at runtime.

A.The Thread.sleep（） method can take t1 as an argument.
B.The Object.notify（） method can take t1 as an argument.
C.The Thread.yield（） method can take t1 as an argument.
D.The Thread.setPriority（） method can take t1 as an argument.
E.The Object.notify（） method arbitrarily chooses which thread to notify.

A.move the line 12 print statement into the foo（） method
B.change line 7 to public synchronized void go（） {
C.change the variable declaration on line 2 to private volatile int x；
D.wrap the code inside the foo（） method with a synchronized（ this ） block

A.private synchronized Object o；
B.void go（） {synchronized（） { /* code here */ }
C.public synchronized void go（） { /* code here */ }
D.private synchronized（this） void go（） { /* code here */ }
E.void go（） {synchronized（Object.class） { /* code here */ }
F.void go（） {Object o = new Object（）；synchronized（o） { /* code here */ }

A.Compilation fails.
B.An exception is thrown at runtime.
C.The code executes and prints "StartedComplete".
D.The code executes and prints "StartedComplete0123".
E.The code executes and prints "Started0123Complete".

A.Arrays.sort（s）；
B.s = new TreeSet（s）；
C.Collections.sort（s）；
D.s = new SortedSet（s）；

A.2 -1
B.2 -4
C.2 -5
D.3 -1
E.3 -4