提示：试卷上的答案请忽略，以后续解答为准。
详细解答：
一、选择题
1、D
2、C 相联存储器是把存储单元所存内容的某一部分作为检索项（即关键字项），用来检索存储器，并读出或写入存储器中与该检索项相符的存储单元的内容。
3、C DES是一种对称式加密算法，使用 16 个循环，使用异或，置换，代换，移位操作四种基本运算。
4、A 常见的对称加密算法有DES、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES；常见的非对称加密算法有：RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）；常见的Hash单向加密算法有MD2、MD4、MD5、HAVAL、SHA
5、C
6、A
7、A 因为是非剥夺式的，请求资源没有得到满足，则会进入阻塞状态。
8、B 由系统进程检查进程资源状态。
9、B 死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
该策略破坏了其中的请求和保持条件。
10、D 概要设计就是系统设计的说明书，不需要每个模块的伪代码。
11、A 原型化方法是为了破除阶段性严格定义的方案，它向用户提供以界面为主导的解决方案，是一种自外向内的设计过程。
12、C
13、A 像星型,网型,总线型,环型这些拓扑结构对网速影响不大，不同点在于拓扑的可靠性和费用。
14、B 多数情况下，一个堡垒主机使用两块网卡，每个网卡连接不同的网络。一块网卡连接你公司的内部网络用来管理、控制和保护，而另一块连接另一个网络，通常是公网也就是Internet。
15、B 参考维基百科http://zh.wikipedia.org/zh/MPEG-4
16、B 124个叶结点的完全二叉树，最多的情况是1+2+4+8+16+32+64+120+1（可补一个左结点）=248
17、D 面向对象三大特征：封装、继承、多态。
18、A 继承的目的之一就是代码复用。
19、A remove可直接删除该对象
20、D x是static静态变量，存放在静态存储区中，无论直接访问和实例化访问，都是同一对象。
21、D 没有无参的默认构造函数。
22、C String是final类型的不可变量，字符串数组是对对象的引用进行操作。
23、D StringBuffer是可变的字符串类，operate方法接受的是StringBuffer对象引用的复制，原始引用并未改变（基本类型传递是值的复制，对象传递是引用的复制），方法运行完后该复制自动消失，打印的是原始引用的对象信息，这里对引用a的对象添加b，而引用b的对象不变。故结果为AB，B。
24、B 访问权限并不是为自己访问而设置的，大多是不同类之间的相互引用限制。
25、D 继承后，子类实例化是首先进入父类的无参构造方法。
二、数据库
26、MySQL分页可直接通过limit实现：select * from 表名 limit m,size;从m+1条查询size条记录。SQLServer可以使用Top和not in实现：select top 10 * from 表名 where 主键 not in(select top 10 主键 from 表名);--查询显示11-20条记录(10条)。
27、以下解析仅供参考，用join实现更好。
(1) select * from J where CITY=‘南京‘;
(2) select SPJ.SN from SPJ,J where SPJ.JN=J.JN and J.CITY=‘上海‘;
(3) select SPJ.SN from SPJ,J,P where SPJ.JN=J.JN and SPJ.PN=P.PN and J.CITY=‘上海‘ or J.CITY=‘北京‘ and P.COLOR=‘红色‘;
(4) select SPJ.PN from SPJ,J,S where SPJ.JN=J.JN and SPJ.SN=S.SN and J.CITY=S.CITY;
(5) select distinct SPJ.JN from SPJ,J,S where SPJ.JN=J.JN and SPJ.SN=S.SN and J.CITY <> S.CITY;
(6) select SPJ.JN from SPJ,S where SPJ.SN=S.SN and SPJ.QTY=0 and S.CITY=‘上海‘;
(7) select S.CITY,J.CITY from SPJ,J,S where SPJ.JN=J.JN and SPJ.SN=S.SN;
三、Android题
28、Android四大组件：http://www.eoeandroid.com/thread-33435-1-1.html
Activity：Activity是Android程序与用户交互的窗口，是Android构造块中最基本的一种，它需要为保持各界面的状态，做很多持久化的事情，妥善管理生命周期以及一些跳转逻辑
service：后台服务于Activity，封装有一个完整的功能逻辑实现，接受上层指令，完成相关的事务，定义好需要接受的Intent提供同步和异步的借口
Content Provider：是Android提供的第三方应用数据的访问方案，可以派生Content
Provider类，对外提供数据，可以像数据库一样进行选择排序，屏蔽内部数据的存储细节，向外提供统一的借口模型，大大简化上层应用，对数据的整合提
供了更方便的途径
BroadCast Receiver：接受一种或者多种Intent作触发事件，接受相关消息，做一些简单处理，转换成一条Notification，统一了Android的事件广播模型。
29、Android五大布局：http://mobile.51cto.com/android-229801.htm
四、Java题
30、常见的七种排序算法：快速、归并、堆、选择、冒泡、插入和希尔。
冒泡排序(稳定)：
public static void bubbleSort(int[] a)
{
for(int i=a.length-1;i>0;i--)
{
for(int j=0;j<i;j++)
{
if(a[j]>a[j+1])
{
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
选择排序(不稳定)：
public static void selectSort(int[] a){
for(int i =0;i<a.length;i++)
{
int k = i;
for(int j =i+1;j<a.length;j++)
{
if(a[k]>a[j])
k=j;
}
if(k!=i){
int temp = a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
插入排序(稳定)：在部分已排序的序列中使用插入排序可达到最少的比较次数。
public static void insertSort(int[] a){
for(int i =1;i<a.length;i++){
int temp = a[i];
int j;
for(j =i-1;j>=0&&temp<a[j];j--)
a[j+1]=a[j];
a[j+1] = temp;
} }
希尔排序(不稳定)：
public static void shellSort(int[] a){
int gap = 0;
while(gap<=a.length){ //改进版insert排序，增加gap跨区域排序
gap = gap*3+1;
}
while(gap>0){
for(int i =gap;i<a.length;i+=gap){
int temp = a[i];
int j;
for(j =i-gap;j>=0&&temp<a[j];j-=gap){
a[j+gap]=a[j];
}
a[j+gap] = temp;
}
gap = (gap-1)/3;
}
}
快速排序(不稳定):
public static void quickSort(int[] a,int low,int high){
if(low >=high){
return;
}
int start = low;
int end = high;
int temp = a[low];
while(low<high){
while(low<high&&a[high]>temp){
high--;
}
a[low] = a[high];
while(low<high&&a[low]<temp){
low++;
}
a[high]=a[low];
}
a[low] = temp;
quickSort(a,start,low-1);
quickSort(a,low+1,end);
}
归并排序(稳定)：
public static void mergeSort(int[] a,int start,int end){//分治法
if(start<end){
int mid = (start+end)/2;
mergeSort(a,start,mid); //递推排序
mergeSort(a,mid+1,end);
merge(a,start,mid,mid+1,end);
}
}
private static void merge(int[] a, int start, int mid, int i, int end) {
// TODO Auto-generated method stub
int m = start;
int temp[] = new int[end-start+1];
int k = 0;
while(start<=mid&&i<=end){
if(a[start]<a[i]){
temp[k++] = a[start++];
}else{
temp[k++] = a[i++];
}
}
while(start<=mid){
temp[k++] = a[start++];
}
while(i<=end){
temp[k++] = a[i++];
}
for(int element:temp){//将排好的数组替换以前的
a[m++] = element;
}
}
堆排序(不稳定):这个排序面试问的最多，务必要手写出来
public static void heapSort(int[] a){
createMaxHeap(a);
for(int i=a.length-1;i>0;i--){
int temp = a[0];
a[0]=a[i];
a[i]=temp;
maxHeap(a,1,i);
}
}
private static void createMaxHeap(int[] a) {
// TODO Auto-generated method stub
int startNode = a.length/2;
for(int i = startNode;i>0;i--){
maxHeap(a,i,a.length);
}
}
private static void maxHeap(int[] a, int startNode, int length) {
// TODO Auto-generated method stub
int leftNode = 2*startNode;
int rightNode = 2*startNode+1;
int maxNode = startNode;
if(leftNode<=length&&a[leftNode-1]>a[startNode-1]){//只考虑length以内的家族,数组与节点相差1
maxNode = leftNode;
}
if(rightNode<=length&&a[rightNode-1]>a[maxNode-1]){
maxNode = rightNode;
}
if(maxNode!=startNode){
int temp = a[maxNode-1];
a[maxNode-1]=a[startNode-1];
a[startNode-1]=temp;
maxHeap(a,maxNode,length);//调整交换后的最大值对其孩子的影响
}
}
31、JDBC数据库查询的步骤：参考http://www.cnblogs.com/hongten/archive/2011/03/29/1998311.html
try{
//加载MySql的驱动类
Class.forName("sun.jbdc.odbc.jdbcOdbcDriver") ;
}catch(ClassNotFoundException e){
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace() ;
}
//连接MySql数据库，用户名和密码都是root
String url = "jdbc:odbc:people" ;
String username = "root" ;
String password = "root" ;
try{
Connection con =
DriverManager.getConnection(url , username , password ) ;
}catch(SQLException se){
System.out.println("数据库连接失败！");
se.printStackTrace() ;
}
Statement stmt = con.createStatement() ;
ResultSet rs = stmt.executeQuery("SELECT * FROM Staff where ID=‘001‘") ;
while(rs.next()){
String name = rs.getString("name") ;
String name1 = rs.getString(1) ; // or此方法比较高效
}
if(rs != null){ // 关闭记录集
try{
rs.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(stmt != null){ // 关闭声明
try{
stmt.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(con != null){ // 关闭连接对象
try{
con.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
32、面向对象三要素：封装、继承、多态
封装：就是用一个自主式框架把对象的数据和方法连在一起形成一个整体。对象是封装的基本单位，相互之间通过接口访问。目的是隐藏细节，代码模块化。
继承：子类拥有父类非private的属性和功能，通过继承的代码复用是一种“白盒式代码复用”，重写和覆盖会破坏封装性。目的是扩展代码模块，实现代码复用。
多态：允许父类声明指向子类对象。即同一方法获得不同的行为特征（重载和覆盖）。目的是接口重用，是面向对象的核心。