一：选择题【有四个选项，只有一个选项正确，每道题1.5分，共20道，总计30分】
1：下面的表达式错误的是
A: float f=(1.9 + 0.1)/(int)1.0
B: float f=1.0F
C: float f=(float)1.0F
D: float f=(int)(0.73+0.27);
解答：【A】因为小数默认是double类型的，那么float f = (1.9+0.1)/(int)1.0则是double类型的，修改为float f = (1.9f+0.1f)/(int)1.0才正确.
2：设x和y均为int型变量,则以下语句:x+=y,y=x-y;x-=y;的功能是
A：把x和y按从大到小排列
B：把x和y按从小到大排列
C：无确定结果
D：交换x和y中的值
解答：【D】直接带两个数字进去进行试验即可
3：请写出下面程序运行的结果（）
int x = 0;
int y = 1;
int a = x++ + ++x;
int b = y– – –y;
System.out.println(++a + b++);
A：3 B：4 C：5 D：6
解答：【B】放到程序里运行一次就OK了，结果是4 ；int a
= x++ + ++x;后a = 2;
int b = y– – –y;后b = 0; ++符号在参数之前的是先加了再计算使用，符号在后面的是计算过后再加。
4：选择下列程序运行的结果
int total = 0;
for (int i = 0, j = 5; total < 10 || j > 3; ++i, –j) {
total += (i + j);
System.out.println(total );
}
A：结果为 5 ，因为一个i自加，一个j自减抵消等于没有自加
B：结果为 10，因为正常运算了
C：有语法错误，不能写多个变量
D：有语法错误，条件表达式不能写多个
解答：【D】条件表达式不能写多个，-j处会报错。
5:请问总共创建了多少个对象？
String aa,b,c;
aa=”bb”;
b=”dd”+aa;
c=”cc”+b+aa;
StringBuffer d = new StringBuffer(c);
A: 4 B: 5 C: 7 D: 8
解答：【C】这种问题真够纠结的！！答案我也做不对！（有其他解可以一起讨论）
“bb”创建字符对象 aa创建了引用对象
“dd”创建字符对象 b创建了引用对象
“cc”创建字符对象 c创建了引用对象
加上StringBuffer 对象
6:接口A中有2个方法，接口B中有2个方法，以下正确的是 ( )
A:若接口C继承A,B两个接口，则C一定继承了四个方法
B:若类C实现接口A,B，则C中必须至少实现A、B中各一个方法
C:若类C要继承接口A,B，则必须要定义接口D来继承接口A、B，由类C实现接口D,才能达到目的
D:若抽象的接口C继承了接口A，B；抽象的D类实现C接口，此时必须要实现累加接口中的所有方法
解答：【 】
7：关于类，抽象，接口，继承综合说法错误的是？
A:类与类之间有关联，继承，聚合的关系；
B:抽象类可以继承实例类，抽象类可以实现接口，抽象接口可以继承多个接口
C:抽象类是类和接口的并集与接口继承的补集
D:在应用开发中，功能类的继承是平行结构，实现功能的接口是树型结构
解答：【 】
8:请判断下面程序运行的结果：
public class ParamTest{
int num = 1;
public void change() {
num = 2;
}
public void change(int num) {
num = 3;
}
public void change(ParamTest pt) {
pt.num = 4;
}
public static void main(String[] args) {
ParamTest pt = new ParamTest();
int num = 5;
pt.change();
System.out.println("1->:" + pt.num);
pt.change(num);
System.out.println("2->:" + pt.num);
pt.change(pt);
System.out.println("3->:" + pt.num);
}
}
A: B: C： D：
1->:1 1->:2 1->:2 1->:2
2->:5 2->:5 2->:2 2->:5
3->:4 2->:5 3->:4 3->:4
解答：【C】，该题考查的主要目的是变量的作用域，pt.num 和在主函数中的num不是同一个对象。所以这点要区分清楚。pt.num一直是指ParamTest类中的num的值，一直关注这个值得变化即可得到答案。
9：下面方法不可以共存的是：（）
已知：
class A {
public A() {
}
public void A() {
}
public void A(int x) {
}
}
class B extends A {
//填入一个方法
}
A：public void A(){}
B：public voidA(int x, int y) {}
C：public intA(int x, char y) {
return x + y;
}
D：public String A(int x){
return “hello”+x;
}
解答： 选D，因为B是继承的父类A，那么A选项是覆盖原来方法，B,C是子类自己新增的方法，D选项错误的原因是，没有办法区分和父类的方法。因为名称和传入的参数都一样，在调用的时候无法区分，不能靠返回值来区别。
10、运行下面程序段：
public class Foo {
int value;
Foo(int value) {
this.value = value;
}
}
Foo[] a1 = { new Foo(1), new Foo(2), newFoo(3) };
Foo[] a2 = new Foo[a1.length];
System.arraycopy(a1, 0, a2, 0, a1.length);
System.out.println((a1 == a2) + "," + (a1[1] == a2[1]));
控制台输出的结果是( )。
A. false,false B. false,true C. true,true D. true,false
解答：答案为B，首先要理解System.arraycopy函数的作用，建议参考JDK详细的看一看。这里就简单解释一下，这个函数就是将一个数组赋值到另外一个数组，从0号位置开始，a1.length位置结束。其实这里就是价格a2数组的内容对应复制给a1，好了那么来看看打印，a1==a2，必然是false，因为是两个不同的对象，虽然数组内容是一样的，但是是两个完全不一样的对象，在内存中是两个不同的地址,所以为false.而a1[1]==a2[1]，因为刚才复制了，他们指向的是同一个值，他们的值是一样的，所以为true。
11：哪种说话阐明了垃圾收集和终结化机制锁承诺的行为？（）
A 对象直到没有任何引用指向自己时才会立即被销毁
B 对一个对象调用的finalize()方法永远不会多于一次
C 适用于收集的对象会最终由垃圾收集器销毁
D 对象一但适用于垃圾收集，就再无法由存活线程访问了
解答：这个不晓得
12：下面执行的结果是
static boolean loop(char c) {
System.out.print(c);
return true;
}
public static void main(String[] args) {
int i = 0;
for (loop('A'); loop('B') && (i < 2); loop('C')) {
i++;
loop('D');
}
A. ABDCBDCB
B. ABCDABCD
C. Compilation fails[编译失败].
D. An exception is thrown at runtime[抛出一个运行例外].
解答：A，运行一遍出结果。主要是了解for循环内的执行顺序即可。
13：下面异常执行的结果是：
try {
int x = 0;
float y = 0;
float z = x / y;
System.out.println("11");
try {
int a[] = new int[3];
a[3] = x;
System.out.println("22");
return;
} catch (Exception e) {
System.out.println("33");
return;
} finally {
System.out.println("44");
System.exit(0);
return;
}
} catch (ArithmeticException e) {
System.out.println("55");
return;
} finally {
System.out.println("66");
return;
}
A: B： C： D：
11 55 11 11
55 66 33 33
66 44 44
66
解答：答案选C，int a[] = new int[3]; a[3] = x;这句话就会抛出异常，因为a[3]根本就不存在，已经数组越界了。所以打印了11后会到异常打印出33，然后finally是必然会执行的，然后打印44，return，然后结束。
14：阅读下面程序段:
byte a[] = { ‘a’, 65, ‘#’, ‘B’ };
byte b[] = new byte[a.length];
System.arraycopy(a, 1, b, 1, 2);
BufferedOutputStream bos;
bos = new BufferedOutputStream(new FileOutputStream(“C:\\file.txt”));
bos.write(b, 1, 2);
bos.flush();
bos.close();
假设file.txt原先不存在，运行该程序段后，文件file.txt的内容为（）。
A. 65 B. 65# C. A# D. A
解答：答案为C，很容易选择为B，因为执行了System.arraycopy(a, 1, b, 1, 2);后b[] = {0,65,’#’,0},利用系统System打印出来的为其ASCII码，但是写入到文本中的时候则为该ASCII码对应的字符。所以65就被转换成A打印出来了。
15：假设以数组A[n]存放循环队列的元素，其头、尾指针分别为head和end。若设定尾指针指向队列中的队尾元素，头指针指向队列中队头元素的前一个位置，则当前存于队列中的元素个数为
A：(end-head-1)%n B：(end-head)%n
C：(head-end+1)%n D：(end-head+n)%n
解析：我估计选A，但不确保正确
16：对线性链表和线性表分析错误的是（）
A：线性链表分为单链表、双向链表和循环链表
B：线性链表是一种物理存储单元上连续但非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接来实现的
C：线性表插入或删除的运算效率很低。在顺序存储的线性表中，插入或删除数据元素时需要移动大量的数据元素
D：线性表的顺序存储结构不便于对存储空间的动态分配
解析：【B】线性链表是一种物理存储单元上连续，这句话是错误，线性链表是物理存储上是不连续的，但在逻辑结构上是连续的。
17：以下属于java.util包中集合类具体实现类的是？
A：Map B：Collection C：TreeMap D：SortedMap
解析：答案为C,TreeMap和HashSet是具体的实现类。需要记忆
18：下面对集合不能正确创建实例化是（）
A：List<HashMap<Number, String>> list = new LinkedList<HashMap<Number, String>>();
B：ArrayList<HashSet<String>> list = new ArrayList<HashSet<String>>();
C：TreeSet<Hashtable<String,Integer>> tree=new TreeSet<Hashtable<String,Integer>>();
D：TreeSet<ArrayList<String,Integer>> tree=new TreeSet<ArrayList<String,Integer>>();
解析：答案是D，ArrayList的参数没有这种形式的，一般ArraList的参数是一个对象或者是自己增加的一个类或者类型。这个涉及到泛型的相关知识。
19：下面可以删除list中所有的“java”的代码是：
ArrayList list = new ArrayList();
list.add(“java”);
list.add(“aaa”);
list.add(“java”);
list.add(“java”);
list.add(“bbb”);
A：
for (int i = list.size() – 1; i >= 0; i–) {
if (“java”.equals(list.get(i))) {
list.remove(i);
}
}
B：
for (int i = 0; i < list.size(); i++) {
if (“java”.equals(list.get(i))) {
list.remove(i);
}
}
C：
Iterator i = list.iterator();
while (i.hasNext()) {
if ((i.next().toString()).equals(“java”)) {
i.removeAll();
}
}
D：
Iterator i = list.listIterator();
while (i.hasNext()) {
if (((String) i.next()).equals(“Java”))
i.remove();
}
}
解析：经过试验ABD,都能够成功的删除java，只有C不可以，原因是Iterator没有removAll方法只有remove方法。
20：题示代码的功能为：将两个有序的ArrayList合并为一个有序的ArrayList。
对于两个存放Integer对象的ArrayList，
内容分别为：list1：{1,3,4,6,8} 和 list2：{2,5,9}
合并后的list3: {1,2,3,4,5,6,8,9}
……
List<Integer> list3 = new ArrayList<Integer>();
int size = list1.size() + list2.size();
for (int i = 0, j = 0, k = 0; k < size; k++) {
< 填入的代码 >
}
System.out.println(list3);
……
完成该功能应该填入的代码是( )。
A.
if (j >= list2.size() || i > list1.size():&& list1.get(i) < list2.get(j)) {
list3.add(list1.get(i++));
} else {
list3.add(list2.get(j++));
}
B.
if (j >= list2.size() || i < list1.size()&& list1.get(i) < list2.get(j)) {
list3.add(list1.get(i++));
} else {
list3.add(list2.get(j++));
}
C.
if (j >= list2.size() || i < list1.size()&& list1.get(i) > list2.get(j)) {
list3.add(list1.get(i++));
} else {
list3.add(list2.get(j++));
}
D.
if (j >= list2.size() || i < list1.size()|| list1.get(i) < list2.get(j)) {
list3.add(list1.get(i++));
} else {
list3.add(list2.get(j++));
}
二：简答题【本环节中每道题3分，共5道，总计15分】
1:String 和StringBuffer有什么差别？在什么情况下使用它们？【3分】
答：JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。
2：new一个类对象和使用类名创建一个对象有什么区别？二者使用时应该注意什么？【3分】
答：
存储空间上不同。
new出来的在堆上
直接定义的在栈上
当变量个数较少且数量确定时可以直接定义
当数量较多或变量个数不能确定时用new
如果你有一个对话框类CMyDlg；
你这样用：CMyDlg dlg;
dlg.Create();
建一非模式对话框，函数一结束，dlg被收回了，这个对话框一闪而过。
这样用： CMyDlg *dlg=new CMyDlg;
dlg->Create();
函数结束了，dlg还在。这个非模式对话框还在。
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）― 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） ― 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）―，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放
4、文字常量区 ―常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区―存放函数体的二进制代码。
3：在异常当中 throw和throws 有什么区别和联系？【3分】
答：
仔细一看就知道了： public Test() throws RepletException { try { System.out.println("Test this Project!") } catch (Exception e) { throw new Exception(e.toString()); } } throws是用来声明一个方法可能抛出的所有异常信息 throw则是指抛出的一个具体的异常类型。 通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个具体的异常信息。 throws通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法； throw则需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。4：LinkList和ArrayList的区别？
如果是在集合的开头插入一个对象，使用哪种效率高些，在集合的末尾插入一个对象，使用哪种效率高些，为什么？【3分】
答：这个有点类似数组和链表的区别。List是借口，LinkList和ArrayList是实现类。ArrayList其实就是类似数组，元素的随机访问效率很高，缺点就是内存占用量较大，插入元素比较以及添加删除元素效率较低。而LinkList相反。在开头插入元素的话设计到，元素的移动，当然是用linklist效率会更好，因为链表不是顺序链接的。但是如果是在最末尾增加一个对象，那么是用ArrayList效率会高一些，因为不涉及移动元素的操作，它定位更加快速。
5：介绍JAVA开发中常用的Collection FrameWork(写出Java集合的框架结构,加上必要的名称注释)? 【3分】
答： Collection
├List接口
│├LinkedList链表
│├ArrayList动态数组
│└Vector容器
│ └Stack栈
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
三：改错与分析题【本环节中每道题3分，共7道，总计21分】
<第一题>
- interface A{
- int x = 0;
- }
- class B{
- int x =1;
- }
- class C extends B implements A {
- public void pX(){
- System.out.println(x);
- }
- public static void main(String[] args) {
- new C().pX();
- }
- }
请问哪一行有错？为什么？【3分】
答：9行有错误，因为这里的X分不清楚到底是哪一个X，程序编译会报错，要明确是用哪一个，例如new B().x
< 第二题>
- abstract class Animal {
- public void saySomething() {
- System.out.println(“你想说什么就说吧！”);
- }
- }
- class Dog extends Animal {
- public void saySomething() {
- System.out.println(“我现在有了第二职业：捉耗”);
- }
- }
- public class Test {
- public static void main (String[] args) {
- Animal ani=new Dog();
- ani.saySomething();
- }
- }
请问哪一行有错？为什么？【3分】
答：我将程序拷贝到eclipse里面反正没有错误，除了3行和8行的引号有问题以外，程序能正确的使出我现在有了第二职业：捉耗
<第三题>
public class Test {
private static void printArray(int[] arr) {
for(int i=0;i< arr.length;i++)
System.out.print(arr[i]+”,”);
System.out.println(” “);
}
private static void changeValue(int value) {
value*=2;
}
private static void changeValue(int[] arr) {
for(int i=0;i<arr.length;i++)
arr[i]*=2;
}
public static void main (String[] args) {
int[] arr={1,2,3,4,5};
changeValue(arr[0]);
printArray(arr);
changeValue(arr);
printArray(arr);
}
}
请问结果是什么?并详细解释原因【3分】
答：
1,2,3,4,5
2,4,6,8,10
这个主要是区分方法的重载，方法的重载主要是根据传递的参数不同来选择具体使用哪一个方法，第一个changeValue只是将数组中的第一个元素传递进去做了计算，但是并没有改变数组，以及数组中的元素，所以打印出来的就是1,2,4,5
第二个changeValue是将数组传递进去了，然后做了运算，所以值发生了改变。
<第四题>
public class A {
static {
System.out.println(“11″);
}
{
System.out.println(“22″);
}
public A() {
System.out.println(“33″);
}
public void deal() {
System.out.println(“44″);
}
}
public class B extends A {
static {
System.out.println(“55″);
}
{
System.out.println(“66″);
}
public B() {
System.out.println(“77″);
}
public void deal() {
System.out.println(“88″);
}
}
public class C {
public static void main(String[] args) {
A b=new B();
b.deal();
}
}
请问结果是什么？并详细分析原因【3分】
答：
11
55
22
33
66
77
88
java中的自由块分为静态的自由块和非静态的自由块，这两种的执行是有区别的：
非静态自由块的执行时间是：在执行构造函数之前。
静态自由块的执行时间是：class文件加载时执行。
这里父类中的deal（）方法是被覆盖了，所以是不会执行的
<第五题>
public class Test{
public static void so(String[] name){
String temp=name[0];
Name[0]=name[1];
Name[1]=temp;
}
public static void so(String name0,String name1){
String temp=name0;
Name0=name1;
Name1=temp;’
}
public static void main(String[] wewe){
String[] name = new String[]{“mike”,”Lily”};
String name0 = “mike”;
String name1=”Lily“;
So(name);
System.out.println(name[0]+”,”+name[1]);
So(name0,name1);
System.out.println(name0+”,”+name1);
}
请输出结果？并详细解释为什么？【3分】
答：
Lily,mike
mike,Lily
首先我们看第一个so(name),传递进去的是一个字符串数组那么这个是整个数组被传递进去了，那么在so中的交换实际上也就是对这个数组中元素的交换。
第二个so(name0,name1)的话，就需要理解形参和实参的关系，形参是不可能改变实参的值得，而且形参的作用域也只有那一个函数而已，打印的name0，和name1并不受影响。
<第六题>
public class Person {
static class User {
int id;
String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return this.id;
}
public String getName() {
return this.name;
}
class Student {
public void setid(int newId) {
id = newId;
}
public void setName(String newName) {
name = newName;
}
}
}
public void print(int id, String name) {
User user = new User(id, name);
System.out.println(user.getId() + “\t” + user.getName());
}
public static void main(String[] args) {
//…手写补充代码
}
}
要求：先对User进行创建实例化 学号为：1001 姓名为： 张三 之后进行修改 学号为： 1002 姓名为：李四 调用Person类的打印输出方法显示修改后的结果。【3分】
答： User zhang = new User(1001,"张三");
User.Student li = zhang.new Student();
li.setid(1002);
li.setName("李四");
new test1().print(zhang.getId(),zhang.getName());
输出的结果为 1002 李四
<第七题>
列举几个你常去的IT技术型的网站，类型不限，个数不限,写中文名亦可，并解释为什么值得你去？【3分】
答：CSDN ITEYE EOEANDROID
四：编程算法题，将代码下在每道题的下面[共5道题，第一，二题为5分，第三题为6分，第四题为8分，第五题为10分，总计34分]
1：请用递归算法写一个方法求出两个数字的最大公约数和最小公倍数【5分】
publicclass test1{
//计算最大公约数使用的是欧几里德算法
publicstaticintgcd(int a,int b){
if(b==0)
return a;
else
returngcd(b,a%b);
}
// 最小公倍数等于两个数的乘积除以最大公约数
publicstaticint gbs(int x,int y){
return x*y/gcd(x,y);
}
publicstaticvoid main(String args[]){
System.out.println(gcd(5,16));
System.out.println(gbs(6,9));
}
}
解析，这个题目是比较经典的，最主要的是计算最大公约数，这个就是经典的欧几里德算法，当计算得到了最大公约数后，最小公倍数就是两个数的乘积除以最大公约数
【安徽科大讯飞2012届武汉大学校园招聘试题】
2：请将一个链表反序【5分】
publicclass test1 {
//假设链表的节点定义如下:
class Node {
inti;
Node next;
}
//那么其反转函数为:
void reverse(Node l) {
if (l ==null)
return;
Node p = null, q = l, r = l.next;
while (r !=null) {
q.next = p;
p = q;
q = r;
r = r.next;
}
q.next = p;
l = q;
}
}
【华为2011届华中科技大学校园招聘试题】
3：现在有一个有趣的游戏：称为杀人游戏！游戏规则是：输入参加的总人数，在输入一个基数，然后每个人依次报数，
当前选手报的数能被基数整除的话，就判为死亡出局，剩下的再继续数数，当数到最后一个时候，再接着从1开始从头数数。。。
一直到活下的人小于基数为止，整个游戏结束，打印最后存活选手的编号；【6分】
例子：总数：6 基数 2
M M M M M M
1 2 3 4 5 6
M X M X M X
1 2 3 4 5 6
M M M
1 2 3
M X M
1 2
M X
1
存活的人数是：1
存活的编号是：1
【微软，中兴的笔试题，要求不限制语言编写实现】
4：比较两个字符串，要求从字符串的最后一个元素开始逐个向前比较，如果两个字符串的长度不等，则只比较短长度字符串的元素。请编程实现下面给出的比较方法，并返回比较中发现的不相等元素的个数。【8分】
public int getDiffNum(int len1, String str1,intlen2, String str2)
例如：len1=3 str1=”acd” len2=5 str2=”zhacd” 函数返回为 0
len1=3 str1=”acd” len2=6 str2=”zhacdv” 函数返回为 3
【华为2012届南京大学校园招聘试题】
5:任何一个自然数m的立方均可写成m个连续奇数之和。【10分】
例如：
1^3=1
2^3=3+5
3^3=7+9+11
4^3=13+15+17+19
请编程实现：输入一自然数n，求组成n^3的n个连续奇数，格式必须按照上面进行输出。【浙江大学研究院2011年笔试题目】