Test1

1.执行如下代码后输出结果为（C ）
public class Test {
public static void main(String[] args) {
System.out.println("return value of getValue(): " + getValue());
}
public static int getValue() {
int i = 1;
try {
i = 4;
} finally{
i++;
return i;
}
}
}
A return value of getValue(): 1
B return value of getValue(): 4
C return value of getValue(): 5
D 其他几项都不对

解析：c.try只适合处理运行时异常，try+catch适合处理运行时异常+普通异常。也就是说，如果你只用try去处理普通异常却不加以catch处理，编译是通不过的，因为编译器硬性规定，普通异常如果选择捕获，则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定，所以catch可以省略，

2.下面关于静态方法说明正确的是
A.在静态方法中可用this来调用本类的类方法
B.在静态方法中调用本类的静态方法时可直接调用
C.在静态方法中只能调用本类中的静态方法
D.在静态方法中绝对不能调用实例方法

解析:B ,静态方法中不能调用非静态方法。相反，静态方法中只能调用静态方法。也可以在静态方法中创建对象，通过对象.调用非静态方法。

3.在软件质量因素中，软件在异常条件下仍能运行的能力成为软件的___B__。
A.安全性
B.健壮性
C.可用性
D.可靠性

解析B：健壮性是指软件对于规范要求以外的输入情况的处理能力。异常条件下仍能运行是说明健壮性
健壮性是指在异常情况下，软件能够正常运行的能力。 正确性描述软件在需求范围之内的行为。
安全性指的是信息安全。可靠性是指在一定的环境下，在给定的时间内，系统不发生故障的概率

4.下列运算符中优先级最高的是?B
A.<
B.+
C.&&
D.!=

单目运算符：+，-，++，–
算数运算符：+，-，*，/，%
移位运算符：<<,>>
关系运算符：>,<,>=,<=,==,!=
位运算符：&，|，~，^,
逻辑运算符：&&，||
三目运算符：表达式1？表达式2：表达式3;
赋值运算符：=等
单目>算数运算符>移位>比较>按位>逻辑>三目>赋值

5.设某数据结构的二元组形式表示为 A=(D ， R) ， D={01 ， 02 ， 03 ， 04 ， 05 ， 06 ， 07 ， 08 ， 09} ， R={r} ， r={<01 ， 02> ， <01 ， 03> ， <01 ， 04> ， <02 ， 05> ， <02 ， 06> ， <03 ， 07> ， <03 ， 08> ， <03 ， 09>} ，则数据结构A是（B） 。
A.线性结构
B.树型结构
C.物理结构
D.图型结构

解析：数据结构的二元组形式为：DS = (D, S)。
其中 D 是数据元素的集合； S 是 D 中数据元素之间的关系集合，并且数据元素之间的关系是使用序偶来表示的。
D = {01, 02, 03, 04, 05, 06}，S = {<01,02>, <01,03>, <02,04>, <02,05>, <03,06>}
除了一个数据元素（元素 01）以外每个数据元素有且仅有一个直接前驱元素，但是可以有多个直接后续元素。这种数据结构的特点是数据元素之间是 1 对 N 的联系，即树结构。
4.D = {01, 02, 03, 04, 05}
S = {<01,02>, <01,05>, <02,01>, <02,03>, <02,04>, <03,02>,<04,02>, <04,05>, <05,01>, <05,04>}:
树在形态和定义上都可以算作是特殊的图

6.下列数组定义错误的是（ ）
A.int arr[2][3] = {{1,2},{3,4},{5,6}};
B.int arr[][3] = {{1,2,3},{4,5,6}};
C.int arr[10]={,10};
D.int arr[10]={10};

解析：java中数组的定义方式：1.数组类型[] 数组名=new 数组类型[数组长度];
2.数组类型[] 数组名={数组0,数组1,数组2,数组3,…};
3.数组类型[] 数组名=new 数组类型[]{数组0,数组1,数组2,…};

7A
class Value{
public int i=15;
}
public class Test{
public static void main(String argv[]){
Test t=new Test( );
t.first( );
}

public void first( ){
int i=5;
Value v=new Value( );
v.i=25;
second(v,i);
System.out.println(v.i);
}

public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value( );
v = val;
System.out.println(v.i+" "+i);
}
}
A.15 0 20
B.15 0 15
C.20 0 20
D.0 15 20

解析：A。当主函数运行时创建Test的实例化对象，调用Test类的first方法。在first方法中创建了Value的实例化对象传入参数调用第二个方法第二个方法中又实例化了一个Value并且赋给了v(本次操作是对象的引用)最后打印了Value类中i的值，i为常量,所以为15.打印的i为second（）方法的局部变量 i=0,
这个val其实相当于是一个指向原来first中的V这个对象的指针，也就是对v对象的引用而已。但是引用是会改变所指的地址的值的。
所以在second中当val.i= 20的时候，就把原来first中的v的i值改为20了。接下来，又把tmp指向了新建的一个对象，所以在second中的val
现在指的是新的对象val，i值为15.

8.Test.main()函数执行后的输出是（B ）
class Test {
public static void main(String[] args) {
System.out.println(new B().getValue());
}
static class A {
protected int value;
public A (int v) {
setValue(v);
}
public void setValue(int value) {
this.value= value;
}
public int getValue() {
try {
value ++;
return value;
} finally {
this.setValue(value);
System.out.println(value);
}
}
}
static class B extends A {
public B () {
super(5);
setValue(getValue()- 3);
}
public void setValue(int value) {
super.setValue(2 * value);
}
}
}
A.6 7 7
B.22 34 17
C.22 74 74
D.11 17 34

解析：创建一个B对象调用B的构造方法通过隐性调用A的构造方法使value=5.
执行对象实例化过程中遵循多态特性 ==> 调用的方法都是将要实例化的子类中的重写方法，只有明确调用了super.xxx关键词或者是子类中没有该方法时，才会去调用父类相同的同名方法。
new B()构造一个B类的实例.调用父类A带参的构造函数，该构造函数调用setValue(v)，这里有两个注意点一是虽然构造函数是A类的构造函数，但此刻正在初始化的对象是B的一个实例，因此这里调用的实际是B类的setValue方法…

9下列关于JAVA多线程的叙述正确的是（B C）
A.调用start()方法和run()都可以启动一个线程
B.CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
C.Callable类的call()方法可以返回值和抛出异常
D.新建的线程调用start()方法就能立即进行运行状态

解析：A. start()方法来启动线程，真正实现了多线程运行，调用了run()方法；run()方法当作普通方法的方式调用。
B. CyclicBarrier让一组线程等待其他线程；CountDownLatch让一组线程等待某个事件发生。（资料搜素）
C. Callable能够抛出checked exception。（资料搜素）
D. start()方法让thread进去可运行状态（runnable），等待获取CPU的使用权。

10.关于下面程序，哪些描述是正确的: ( )
public class While {
public void loop() {
int x= 10;
while ( x ) {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}
A.行1有语法错误
B.行4有语法错误
C.行5有语法错误
D.行6有语法错误
E.行2有语法错误,loop是关键字
F.程序能够正常编译和运行

解析：loop 不是java 的关键字
问题出在 while( boolean ) x 是一个int 形的变量 不是Boolean 值 所有编译不通过.

编程题：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解析：在一个传入的数组中找到两个数字之和为传入的数字，：遍历这个数组分为两层循环.第一层开始找。在第二层循环中找到一个数字为传入数字掉第一个循环数，将两个数的下标放进数组中返回。在主函数中调用。

	public int[] twoSum(int[] nums, int target) {
		for (int i = 0; i < nums.length; i++) {
			for (int j = i + 1; j < nums.length; j++) {
				if (nums[j] == target - nums[i]) {
					return new int[] { i, j };
				}
			}
		}
		throw new IllegalArgumentException("No two sum solution");
	}
	public static void main(String[] args) {
		Test t = new Test();
		int[] nums = { 2, 7, 11, 15 };
		int target = 9;
		int[] a = t.twoSum(nums, target);
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
}

运行结果：

0
1