1.关于异常处理机制的叙述正确的是（）

正确答案: C 你的答案: C (正确)
A.catch部分捕捉到异常情况时，才会执行finally部分
B.当try区段的程序发生异常时，才会执行finally部分
C.当try区段不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
D.以上都是

解释：
在Java语言的异常处理中，finally块的作用就是为了保证无论出现什么情况，finally块里的代码一定会执行。
由于程序执行return就意味着结束了对当前函数的调用并跳出这个函数体，因此任何语句执行都要放在return前执行（除非碰到exit函数），因此finally块里面的函数也是在return前执行的。
如果try-finally或者catch-finally中都有return语句，那么finally中的return语句会覆盖别处的，最终返回到调用者那里的是finally中的return值。

2.关于下面代码 int[] x=new int[25]; 描述正确的是（）

正确答案: C 你的答案: C (正确)
A.x[25]存放了数据“\0”。
B.x[24] 存放了数据“\0”。
C.若访问x[25]，程序将抛出异常。
D.x[1]访问此数组的第一个元素。

解释：
A:不存在x[25] 索引从0开始到length-1
B:x[24] 存的是默认值0(java中没有’\0’这一说)
C:超出内存 正确
D:第二元素

3.如下代码的 结果是什么 ?

class Base {Base() {System.out.print("Base");}
}
public class Alpha extends Base {public static void main( String[] args ) {new Alpha();//调用父类无参的构造方法new Base();}
}

正确答案: B 你的答案: B (正确)
A.Base
B.BaseBase
C.编译失败
D.代码运行但没有输出
E.运行时抛出异常

解释：
在执行new Alpha()时，会先执行父类的构造方法，在执行相应的子类的构造方法，所以此处会打印Base，在执行new Base()时，会直接执行Base中无参构造器的代码，再输出Base，所以选B

4.静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（ ）

正确答案: A 你的答案: B (错误)
A.正确
B.错误

解释：
总的来说一下内部类吧：

1. 静态内部类：
   1. 静态内部类本身可以访问外部的静态资源，包括静态私有资源。但是不能访问非静态资源，可以不依赖外部类实例而实例化。
2. 成员内部类：
   1. 成员内部类本身可以访问外部的所有资源，但是自身不能定义静态资源，因为其实例化本身就还依赖着外部类。
3. 局部内部类：
   1. 局部内部类就像一个局部方法，不能被访问修饰符修饰，也不能被static修饰。
   2. 局部内部类只能访问所在代码块或者方法中被定义为final的局部变量。
4. 匿名内部类：
   1. 没有类名的内部类，不能使用class，extends和implements，没有构造方法。
   2. 多用于GUI中的事件处理。
   3. 不能定义静态资源
   4. 只能创建一个匿名内部类实例。
   5. 一个匿名内部类一定是在new后面的，这个匿名类必须继承一个父类或者实现一个接口。
   6. 匿名内部类是局部内部类的特殊形式，所以局部内部类的所有限制对匿名内部类也有效。

5.根据下面的程序代码，哪些选项的值返回true？

public class Square {  long width;  public Square(long l) {   width = l;  }  public static void main(String arg[]) {   Square a, b, c;  a = new Square(42L);   b = new Square(42L);   c = b;   long s = 42L;  } 
}

正确答案: C 你的答案: D (错误)
A.a == b
B.s == a
C.b == c
D.a.equals(s)

解释：
A: a == b
由图可以看出a和b指向的不是同一个引用，故A错
B：s == a
一个Square类型不能与一个long型比较，编译就错误，故B错
c：b == c
由图可以看出b和c指向的是同一个引用，故C正确
d：a equal s
程序会把s封装成一个Long类型，由于Square没有重写Object的equals方法， 所以调用的是Object类的equals方法，源码如下

 public boolean equals(Object obj) {return (this == obj);}其实就是判断两个引用是否相等，故D也错误

6.以下代码执行的结果显示是多少（）？

public class Demo{public static void main(String[] args){System.out.print(getNumber(0));System.out.print(getNumber(1));System.out.print(getNumber(2));System.out.print(getNumber(4));}public static int getNumber(int num){try{int result = 2 / num;return result;}catch (Exception exception){return 0;}finally{if(num == 0){return -1;}if(num == 1){return 1;}}}    
}

正确答案: B 你的答案: B (正确)
A.0110
B.-1110
C.0211
D.-1211

解释：
try,catch,finally中:
num=0,捕获异常，执行catch语句，catch中返回0，执行finally语句，finally语句中返回-1，于是返回finally中的-1；
num=1,try中返回2，执行finally语句，finally语句中返回1，于是返回finally中的1；
num=2,try中返回1，执行finally语句，finally语句中没有返回，于是返回try中的1；
num=4,try中返回0，执行finally语句，finally语句中没有返回，于是返回try中的0.

规则：
1.try块是必须的，catch块和finally块都是可选的，但必须存在一个或都存在。try块不能单独存在。
2.try块里的语句运行中出现异常会跳过try块里其他语句，直接运行catch里的语句。
3.无论try块中是否有异常，无论catch块中的语句是否实现，都会执行finally块里的语句。
4.如果try块或catch块中有return语句，finally块里的语句会执行在try块或catch块中的return语句前。
5.如果finally块里有return语句，则直接返回，而不执行try块或catch块里的return语句。
6.只有一种办法不执行finally块里的语句，那就是调用System.exit(1);方法，即退出java虚拟机。
强调：finally块里的语句在try或catch里的人return前执行！！！

7.下面关于静态方法说明正确的是

正确答案: B 你的答案: B (正确)
A.在静态方法中可用this来调用本类的类方法
B.在静态方法中调用本类的静态方法时可直接调用
C.在静态方法中只能调用本类中的静态方法
D.在静态方法中绝对不能调用实例方法

解释：
A：不能使用this调用本类的类方法（即静态方法）；具体原理不清楚（望指点），个人理解为this指向的是实例对象，此时未实例化，故不能使用
B: 正确
C:在静态方法中，不只可以调用本类的静态方法，也可以使用【类名.静态方法名】调用其他类的静态方法
D:可以调用实例方法，使用【new 类名().实例方法名】调用

8.在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（）？

正确答案: A 你的答案: B (错误)
A.管道
B.消息队列
C.高速缓存数据库
D.套接字

解释：
1.管道(pipe)
管道是一种具有两个端点的通信通道，一个管道实际上就是只存在在内存中的文件，对这个文件操作需要两个已经打开文件进行，他们代表管道的两端，也叫两个句槟，管道是一种特殊的文件，不属于一种文件系统，而是一种独立的文件系统，有自己的数据结构，根据管道的使用范围划分为无名管道和命名管道。
无名管道用于父进程和子进程之间，通常父进程创建管道，然后由通信的子进程继承父进程的读端点句柄和写端点句柄，或者父进程有读写句柄的子进程，这些子进程可以使用管道直接通信，不需要通过父进程。
命名管道，命名管道是为了解决无名管道只能在父子进程间通信而设计的，命名管道是建立在实际的磁盘介质或文件系统(而不是只存在内存中)，任何进程可以通过文件名或路径建立与该文件的联系，命名换到需要一种FIFO文件(有先进先出的原则)，虽然FIFO文件的inode节点在磁盘上，但仅是一个节点而已，文件的数据还是存在于内存缓冲页面中，和普通管道相同。
2.信号
信号，用于接受某种事件发生，除了用于进程间通信之外，进程还可以发送信号给进程本身。除了系统内核和root之外，只有具备相同id的进程才可以信号进行通信。
3.消息队列
消息队列是消息的链表，包括Posix消息队列和system v消息队列(Posix常用于线程，system常用于进程)，有权限的进程可以向消息队列中添加消息，有读权限的进程可以读走消息队列的消息。
消息队列克服了信号承载信息量少，管道只能承载无格式字节流及缓冲区大小受限等缺陷。
4.共享内存
共享内存使多个进程可以访问同一块内存空间，是最快的IPC形式，是针对其他通信方式运行效率低而设计的，往往与其他进程结合使用，如与信号量结合，来达到进程间的同步与互斥。传递文件最好用共享内存的方式。

9.面代码输出是？

double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));

正确答案: A 你的答案: A (正确)
A.Ceil d1=-0.0
floor d1=-1.0

B.Ceil d1=0.0
floor d1=-1.0

C.Ceil d1=-0.0
floor d1=-0.0

D.Ceil d1=0.0
floor d1=0.0

E.Ceil d1=0
floor d1=-1

解释：
ceil：大于等于 x，并且与它最接近的整数。
floor：小于等于 x，且与 x 最接近的整数。

Math.ceil(d1) 如果参数小于0且大于-1.0，结果为 -0

Math.floor(d1) 如果参数是 NaN、无穷、正 0、负 0，那么结果与参数相同。

10.在java中重写方法应遵循规则的包括（）

正确答案: B C 你的答案: B C (正确)
A.访问修饰符的限制一定要大于被重写方法的访问修饰符
B.可以有不同的访问修饰符
C.参数列表必须完全与被重写的方法相同
D.必须具有不同的参数列表

解释：
方法重写

• 参数列表必须完全与被重写方法的相同；
• 返回类型必须完全与被重写方法的返回类型相同；
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
• 父类的成员方法只能被它的子类重写。
• 声明为final的方法不能被重写。
• 声明为static的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为>private和final的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和>protected的非final方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。>但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛>的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个方法，则不能重写这个方法。

方法重载

• 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。