java测试复盘6（2019.9.8）

1、假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？ A*

public class Base
{
public void methodOne()
{
System.out.print("A");
methodTwo();
}

public void methodTwo()
{
System.out.print("B");
}
}

public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print("C");
}

public void methodTwo()
{
super.methodTwo();
System.out.print("D");
}
}

A.ABDC
B.AB
C.ABCD
D.ABC

2、以下说法中正确的有？ A*
A.StringBuilder是 线程不安全的
B.Java类可以同时用 abstract和final声明
C.HashMap中，使用 get(key)==null可以 判断这个Hasmap是否包含这个key
D.volatile关键字不保证对变量操作的原子性

3、ArrayList list = new ArrayList(20);中的list扩充几次 A*
A.0
B.1
C.2
D.3
解析：ArrayList的构造函数总共有三个：
（1）ArrayList()构造一个初始容量为 10 的空列表。
（2）ArrayList(Collection<? extends E> c)构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
（3）ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
调用的是第三个构造函数，直接初始化为大小为20的list，没有扩容，所以选择A

4、对以下 HTTP 状态码描述，不正确的是？ B
A.301 和 302 状态码都表示请求的资源被转移到新地址
B.服务器返回 304 时，需要同时返回请求的资源内容。
C.2xx 的状态码表示请求成功
D.如果服务器请求第三方 API 超时，应该返回 504
解析：HTTP 304 Not Modified 客户端针对有缓冲的文件并发出了一个条件性的请求（一般是If-Modified-Since头）。服务器检查之后该文件是否更新,若没有则返回304,并且不会返回该文件，表明原来缓冲的文件还可以继续使用。

5、假设num已经被创建为一个ArrayList对象，并且最初包含以下整数值：[0，0，4，2，5，0，3，0]。 执行下面的方法numQuest(),最终的输出结果是什么？ D

private List<Integer> nums;
 
//precondition: nums.size() > 0
//nums contains Integer objects
public void numQuest() {
int k = 0;
Integer zero = new Integer(0);
while (k < nums.size()) {
if (nums.get(k).equals(zero))
nums.remove(k);
k++;
}
}

A.[3, 5, 2, 4, 0, 0, 0, 0]
B.[0, 0, 0, 0, 4, 2, 5, 3]
C.[0, 0, 4, 2, 5, 0, 3, 0]
D.[0, 4, 2, 5, 3]
解析：在执行循环时碰到了0的对象,进行删除
使数组减少一个数,List为 [0, 4, 2, 5, 0, 3, 0],
但是下一次k=1,所以将在4的位置开始比较,跳过0
而将在List索引为4的位置再次碰到0的对象,
得到List为[0, 4, 2, 5, 3, 0],此时下一次的k=5,跳过了3
然而LIst的索引为5的位置是0的对象,再进行删除.
得到答案:[0, 4, 2, 5, 3]
总结:由于remove()删除了List集合元素,导致集合产生变化,而索引未进行修正,导致跳过了一些元素.

6、以下哪个I / O类可以附加或更新文件A
A.RandomAccessFile()
B.OutputStream()
C.DataOutputStream()
D.None of the above
解析：RandomAccessFile直接继承于Java. Lang. Object类，实现了DataInput和DataOutput接口，它既可以作为一个输入流，又可以作为一个输出流

7、在32位系统下运行以下程序，可能的输出结果为（ ）C

int main ()
{
int i,a[5];
for (i=0;i<=30;i++)
{
a[i]=0;
printf("%d:hello\n",i);
}
printf("%d:hello world",i);
return 0;
}

A.三十行的 i:hello (i∈[0,30]) 和一行 30:hello world
B.三十行的 i:hello (i∈[0,30]) 和一行 31:hello world
C.多行的 i:hello (i∈[0,30] )
D.多行的 i:hello (i∈[0,31])
解析：本题是考察数组越界会导致死循环。经过实验得知，当循环体中改为i<=7后，开始0-6的死循环，i<=6及之前的，都可以退出循环。
栈中是从高地址指向低地址的，如下：
高地址 | i | a[4] | a[3] | a[2] | a[1] | a[0] | 低地址
所以i在高地址，而数组是连续存储的，而又由于有些编译器做了优化，使数组和i之间留有内存间隙，如开头所述，我用的VS2010留了2个间隙，但是，如果i越界严重，比如不小心给了50，还是会导致死循环。知a[6]与i占据一块空间，当执行到i=6，a[6]=0，将i的值又变成了0,又进入循环段执行下去，i永远的不大于30，造成死循环

9、下面关于垃圾收集的说法正确的是 D
A.一旦一个对象成为垃圾，就立刻被收集掉。
B.对象空间被收集掉之后，会执行该对象的finalize方法
C.finalize方法和C++的析构函数是完全一回事情
D.一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此
解析：A,B其实是一个知识点，既一个对象到GC Roots没有任何引用链相连时就是一个可回收对象，可回收对象在被回收之前，JVM会判断是否有finalize方法，如果有则会调用finalize方法，在这个方法里面对象可以自救的。
C 肯定不对啦
1.与C++的析构函数不同，析构函数调用确定，而finalize()方法是不确定的，因为finalize()方法在对象被GC回收时调用。
2.JVM将重写了finalize方法的对象放置于F-Queue队列，稍后会被一个优先级很低的Finalizer线程执行。Finalizer线程随时会终止，为了防止对象的finalize方法执行缓慢，或者发生死循环。
3.finaliz的设计目的是保证对象在被垃圾收集前完成特定资源的回收或给予对象最后一次重生机会等。
4. finalize是个不太可控的方法因此并不常用，并且在JDK9+版本被标注为过时方法。

10、某一速率为100M的交换机有20个端口，其一个端口上连着一台笔记本电脑，此电脑从迅雷上下载一部1G的电影需要的时间可能是多久？ D
A.OS
B.2OS
C.4OS
D.10OS
解析：暂无

11、以下说法中正确的有？ A
A.StringBuilder是 线程不安全的
B.Java类可以同时用 abstract和final声明
C.HashMap中，使用 get(key)==null可以 判断这个Hasmap是否包含这个key
D.volatile关键字不保证对变量操作的原子性

12、Spring开发模式的工作流程正确的是（ ） C
1.Spring MVC请所有的请求都提交给DispatcherServlet
2.DispatcherServlet请请求提交到目标Controller
3.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
4.视图对象负责渲染返回给客户端
5.找到ModelAndView对象指定的视图对象
6.Controller进行业务逻辑处理后，会返回一个ModelAndView
A.1-4-3-5-2-6
B.1-2-3-4-5-6
C.1-3-2-6-5-4
D.1-6-5-3-4-2
解析：最后一步渲染返回给客户端就完事了，选C

13、（多选）关于身份证号，以下正确的正则表达式为（ ）AC
A.isIDCard=/¹\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}KaTeX parse error: Undefined control sequence: \d at position 22: …sIDCard=/^[1-9]\̲d̲{7}((9\d)|(1[0-…/;
C.isIDCard=/²\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}KaTeX parse error: Undefined control sequence: \d at position 22: …sIDCard=/^[1-9]\̲d̲{5}[1-9]\d{3}((…/;

15、（多选）下列容器中，哪些容器按 key 查找的复杂度为 O(log(n)) （）BC
A.std::unordered_set
B.std::multimap
C.std::map
D.std::deque
解析：STL库中，map和multimap底层都是红黑树实现的，两者的不同在于multimap允许重复的可以，而map中不行。
红黑树的查找复杂度为O(log(n))
unodered_map/_set底层是哈希表实现的，查找复杂度为O(1)

16、下面哪些不是Thread类的方法 C
A.start()
B.run()
C.exit()
D.getPriority()

18、下列关于构造函数说法正确的是（ ）C
A.构造函数的返回值为void
B.构造函数不可以被重载
C.构造函数可以是内联函数
D.构造函数可以没有参数
解析：进入函数体里就说明分配了内存就有了this指针

19、以下关于Integer与int的区别错误的是 D
A.int是java提供的8种原始数据类型之一
B.Integer是java为int提供的封装类
C.int的默认值为0
D.Integer的默认值为1
解析：integer是类名

20、关于windows下的多线程安全，选项中说法错误的是（ ）B
A.如果多线程的程序运行结果是可预期的，在功能逻辑上与单线程实现的程序运行结果一致，那么我们说这个程序是多线程安全的。
B.只要使用了多线程CRT（multithreaded CRT）进行编译链接，那么CreateThread启动的线程就可以随便使用CRT函数，而不用担多线程安全问题。
C.如果在线程函数中不直接或者间接使用crt函数，那么使用CreateThread和使用_beginthreadex启动 的线程在thread-safe方面区别不大。
D.在线程函数中，尽量避免使用crt函数，如果一定要用，尽量使用_beginthreadex来启动线程
解析：C Runtime是windows平台下的一个概念。一般来说，CRT函数就是标准的C语言函数。例如，printf、scanf、strlen、fopen等函数就属于CRT函数。所有的C运行时函数除signal外都能够在通过CreateThread创建的线程中正确的运行。然而，对某些CRT函数的调用，在线程终止时会引发小小的内存泄露。例如：当调用strlen时并不会触发CRT线程在数据块中分配内存，而调用malloc,fopen,_open,strtok,ctime,或者localtime则会在每个线程数据块中分配内存，这可能会引发内存泄露。

21、某公司网络中心升级web服务器的物理内存,相应的要提高linux服务器交换空间,以下可以扩展交换空间的操作是（ ）A
A.dd if=/dev/zero of=/mnt/sw1;swapon /mnt/sw1
B.mkfs -f swap /dev/sdb1
C.mkswap /dev/sdb1
D.swapon /dev/sdb1

23、下列选项哪些语句可以正确定义数组（ ）A
A.#define N 2017 int arr[N];
B.#define N 2017 int arr[N*2];
C.int i=2017； int arr[i];
D.int arr[]={1};
解析：前两项都是宏定义的问题，不要把两个看作两行辽，我就是犯了这个错误，c也是错误的，变量不能用，唯一对的只有最后的选项

25、AccessViolationException异常触发后，下列程序的输出结果为（ ） A

static void Main(string[] args) 
{ 
try 
{ 
throw new AccessViolationException(); 
Console.WriteLine("error1"); 
} 
catch (Exception e) 
{ 
Console.WriteLine("error2"); 
} 
Console.WriteLine("error3"); 
}

A.error2
error3
B.error3
C.error2
D.error1
解析：1.若catch(){}块中，如果有throw 语句，则，try{}catch(){} finally{}块之外的代码不执行；否则，执行。 2.try{}中有异常，则异常下面代码不执行。 3.finally{}中代码必执行。

26、（多选）以下哪些方法是Object类中的方法 ABCD
A.clone()
B.toString()
C.wait()
D.finalize()

27、（多选）以下哪种方式实现的单例是线程安全的 ABCD
A.枚举
B.静态内部类
C.双检锁模式
D.饿汉式

28、（多选）下面关于volatile的功能说法正确的是哪个 BC
A.原子性
B.有序性
C.可见性
D.持久性
解析：synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性

29、下面关于静态方法说明正确的是 B
A.在静态方法中可用this来调用本类的类方法
B.在静态方法中调用本类的静态方法时可直接调用
C.在静态方法中只能调用本类中的静态方法
D.在静态方法中绝对不能调用实例方法
解析：A：静态方法没有this。
C：静态方法中可以调用其他类的静态方法，比如我们经常用的println。
D：静态方法可以通过创建类的实例来调用实例方法

30、某程序要求每次输入只能是正整数，并且每次输入的数值要求必须是100的倍数且小于等于500，则下列哪个是正确的无效等价类( ) C
A.（0，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;
B.（500，+∞）
C.（500，+∞）、任意大于0小于500的非100倍数的整数；
D.（-∞，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;
解析：无效等价类是指对于软件规格说明而言，是没有意义的、不合理的输入数据集合。利用无效等价类可以找出程序异常说明情况，检查程序的功能和性能的实现是否有不符合规格说明要求的地方。
有效等价类是指输入数据完全满足程序输入的规格说明，是有效、有意义的输入数据所构成的集合。利用有效等价类可以检验程序是否满足规格说明所规定的功能和性能。
应该选 C，因为C的后面一句话是已经排除了负数中的100的整数倍了

31、（多选）下面有关java threadlocal说法正确的有？ ABCD
A.ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递
B.从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收
C.在Thread类中有一个Map，用于存储每一个线程的变量的副本
D.对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式
解析：对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

32、以下协议属于 TCP/IP 协议簇中网络层的是（） B
A.SNMP
B.IGMP
C.UDP
D.DNS
解析：SNAP和dns属于应用层，tcp和udp协议属于传输层，iGMp是网络分组协议，属于网络层

33、对于函数y = ax^2 + bx + c,(a > 0),需要找出y的小值，精确到小数点后6位。下列选项中最有效的方法是（）。 D
A.枚举
B.二分查找
C.三分查找
D.推公式
解析：

34、终端发送帧序列为1101011111，使用生成多项式为G(x)=x^4+x+1校验后发出的帧为序列为（ ） D
A.11010111111100
B.11010111110011
C.11010111111011
D.11010111110010

35、（多选）判断一块内存空间是否符合垃圾收集器收集的标准有哪些？ ABD
A.给对象赋予了空值null,以下再没有调用过
B.对象重新分配了内存空间
C.给对象赋予了空值null
D.给对象赋予了新值
解析：在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
1.给对象赋值为null，以下没有调用过。
2.给对象赋了新的值，重新分配了内存空间。

38、java源程序编译为字节码，存放在.class文件中，JVM装载类解释执行。这句话正确还是错误呢A
A.T
B.F

40、在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为C
A.隐藏
B.覆盖
C.重载
D.Java不支持此特性
解析：方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。
方法重载能改变返回值类型，因为它和返回值类型无关。
Override：方法重写
Overload：方法重载

42、（多选）以下程序执行后，错误的结果是（）ABC

public class Test {
    private String name = "abc";
    public static void main(String[] args) {
        Test test = new Test();
        Test testB = new Test();
        String result = test.equals(testB) + ",";
        result += test.name.equals(testB.name) + ",";
        result += test.name == testB.name;
        System.out.println(result);
    }
}

A.true,true,true
B.true,false,false
C.false,true,false
D.false,true,true

43、关于protected 修饰的成员变量，以下说法正确的是A
A.可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B.可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
C.只能被该类自身所访问
D.只能被同一个包中的类访问
解析：（1）public：可以被所有其他类所访问。
（2）private：只能被自己访问和修改。
（3）protected：自身，子类及同一个包中类可以访问。
（4）default（默认）：同一包中的类可以访问，声明时没有加修饰符，认为是friendly

45、抽象类和接口的区别，一下说法错误的是D
A.接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
B.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
C.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的
D.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"has-a"关系，interface表示的是"is-a"关系。
解析：D项： abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

46、（多选）下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：( )AE
A.java.util.ConcurrentHashMap
B.java.util.Map
C.java.util.TreeMap
D.java.util.SortMap
E.java.util.Hashtable
F.java.util.HashMap
解析：Hashtable的方法都是synchrnized修饰的线程安全，ConcurrentHashMap并发容器，JDK7采用分段锁，JDK8采用CAS算法，线程安全，建议使用，Connections工具类提供了一个方法synchrnizedMap可以把Map同步，本质就是给每一个方法加上synchrnized关键字进行同步

47、（多选）如果进栈序列为e1，e2，e3，e4，则可能的出栈序列是()BC
A.e3，e1，e4，e2
B.e2，e4，e3，e1
C.e2，e3，e4，e1
D.任意顺序都有可能

48、下列代码输出什么（）B

char *a[] = {"BEIJING", "SHENZHEN", "SHANGHAI", "GUANGZHOU"};
char **pa[] = {a+3, a+2, a+1, a};
char ***ppa = pa;
int main(void) {
    printf("%s, ", **++ppa);
    printf("%s, ", *--*++ppa+3);
    printf("%s, ", *ppa[-2]+3);
    printf("%s", ppa[-1][-1]+1);
}

A.BEIJING, SHENZHEN, SHANGHAI,GUANGZHOU
B.SHANGHAI, JING, NGZHOU, HENZHEN
C.SHANGHAI,BEIJING, GUANGZHOU, SHENZHEN
D.SHANGHAI,EIJING,ZHOU,ZHEN

49、下面代码的运行结果为：（） C

import java.io.*;
import java.util.*;
public class foo{
public static void main (String[] args){
String s;
System.out.println("s=" + s);
}
}

A.代码得到编译，并输出“s=”
B.代码得到编译，并输出“s=null”
C.由于String s没有初始化，代码不能编译通过
D.代码得到编译，但捕获到 NullPointException异常

50、面向对象的基本特征有哪些（）A
A.封装
B.继承
C.多态
D.重载
解析：三大特征是：封装、继承和多态。 封装是指将某事物的属性和行为包装到对象中，这个对象只对外公布需要公开的属性和行为，而这个公布也是可以有选择性的公布给其它对象

51、（多选）下列关于final、finally、finalize说法正确的是（ ）ABD
A.final可以用来修饰类、方法、变量
B.finally是java保证重点代码一定要被执行的一种机制
C.变量被final修饰后不能再指向其他对象，但可以重写
D.finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收
解析：当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。

52、jdbc的事务必须在一个数据库连接上完成。编程时必须去掉数据库的自动提交功能。当成功后调用commit，当失败后调用rollback。判断这句话正确与否A
A.T
B.F

53、在Java中，什么是Garbage Collection?（）C
A.自动删除在程序中导入但未使用的任何包
B.JVM检查任何Java程序的输出并删除任何没有意义的东西
C.当对象的所有引用都消失后，对象使用的内存将自动回收
D.操作系统定期删除系统上可用的所有java文件
解析：垃圾回收器是将没有引用的对象进行垃圾回收，回收前会调用finalize()方法，下一个周期中进行回收

54、（多选）关于equals和hashCode描述正确的是 ()ABC
A.两个obj，如果equals()相等，hashCode()一定相等（符合代码规范的情况下）
B.两个obj，如果hashCode()相等，equals()不一定相等
C.两个不同的obj， hashCode()可能相等
D.其他都不对

55、（多选）关于java中的数组，下面的一些描述，哪些描述是准确的：（）ACE
A.数组是一个对象，不同类型的数组具有不同的类
B.数组长度是可以动态调整的
C.数组是一个连续的存储结构
D.一个固定长度的数组可类似这样定义：int array[100]
E.两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
F.可以二维数组，且可以有多维数组，都是在java中合法的。
解析：ACF E中如果直接比较的是两个数组的话，是直接调用obj中的eques()方法(比较的是两个数组的内存地址)，如果想要比较两个数组里的元素是不是都相同用的是Arrays.eques()

56、以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )B
A.String a = “hello”; String b = “hello”;
B.Integer a; Integer b = a;
C.int a = 1; Integer b = new Integer(1);
D.int a = 1; Integer b = 1;
解析：

57、（多选）在Java中，关于HashMap类的描述，以下正确的是 ()ACD
A.HashMap使用键/值得形式保存数据
B.HashMap 能够保证其中元素的顺序
C.HashMap允许将null用作键
D.HashMap允许将null用作值
解析：HashMap允许key/value都为空，但是HashMap是无序的，HashTable才是有序的，但它的效率低于HashMap

58、下面关于JAVA的垃圾回收机制，正确的是（ ）B
A.当调用“System.gc()”来强制回收时，系统会立即回收垃圾
B.垃圾回收不能确定具体的回收时间
C.程序可明确地标识某个局部变量的引用不再被使用
D.程序可以显式地立即释放对象占有的内存
解析：java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。

59、以下对异常的描述不正确的有（）C
A.异常分为Error和Exception
B.Throwable是所有异常类的父类
C.Exception是所有异常类父类。
D.Exception包括RuntimeException和RuntimeException之外的异常。

60、（多选）关于下面的一段代码，以下哪些说法是正确的：AD

public static void main(String[] args) {
   String a = new String("myString");
    String b = "myString";
    String c = "my" + "String";
    String d = c;
    System.out.print(a == b);
    System.out.print(a == c);
    System.out.print(b == c);
    System.out.print(b == d);
}

A.System.out.print(a == b)打印出来的是false
B.System.out.print(a == c)打印出来的是true
C.System.out.print(b == c)打印出来的是false
D.System.out.print(b == d)打印出来的是true

61、（多选）接口和抽象类描述正确的有（ ）BC
A.抽象类没有构造函数。
B.接口没有构造函数。
C.抽象类不允许多继承。
D.接口中的方法可以有方法体。
解析：JDK8以后的默认方法和静态方法可以有方法体，题目的方法应该是指普通方法

62、以下对继承的描述错误的是（）A
A.Java中的继承允许一个子类继承多个父类
B.父类更具有通用性，子类更具体
C.Java中的继承存在着传递性
D.当实例化子类时会递归调用父类中的构造方法

63、关于protected 修饰的成员变量，以下说法正确的是A
A.可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B.只能被该类本身和该类的所有的子类访问
C.只能被该类自身所访问
D.只能被同一个包中的类访问
解析：（1）public：可以被所有其他类所访问。
（2）private：只能被自己访问和修改。
（3）protected：自身，子类及同一个包中类可以访问。
（4）default（默认）：同一包中的类可以访问，声明时没有加修饰符，认为是friendly

64、（多选）JAVA 中可以让线程停止执行方法有（）ACD
A.sleep();
B.notify();
C.synchronized();
D.yield();
解析：当一个线程抢到执行权后，执行到yield（）方法后，就会放弃执行权，其他线程就可以拿到执行权 了。

65、WaitForSingleObject 有几种返回值的可能 D
A.1
B.2
C.3
D.>=4

66、以下程序运行后的输出结果是（ ）A

int main()
{
int a=1,b=2,m=0,n=0,k;
 
k=(n=b<a)&&(m=a) ;
printf("%d,%d\n",k,m);
 
return 0;
}

A.0，0
B.0，1
C.1，0
D.1，1

67、（多选）关于下列代码的执行顺序，下面描述正确的有哪些选项（）ABC

public class HelloA {
    public HelloA() { 
        System.out.println("A的构造函数");
    }
{ 
    System.out.println("A的构造代码块");
}
static { 
    System.out.println("A的静态代码块");
}
public static void main(String[] args) {
    HelloA a = new HelloA();
}
}

A.打印顺序A的静态代码块> A的构造函数
B.打印顺序A的静态代码块> A的构造代码块
C.打印顺序A的构造代码块> A的构造函数
D.打印顺序A的构造函数> A的构造代码块
解析：打印顺序为A的静态代码块，A的构造代码块，A的构造函数

68、（多选）下列运算符中，能够被重载的是（）ABD
A.&&
B.！=
C…
D.->
解析：除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，C++中的所有运算符都可以重载
但是=、()、[]、->这四个不能重载为类的友元函数。

69、应用NAT后会带来哪些影响（ ）A
A.不利于分片
B.不利于数据加密
C.需要重新计算IP分组校验和
D.可以解决IPv4地址耗尽问题

6.J2EE中，当把来自客户机的HTTP请求委托给servlet时，会调用HttpServlet的（ ）方法A*
A.service
B.doget
C.dopost
D.init
解析：Servlet生命周期分为三个阶段：
1.初始化阶段 调用init()方法
2.响应客户请求阶段　　调用service()方法
3.终止阶段　　调用destroy()方法

7.以下选项中，合法的赋值语句是（） B*
A.a>1;
B.i++;
C.a= a+1=5;
D.y = int ( i );
解析：这道题不是考初不初始化的问题
c的表达式都是错位的
d强制转换，括号应该在前面
i++ 可以看成i=i+1

8.When is the text “Hi there”displayed? C*

public class StaticTest
{
    static
    {
        System.out.println(“Hi there”);
    }
 
    public void print()
    {
        System.out.println(“Hello”);
    }
 
    public static void main(String args[])
    {
        StaticTest st1 = new StaticTest();
        st1.print();
        StaticTest st2 = new StaticTest();
        st2.print();
    }
}

A.Never.
B.Each time a new object of type StaticTest is created.
C.Once when the class is loaded into the Java virtual machine.
D.Only when the main() method is executed.
解析：
类的加载顺序
(1) 父类静态代码块(包括静态初始化块，静态属性，但不包括静态方法)
(2) 子类静态代码块(包括静态初始化块，静态属性，但不包括静态方法 )
(3) 父类非静态代码块( 包括非静态初始化块，非静态属性 )
(4) 父类构造函数
(5) 子类非静态代码块 ( 包括非静态初始化块，非静态属性 )
(6) 子类构造函数
其中：类中静态块按照声明顺序执行，并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)

9.以下程序段执行后将有（）个字节被写入到文件afile.txt中。 C*

try {
    FileOutputStream fos = new FileOutputStream("afile.txt");
    DataOutputStream dos = new DataOutputStream(fos);
    dos.writeInt(3);
    dos.writeChar(1);
    dos.close();
    fos.close();
} catch (IOException e) {}

A.3
B.5
C.6
D.不确定，与软硬件环境相关
解析：java采用的uincode编码，两个字节表示一个字符，因此 char型在java中占两个字节，而int型占四个字节，故总共占四个字节

10.What is the result of compiling and executing the following fragment of code: C*

Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}

A.The code fails to compile at the “if” statement.
B.An exception is thrown at run-time at the “if” statement.
C.The text“true” is displayed.
D.The text“false”is displayed.
E.Nothing is displayed.
解析：Boolean修饰的变量为包装类型，初始化值为false,进行赋值时会调用Boolean.valueOf(boolean b)方法自动拆箱为基本数据类型，因此赋值后flag值为true，输出文本true。 如果使用==比较,则输出文本false。if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值

11.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
解析：这道题的知识点：子类中的方法覆盖父类的方法以后，由于向上转型，父类调用方法的时候是调用子类的，除非用super。
还有一个点就是在Try catch finally 体系当中，在return之前始终会执行finally里面的代码，如果finally里面有return，则数据跟随finally改变。如果没有return，则原数据不跟随finally里改变的数据改变！

12.下面不是面向对象的基本原则的是 C*
A.单一职责原则（Single-Resposibility Principle）
B.开放封闭原则（Open-Closed principle）
C.抽象类原则（Abstract-Class principle）
D.依赖倒置原则（Dependecy-Inversion Principle）
E.接口隔离原则（Interface-Segregation Principle）

13.下面哪个行为被打断不会导致InterruptedException：（ ）？ E*
A.Thread.join
B.Thread.sleep
C.Object.wait
D.CyclicBarrier.await
E.Thread.suspend
解析：suspendsuspend方法作用是阻塞一个线程，不会释放锁，直到其他的线程调用resume方法，才能继续向下执行。被打断不会导致InterruptedException。

14.关于Java以下描述正确的有( )//多选 CD*
A.Class类是Object类的超类
B.Object类是一个final类
C.String类是一个final类
D.Class类可以装载其它类

15.在使用super和this关键字时，以下描述错误的是（）//多选 BCD
A.在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B.super()和this()不一定要放在构造方法内第一行
C.this()和super()可以同时出现在一个构造函数中
D.this()和super()可以在static环境中使用，包括static方法和static语句块
解析：super和this都只能位于构造器的第一行，而且不能同时使用，这是因为会造成初始化两次，this用于调用重载的构造器，super用于调用父类被子类重写的方法

16.java中关于内存回收的正确说法是 B
A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序允许程序员直接释放内存
D.内存回收程序可以在指定的时间释放内存对象
解析：首先明确一点，java的GC回收是完全自动的，没有提供相关api手动回收，所有的内存分配和回收权限都在jvm，在开发人员手里没有绝对的强制垃圾回收的方法，不过可以这样去做：

1. 对于不再引用的对象，及时把它的引用赋为null。 obj = null;
2. 如果内存确实很紧张，调用System.gc() 方法来建议垃圾回收器开始回收垃圾，通知GC运行，但是Java语言规范并不保证GC一定会执行。

18.下面有个hibernate延迟加载，说法错误的是？ C*
A.Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
B.Hibernate3 提供了属性的延迟加载功能
C.get支持延迟加载，load不支持延迟加
D.hibernate使用Java反射机制，而不是字节码增强程序来实现透明性
解析： load方法来得到一个对象时，此时hibernate会使用延迟加载的机制来加载这个对象，即：当 我们使用session.load()方法来加载一个对象时，此时并不会发出sql语句，当前得到的这个对象其实是一个代理对象，这个代理对象只保存了实 体对象的id值，只有当我们要使用这个对象，得到其它属性时，这个时候才会发出sql语句，从数据库中去查询我们的对象。
相对于load的延迟加载方式，get就直接的多，当我们使用session.get()方法来得到一个对象时，不管我们使不使用这个对象，此时都会发出sql语句去从数据库中查询出来。

22.下面关于垃圾收集的说法正确的是 D*
A一旦一个对象成为垃圾，就立刻被收集掉。
B对象空间被收集掉之后，会执行该对象的finalize方法
C finalize方法和C++的析构函数是完全一回事情
D 一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此
解析：对象空间被收集前执行finalize（）方法，而不是对象空间被收集之后再执行，如果这样的话执行finalize（）就没有意义了。

25.jdbc的事务必须在一个数据库连接上完成。编程时必须去掉数据库的自动提交功能。当成功后调用commit，当失败后调用rollback。判断这句话正确与否 A
A.正确
B.错误

26.Which of the following can be applied to constructors: E*
A.final
B.static
C.synchronized
D.native
E.None of these.
解析：构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法。

28.下面有关java内存模型的描述，说法错误的是？ D*
A.JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证
B.“synchronized” — 保证在块开始时都同步主内存的值到工作内存，而块结束时将变量同步回主内存
C.“volatile” — 保证修饰后在对变量读写前都会与主内存更新。
D.如果在一个线程构造了一个不可变对象之后（对象仅包含final字段），就可以保证了这个对象被其他线程正确的查看
解析：Java线程之间的通信由Java内存模型（简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化
volatile变量的写-读可以实现线程之间的通信。
从内存语义的角度来说，volatile与监视器锁有相同的效果：volatile写和监视器的释放有相同的内存语义；volatile读与监视器的获取有相同的内存语义。

29.下面程序的运行结果（）D

Object obj=new Object();
        List aList=new ArrayList();
        List bList=new LinkedList();
         
        long t1=System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            aList.add(0,obj);
        }
        long t2=System.currentTimeMillis()-t1;
         
        t1=System.currentTimeMillis();
        for(int i=0;i<50000;i++){
            bList.add(0,obj);
        }
        long t3=System.currentTimeMillis()-t1; 

A.t2
B.t2=t3
C.不确定
D.t2>t3

30.下面有关servlet和cgi的描述，说法错误的是？ D*
A.servlet处于服务器进程中，它通过多线程方式运行其service方法
B.CGI对每个请求都产生新的进程，服务完成后就销毁
C.servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
D.cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi
解析：选择D，servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

31.有以下一个对象：D
public class DataObject implements Serializable{

    private static int i=0;
    private String word=" ";
    public void setWord(String word){
        this.word=word;
    }
    public void setI(int i){
        Data0bject. i=I;
     }
}

创建一个如下方式的DataObject:

DataObject object=new Data0bject ( );
object. setWord("123");
object. setI(2);

将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的Data0bject对象中的word和i的值分别为：
A."", 0
B."", 2
C.“123”, 2
D.“123”, 0
解析：这道题的答案应该是: D,序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的

32.以下对异常的描述不正确的有（）C
A.异常分为Error和Exception
B.Throwable是所有异常类的父类
C.Exception是所有异常类父类。
D.Exception包括RuntimeException和RuntimeException之外的异常。

34.对文件名为Test.java的java代码描述正确的是() C*

class Person {
    String name = "No name";
    public Person(String nm) {
        name = nm;
    }
}
class Employee extends Person {
    String empID = "0000";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

A.输出：0000
B.输出：123
C.编译报错
D.输出：No name

35.关于ThreadLocal类 以下说法正确的是//多选 DE
A.ThreadLocal继承自Thread
B.ThreadLocal实现了Runnable接口
C.ThreadLocal重要作用在于多线程间的数据共享
D.ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E.ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏
解析：ThreadLocal继承Object，相当于没继承任何特殊的。
ThreadLocal没有实现任何接口。
ThreadLocal并不是一个Thread，而是Thread的局部变量。

36.Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( )//多选 ADF
A.Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B.通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
C.通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
D.Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
E.Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
F.Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

37.下列哪种说法是正确的？ C*
A.实例方法可直接调用超类的实例方法
B.实例方法可直接调用超类的类方法
C.实例方法可直接调用本类的类方法
D.实例方法可直接调用其他类的实例方法

39.如下的Java程序 B*

public class Test { 
     public static void main(String[] args) { 
     System.out.println(args[0]); 
     } 
} 

A.Test
B.one
C.two
D.java

44.根据以下代码段，下列说法中正确的是( )。 C*

public class Parent {
    private void m1(){}
    void m2(){}
    protected void m3(){}
    public static void m4(){}
}

A.子类中一定能够继承和覆盖Parent类的m1方法
B.子类中一定能够继承和覆盖Parent类的m2方法
C.子类中一定能够继承和覆盖Parent类的m3方法
D.子类中一定能够继承和覆盖Parent类的m4方法

45.ResultSet中记录行的第一列索引为？ C*
A.-1
B.0
C.1
D.以上都不是

47.下面哪些情况下需要使用抽象类？//多选 ABD
A.当一个类的一个或多个方法是抽象方法时
B.当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
C.当一个类实现多个接口时
D.当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时
解析：抽象类：用abstract修饰，抽象类中可以没有抽象方法，但抽象方法肯定在抽象类中，且抽象方法定义时不能有方法体；抽象类不可以实例化只能通过继承在子类中实现其所有的抽象方法；抽象类如果不被继承就没有任何意义；抽象类为子类定义了一个公共类型，封装了子类中的重复内容。
接口:同Interface关键字定义接口，是特殊的抽象类因为类中只包含抽象方法；接口中不能定义成员变量可以定义常量；接口是其通过其他类使用implements关键字定义实现类，一个类一旦实现接口就必须实现其中的所有抽象方法，一个类可以实现多个接口，接口名之间用逗号隔开即可；一个接口可以通过extends关键字继承另一个接口，与此同时继承了父类中的所有方法。

48.关于抽象类与接口，下列说法正确的有？//多选 AC
A.优先选用接口，尽量少用抽象类
B.抽象类可以被声明使用，接口不可以被声明使用
C.抽象类和接口都不能被实例化。
D.以上说法都不对
解析：ac java只是单继承，但是可以实现多个接口，继承的耦合性太强，java推荐高内聚低耦合的设计思路，不推荐使用继承。在用继承的情况下，如果还必须要继承另外的接口会很麻烦，尽量用接口，这样在你必须要用到继承的时候就可以用了。抽象类和接口都不能被实例化。接口没有构造方法，不能被实例化，但是抽象方法可以有构造方法，不过不是用来实例化对象的，使用来初始化的。

49.下列说法正确的是（）？ AB
A.对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们
B.成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）
C.由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的
D.静态内部类可以访问外部类的成员变量

50.以下JAVA程序的运行结果是什么( ) D*

public static void main(String[] args) {
Object o1 = true ? new Integer(1) : new Double(2.0);
Object o2;
if (true) {
             o2 = new Integer(1);
} else {
o2 = new Double(2.0);
}
System.out.print(o1);
System.out.print(" ");         
System.out.print(o2);
}

A.1 1
B.1.0 1.0
C.1 1.0
D.1.0 1

51.下面有关java的引用类型，说法正确的有？//多选 ABCD
A.对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
B.如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
C.如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
D.一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间

52.下列流当中，属于处理流的是：（） //多选 CD
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream

53.下面有关Java的说法正确的是（ ）//多选 ACDF
A.一个类可以实现多个接口
B.抽象类必须有抽象方法
C.protected成员在子类可见性可以修改
D.通过super可以调用父类构造函数
E.final的成员方法实现中只能读取类的成员变量
F.String是不可修改的，且java运行环境中对string对象有一个对象池保存
解析：
A对：java类单继承，多实现
B错：被abstract修饰的类就是抽象类，有没有抽象方法无所谓
C错：描述有问题。protected成员在子类的可见性，我最初理解是子类（不继承父类protected成员方法）获取父类被protected修饰的成员属性或方法，可见性是不可能变的，因为修饰符protected就是描述可见性的。
这道题应该是要考察子类继承父类，并重写父类的protected成员方法，该方法的可见性可以修改，这是对的，因为子类继承父类的方法，访问权限可以相同或往大了改
D对。
E错：final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量
F对。

54.在为传统面向对象语言的程序做单元测试的时候,经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个特性？ A
A.封装
B.多态
C.继承
D.抽象

55.局部变量能否和成员变量重名？ A*
A.可以，局部变量可以与成员变量重名，这时可用“this”来指向成员变量
B.可以，这时可用“local”关键字来指向局部变量
C.不能，局部变量不能与成员变量重名
D.不能，在一个类中不能有重名变量，不管是成员变量还是函数中的局部变量

56.在 Applet 中，方法执行的顺序是 ?（ ） A
A.init(), start(), paint(),stop(),destroy().
B.init(),paint(),start(),stop(),destroy().
C.paint(),start(),stop(),destroy().
D.init(), start(),stop(),destroy(),paint().

58.结构型模式中最体现扩展性的模式是（）A*
A.装饰模式
B.合成模式
C.桥接模式
D.适配器
解析：设计模式分为三大类：
创建型设计模式：单例模式，工厂方法模式，简单工厂模式，建造者模式、原型模式
结构型设计模式：适配器模式，代理模式，AOP、装饰器模式、
行为型设计模式：观察者模、板方法模式

59.下面哪种情况会导致持久区jvm堆内存溢出？ C
A.循环上万次的字符串处理
B.在一段代码内申请上百M甚至上G的内存
C.使用CGLib技术直接操作字节码运行，生成大量的动态类
D.不断创建对象
解析：
持久代仅仅是HotSpot存在的一个概念，并且将其置于方法区中，本质上两者并不等价的。而方法区在《深入理解Java虚拟机》书中被称为非堆（Non-heap），目的就是要跟存放对象实例的Java堆区分开来，在方法区主要存放的是已经被虚拟机加载的类信息、常量、静态常量等数据。

60,如下代码，执行test()函数后，屏幕打印结果为（） D*

public class Test2
{
    public void add(Byte b)
    {
        b = b++;
    }
    public void test()
    {
        Byte a = 127;
        Byte b = 127;
        add(++a);
        System.out.print(a + " ");
        add(b);
        System.out.print(b + "");
    }
}

A.127 127
B.128 127
C.129 128
D.以上都不对
解析：public void add(Byte b){ b=b++; } 这里涉及java的自动装包/自动拆包(AutoBoxing/UnBoxing) Byte的首字母为大写，是类，看似是引用传递，但是在add函数内实现++操作，会自动拆包成byte值传递类型，所以add函数还是不能实现自增功能。也就是说add函数只是个摆设，没有任何作用。 Byte类型值大小为-128~127之间。 add(++a);这里++a会越界，a的值变为-128 add(b); 前面说了，add不起任何作用，b还是127

61.下面叙述那个是正确的？（）D*
A.java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
B.在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
C.java接口包含函数声明和变量声明。
D.java中，子类不可以访问父类的私有成员和受保护的成员。

62.关于Spring MVC的核心控制器DispatcherServlet的作用，以下说法错误的是（ ）？ B*
A.它负责处理HTTP请求
B.加载配置文件
C.实现业务操作
D.初始化上下应用对象ApplicationContext
解析：SpringMVC的原理：
SpringMVC是Spring中的模块，它实现了mvc设计模式的web框架，首先用户发出请求，请求到达SpringMVC的前端控制器（DispatcherServlet）,前端控制器根据用户的url请求处理器映射器查找匹配该url的handler，并返回一个执行链，前端控制器再请求处理器适配器调用相应的handler进行处理并返回给前端控制器一个modelAndView，前端控制器再请求视图解析器对返回的逻辑视图进行解析，最后前端控制器将返回的视图进行渲染并把数据装入到request域，返回给用户。
DispatcherServlet作为springMVC的前端控制器，负责接收用户的请求并根据用户的请求返回相应的视图给用户。
实现业务操作时在service层，所以C答案错误

63.关于中间件特点的描述.不正确的是（） C*
A.中间件运行于客户机/服务器的操作系统内核中，提高内核运行效率
B.中间件应支持标准的协议和接口
C.中间件可运行于多种硬件和操作系统平台上
D.跨越网络,硬件，操作系统平台的应用或服务可通过中间件透明交互
解析：中间件是一种独立的系统软件或服务程序，分布式应用软件借助这种软件在不同的技术之间共享资源。中间件位于客户机/ 服务器的操作系统之上，管理计算机资源和网络通讯。是连接两个独立应用程序或独立系统的软件。相连接的系统，即使它们具有不同的接口，但通过中间件相互之间仍能交换信息。执行中间件的一个关键途径是信息传递。通过中间件，应用程序可以工作于多平台或OS环境。
（简单来说，中间件并不能提高内核的效率，一般只是负责网络信息的分发处理）

64.下面这段代码，当 T 分别是引用类型和值类型的时候，分别产生了多少个 T 对象（） A*

T t = new T();
Func(t);

Func 定义如下：
public void Func(T t) { }
A.1 1
B.2 1
C.2 2
D.1 2
解析：引用类型作为函数的参数时，复制的是引用的地址，不会产生一个新的T；而如果T是值类型，其作为函数实参时会复制其值，也就是产生了一个新的T。

65.（）运算符和（）运算符分别把一个值的位向左和向右移动 A
A.<<
B.>>
C.&&
D.||

66.已知 boolean result = false，则下面哪个选项是合法的：AB
A.result=1
B.result=true;
C.if(result!=0) {//so something…}
D.if(result) {//do something…}

69.面向对象的最重要的特性是支持继承、封装和多态 ACD
A.系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
B.函数式的语言必然是面向对象的语言
C.面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
D.过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
E.Java和C++都是静态类型的面向对象编程语言

71.Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( ) ACE
A.Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
B.通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
C.通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
D.Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
E.Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
F.Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率
解析：反射指的是在运行时能够分析类的能力的程序。
反射机制可以用来：
1.在运行时分析类的能力–检查类的结构–所用到的就是java.lang.reflect包中的Field、Method、Constructor，分别用于描述类的与、方法和构造器。A中的Class类在java.lang中。
2.在运行时查看对象。
3.实现通用的数组操作代码。
反射机制的功能：
在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
反射机制常见作用：
动态加载类、动态获取类的信息（属性、方法、构造器）；动态构造对象；动态调用类和对象的任意方法、构造器；动态调用和处理属性；获取泛型信息（新增类型：ParameterizedType,GenericArrayType等）；处理注解（反射API:getAnnotationsdeng等）。
反射机制性能问题：
反射会降低效率。
void setAccessible(boolean flag):是否启用访问安全检查的开关，true屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置。禁止安全检查，可以提高反射的运行速度

72.以下不属于构造方法特征的是（） ADF
A.构造方法名与类名相同
B.构造方法不返回任何值，也没有返回类型
C.构造方法在创建对象时调用，其他地方不能显式地直接调用
D.每一个类只能有一个构造方法
解析：这道题目感觉有很多模糊又不明确的地方，题目质量不好。
A：一个类里面多个内部类，构造方法名是与和.java文件同名的public类名。内部类也是类，构造方法名和内部类名不同。
B:构造方法不返回任何值，也没有返回类型。无异议。
C：子类在构造方法里面调用父类的构造方法时，会在第一行使用“super(参数列表)”显示调用父类的构造方法。这里是显示地直接调用，而且没有创建新对象。
D：每一个和.java文件同名的public类可以有多个构造方法，构造方法允许重载。内部类也可以有多个构造方法，而匿名内部类一个构造方法都没有。

73.下面程序的输出是:() D*

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

A.FmNwxy
B.fmnwxy
C.wxyfmn
D.Fmnwxy

---

1. 1-9 ↩︎

2. 1-9 ↩︎