中软测试题.docx
《中软测试题.docx》由会员分享，可在线阅读，更多相关《中软测试题.docx（16页珍藏版）》请在冰豆网上搜索。
中软测试题
中软的一次试题：
1.请说明下面代码的执行结果：
bytea=1;
byteb=1;
bytec=a+b;
System.out.println（c）;
2.-2>>3结果是多少？
3.一个ArrayList的引用ArrayList还是List好？
为什么？
4.类方法与实例方法有什么区别？
5.Hashtable和HashMap有何区别？
6.单例模式有几种实现方式？
举例说明
7.Socket编程有哪两种模式？
8.JSP和Servlet有何区别？
9.Java语言中是怎样实现多线程的？
请说明Synchronized，volatile，ThreadLocal的区别？
说明wait、sleep、join方法的区别
10.TCP/IP分几层？
11.Java是用什么进行垃圾处理的？
列出你所知道的垃圾收集器的实现方式
12.请说明TCP/IP三次握手过程
13.举例说明Linux常用命令
14.什么是序列化？
Java是怎样实现序列化的
15.说明heap和stack的区别
16.编程对任意一组数进行排序，使用冒泡程序
类方法与实例方法有什么区别
有时候我们对静态方法和实例化方法会有一些误解。
1、大家都以为“静态方法常驻内存，实例方法不是，所以静态方法效率高但占内存。
”
事实上，他们都是一样的，在加载时机和占用内存上，静态方法和实例方法是一样的，在类型第一次被使用时加载。
调用的速度基本上没有差别。
2、大家都以为“静态方法在堆上分配内存，实例方法在堆栈上”
事实上所有的方法都不可能在堆或者堆栈上分配内存，方法作为代码是被加载到特殊的代码内存区域，这个内存区域是不可写的。
方法占不占用更多内存，和它是不是static没什么关系。
因为字段是用来存储每个实例对象的信息的，所以字段会占有内存，并且因为每个实例对象的状态都不一致（至少不能认为它们是一致的），所以每个实例对象的所以字段都会在内存中有一分拷贝，也因为这样你才能用它们来区分你现在操作的是哪个对象。
但方法不一样，不论有多少个实例对象，它的方法的代码都是一样的，所以只要有一份代码就够了。
因此无论是static还是non-static的方法，都只存在一份代码，也就是只占用一份内存空间。
同样的代码，为什么运行起来表现却不一样？
这就依赖于方法所用的数据了。
主要有两种数据来源，一种就是通过方法的参数传进来，另一种就是使用class的成员变量的值……
3、大家都以为“实例方法需要先创建实例才可以调用，比较麻烦，静态方法不用，比较简单”
事实上如果一个方法与他所在类的实例对象无关，那么它就应该是静态的，而不应该把它写成实例方法。
所以所有的实例方法都与实例有关，既然与实例有关，那么创建实例就是必然的步骤，没有麻烦简单一说。
当然你完全可以把所有的实例方法都写成静态的，将实例作为参数传入即可，一般情况下可能不会出什么问题。
从面向对象的角度上来说，在抉择使用实例化方法或静态方法时，应该根据是否该方法和实例化对象具有逻辑上的相关性，如果是就应该使用实例化对象反之使用静态方法。
这只是从面向对象角度上来说的。
如果从线程安全、性能、兼容性上来看也是选用实例化方法为宜。
我们为什么要把方法区分为：
静态方法和实例化方法？
如果我们继续深入研究的话，就要脱离技术谈理论了。
早期的结构化编程，几乎所有的方法都是“静态方法”，引入实例化方法概念是面向对象概念出现以后的事情了，区分静态方法和实例化方法不能单单从性能上去理解，创建c++,java,c#这样面向对象语言的大师引入实例化方法一定不是要解决什么性能、内存的问题，而是为了让开发更加模式化、面向对象化。
这样说的话，静态方法和实例化方式的区分是为了解决模式的问题。
拿别人一个例子说事：
比如说“人”这个类，每个人都有姓名、年龄、性别、身高等，这些属性就应该是非静态的，因为每个人都的这些属性都不相同；但人在生物学上属于哪个门哪个纲哪个目等，这个属性是属于整个人类，所以就应该是静态的——它不依赖与某个特定的人，不会有某个人是“脊椎动物门哺乳动物纲灵长目”而某个人却是“偶蹄目”的。
拓展：
JAVA中构造方法，实例方法，类方法，有什么区别？
构造方法：
构造方法是用来构造类的对象的，方法名和类名相同没有返回值。
一般用new构造方法名（）来创建该类的对象。
在不写构造方法的情况下会有一个默认的无参构造方法，当然你也可以重写和重载构造方法（建议你找一本《Java编程思想》看看，里面讲的很透彻）。
实例方法：
简单地说就是可以通过类的实例（某个对象）调用的方法，也就是我们正常情况下使用的方法。
实例方法也称成员方法（成员方法和成员变量的知识你可以参考《Java编程思想》）。
类方法：
简单地说就是直接可以用类名调用的方法，也就是被关键字static修饰的方法，它不需要创建类的对象来调用该方法。
（关于static关键字的详细用法你也可以在《Java编程思想》这本书中找到）。
HashTable和HashMap的区别
HashTable的应用非常广泛，HashMap是新框架中用来代替HashTable的类，也就是说建议使用HashMap，不要使用HashTable。
可能你觉得HashTable很好用，为什么不用呢？
这里简单分析他们的区别。
1.HashTable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。
2.HashTable不允许null值（key和value都不可以）,HashMap允许null值（key和value都可以）。
3.HashTable有一个contains（Objectvalue），功能和containsValue（Objectvalue）功能一样。
4.HashTable使用Enumeration，HashMap使用Iterator。
以上只是表面的不同，它们的实现也有很大的不同。
5.HashTable中hash数组默认大小是11，增加的方式是old*2+1。
HashMap中hash数组的默认大小是16，而且一定是2的指数。
6.哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：
inthash=key.hashCode（）;
intindex=（hash&0x7FFFFFFF）%tab.length;
而HashMap重新计算hash值，而且用与代替求模：
inthash=hash（k）;
inti=indexFor（hash,table.length）;
staticinthash（Objectx）{
inth=x.hashCode（）;
h+=~（h<<9）;
h^=（h>>>14）;
h+=（h<<4）;
h^=（h>>>10）;
returnh;
}
staticintindexFor（inth,intlength）{
returnh&（length-1）;
}
以上只是一些比较突出的区别，当然他们的实现上还是有很多不同的，比如
HashMap对null的操作。
单例模式有几种实现方式？
举例说明
在GoF的23种设计模式中，单例模式是比较简单的一种。
然而，有时候越是简单的东西越容易出现问题。
下面就单例设计模式详细的探讨一下。
所谓单例模式，简单来说，就是在整个应用中保证只有一个类的实例存在。
就像是JavaWeb中的application，也就是提供了一个全局变量，用处相当广泛，比如保存全局数据，实现全局性的操作等。
1.最简单的实现
首先，能够想到的最简单的实现是，把类的构造函数写成private的，从而保证别的类不能实例化此类，然后在类中提供一个静态的实例并能够返回给使用者。
这样，使用者就可以通过这个引用使用到这个类的实例了。
publicclassSingletonClass{
privatestaticfinalSingletonClassinstance=newSingletonClass（）;
publicstaticSingletonClassgetInstance（）{
returninstance;
}
privateSingletonClass（）{
}
}
如上例，外部使用者如果需要使用SingletonClass的实例，只能通过getInstance（）方法，并且它的构造方法是private的，这样就保证了只能有一个对象存在。
2.性能优化——lazyloaded
上面的代码虽然简单，但是有一个问题——无论这个类是否被使用，都会创建一个instance对象。
如果这个创建过程很耗时，比如需要连接10000次数据库（夸张了…：
-）），并且这个类还并不一定会被使用，那么这个创建过程就是无用的。
怎么办呢？
为了解决这个问题，我们想到了新的解决方案：
publicclassSingletonClass{
privatestaticSingletonClassinstance=null;
publicstaticSingletonClassgetInstance（）{
if（instance==null）{
instance=newSingletonClass（）;
}
returninstance;
}
privateSingletonClass（）{
}
}
代码的变化有两处——首先，把instance初始化为null，直到第一次使用的时候通过判断是否为null来创建对象。
因为创建过程不在声明处，所以那个final的修饰必须去掉。
我们来想象一下这个过程。
要使用SingletonClass，调用getInstance（）方法。
第一次的时候发现instance是null，然后就新建一个对象，返回出去;第二次再使用的时候，因为这个instance是static的，所以已经不是null了，因此不会再创建对象，直接将其返回。
这个过程就成为lazyloaded，也就是迟加载——直到使用的时候才进行加载。
3.同步
上面的代码很清楚，也很简单。
然而就像那句名言：
“80%的错误都是由20%代码优化引起的”。
单线程下，这段代码没有什么问题，可是如果是多线程，麻烦就来了。
我们来分析一下：
线程A希望使用SingletonClass，调用getInstance（）方法。
因为是第一次调用，A就发现instance是null的，于是它开始创建实例，就在这个时候，CPU发生时间片切换，线程B开始执行，它要使用SingletonClass，调用getInstance（）方法，同样检测到instance是null——注意，这是在A检测完之后切换的，也就是说A并没有来得及创建对象——因此B开始创建。
B创建完成后，切换到A继续执行，因为它已经检测完了，所以A不会再检测一遍，它会直接创建对象。
这样，线程A和B各自拥有一个SingletonClass的对象——单例失败！
解决的方法也很简单，那就是加锁：
publicclassSingletonClass{
privatestaticSingletonClassinstance=null;
publicsynchronizedstaticSingletonClassgetInstance（）{
if（instance==null）{
instance=newSingletonClass（）;
}
returninstance;
}
privateSingletonClass（）{
}
}
是要getInstance（）加上同步锁，一个线程必须等待另外一个线程创建完成后才能使用这个方法，这就保证了单例的唯一性。
4.又是性能
上面的代码又是很清楚很简单的，然而，简单的东西往往不够理想。
这段代码毫无疑问存在性能的问题——synchronized修饰的同步块可是要比一般的代码段慢上几倍的！
如果存在很多次getInstance（）的调用，那性能问题就不得不考虑了！
让我们来分析一下，究竟是整个方法都必须加锁，还是仅仅其中某一句加锁就足够了？
我们为什么要加锁呢？
分析一下出现lazyloaded的那种情形的原因。
原因就是检测null的操作和创建对象的操作分离了。
如果这两个操作能够原子地进行，那么单例就已经保证了。
于是，我们开始修改代码：
publicclassSingletonClass{
privatestaticSingletonClassinstance=null;
publicstaticSingletonClassgetInstance（）{
synchronized（SingletonClass.class）{
if（instance==null）{
instance=newSingletonClass（）;
}
}
returninstance;
}
privateSingletonClass（）{
}
}
首先去掉getInstance（）的同步操作，然后把同步锁加载if语句上。
但是这样的修改起不到任何作用：
因为每次调用getInstance（）的时候必然要同步，性能问题还是存在。
如果……如果我们事先判断一下是不是为null再去同步呢？
publicclassSingletonClass{
privatestaticSingletonClassinstance=null;
publicstaticSingletonClassgetInstance（）{
if（instance==null）{
synchronized（SingletonClass.class）{
if（instance==null）{
instance=newSingletonClass（）;
}
}
}
returninstance;
}
privateSingletonClass（）{
}
}
还有问题吗？
首先判断instance是不是为null，如果为null，加锁初始化;如果不为null，直接返回instance。
这就是double-checkedlocking设计实现单例模式。
到此为止，一切都很完美。
我们用一种很聪明的方式实现了单例模式。
5.从源头检查
下面我们开始说编译原理。
所谓编译，就是把源代码“翻译”成目标代码——大多数是指机器代码——的过程。
针对Java，它的目标代码不是本地机器代码，而是虚拟机代码。
编译原理里面有一个很重要的内容是编译器优化。
所谓编译器优化是指，在不改变原来语义的情况下，通过调整语句顺序，来让程序运行的更快。
这个过程成为reorder。
要知道，JVM只是一个标准，并不是实现。
JVM中并没有规定有关编译器优化的内容，也就是说，JVM实现可以自由的进行编译器优化。
下面来想一下，创建一个变量需要哪些步骤呢？
一个是申请一块内存，调用构造方法进行初始化操作，另一个是分配一个指针指向这块内存。
这两个操作谁在前谁在后呢？
JVM规范并没有规定。
那么就存在这么一种情况，JVM是先开辟出一块内存，然后把指针指向这块内存，最后调用构造方法进行初始化。
下面我们来考虑这么一种情况：
线程A开始创建SingletonClass的实例，此时线程B调用了getInstance（）方法，首先判断instance是否为null。
按照我们上面所说的内存模型，A已经把instance指向了那块内存，只是还没有调用构造方法，因此B检测到instance不为null，于是直接把instance返回了——问题出现了，尽管instance不为null，但它并没有构造完成，就像一套房子已经给了你钥匙，但你并不能住进去，因为里面还没有收拾。
此时，如果B在A将instance构造完成之前就是用了这个实例，程序就会出现错误了！
于是，我们想到了下面的代码：
publicclassSingletonClass{
privatestaticSingletonClassinstance=null;
publicstaticSingletonClassgetInstance（）{
if（instance==null）{
SingletonClasssc;
synchronized（SingletonClass.class）{
sc=instance;
if（sc==null）{
synchronized（SingletonClass.class）{
if（sc==null）{
sc=newSingletonClass（）;
}
}
instance=sc;
}
}
}
returninstance;
}
privateSingletonClass（）{
}
}
我们在第一个同步块里面创建一个临时变量，然后使用这个临时变量进行对象的创建，并且在最后把instance指针临时变量的内存空间。
写出这种代码基于以下思想，即synchronized会起到一个代码屏蔽的作用，同步块里面的代码和外部的代码没有联系。
因此，在外部的同步块里面对临时变量sc进行操作并不影响instance，所以外部类在instance=sc;之前检测instance的时候，结果instance依然是null。
不过，这种想法完全是错误的！
同步块的释放保证在此之前——也就是同步块里面——的操作必须完成，但是并不保证同步块之后的操作不能因编译器优化而调换到同步块结束之前进行。
因此，编译器完全可以把instance=sc;这句移到内部同步块里面执行。
这样，程序又是错误的了！
6.解决方案
说了这么多，难道单例没有办法在Java中实现吗？
其实不然！
在JDK5之后，Java使用了新的内存模型。
volatile关键字有了明确的语义——在JDK1.5之前，volatile是个关键字，但是并没有明确的规定其用途——被volatile修饰的写变量不能和之前的读写代码调整，读变量不能和之后的读写代码调整！
因此，只要我们简单的把instance加上volatile关键字就可以了。
publicclassSingletonClass{
privatevolatilestaticSingletonClassinstance=null;
publicstaticSingletonClassgetInstance（）{
if（instance==null）{
synchronized（SingletonClass.class）{
if（instance==null）{
instance=newSingletonClass（）;
}
}
}
returninstance;
}
privateSingletonClass（）{
}
}
然而，这只是JDK1.5之后的Java的解决方案，那之前版本呢？
其实，还有另外的一种解决方案，并不会受到Java版本的影响：
publicclassSingletonClass{
privatestaticclassSingletonClassInstance{
privatestaticfinalSingletonClassinstance=newSingletonClass（）;
}
publicstaticSingletonClassgetInstance（）{
returnSingletonClassInstance.instance;
}
privateSingletonClass（）{
}
}
在这一版本的单例模式实现代码中，我们使用了Java的静态内部类。
这一技术是被JVM明确说明了的，因此不存在任何二义性。
在这段代码中，因为SingletonClass没有static的属性，因此并不会被初始化。
直到调用getInstance（）的时候，会首先加载SingletonClassInstance类，这个类有一个static的SingletonClass实例，因此需要调用SingletonClass的构造方法，然后getInstance（）将把这个内部类的instance返回给使用者。
由于这个instance是static的，因此并不会构造多次。
由于SingletonClassInstance是私有静态内部类，所以不会被其他类知道，同样，static语义也要求不会有多个实例存在。
并且，JSL规范定义，类的构造必须是原子性的，非并发的，因此不需要加同步块。
同样，由于这个构造是并发的，所以getInstance（）也并不需要加同步。
至此，我们完整的了解了单例模式在Java语言中的时候，提出了两种解决方案。
个人偏向于第二种，并且EffiectiveJava也推荐的这种方式。
JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？
JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。
JSP编译后是"类servlet"。
Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。
而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。
JSP侧重于视图，Servlet主要用于控制逻辑。
jsp是发展自servlet的一种技术，具体地说，jsp是在html里插入java代码，而servlet的纯java代码，那么jsp有什么好处的，是这样的，以前使用纯java代码的servlet来开发动态网页就会造成一个问题，即页面开发者，也就是设计页面的美工也必须懂java语言，即能设计出好看的网页，又能写出健壮的代码的人是很少的，所以必须想办法把任务分开，于是jsp技术被推了出来，它是对servlet技术的一次改进，美工负责html，然后交给java程序员来嵌入代码。
其实，在功能上jsp并没有其他的改进，jsp最终要被servlet容器（比如tomcat，weblogic）翻译成servlet，然后java虚拟机再去编译成.class
最后去执行，然后容器把执行结果再翻译成纯html，发送给客户端的浏览器。
TCP/IP协议的体系结构分为哪几层？
每层的功能？
TCP/IP协议并不完全符合OSI的七层参考模型。
传统的开放式系统互连参考模型，是一种通信协议的7层抽象的参考模型,其中每一层执行某一特定任务。
该模型的目的是使各种硬件在相同的层次上相互通信。
这7层是:
物理层、数据链路层、网路层、传输层、话路层、表示层和应用层。
而TCP/IP通讯协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。
这4层分别为：
●应用层：
应用程序间沟通的层，如简单电子邮件传输（SMTP）、文件传输协议（FTP）、网络远程访问协议（Telnet）等。
●传输层：
在此层中，它提供了节点间的数据传送服务，如传输
升级会员 