（一）Java部分
1、列举出JAVA中6个比较常用的包【天威诚信面试题】
【参考答案】
java.lang;java.util;java.io;java.sql;java.awt;java.net;javax.swing
2、JDK中哪些类是不能继承的？【信雅达面试题】
【参考答案】
不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的。
3、String是最基本的数据类型吗?【天能智健面试题】
【参考答案】
基本数据类型包括byte、int、char、long、float、double、boolean和short。
所以String不属于基本数据类型范畴内，但String属于最常见一种引用类型。
4、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?【博炎科技面试题】
【参考答案】
对于short s1 = 1; s1 = s1 + 1;由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器会提示错误，需要强制转换类型。
对于short s1 = 1; s1 += 1;由于+=是java语言规定的运算符，Java编译器会对它进行特殊处理，因此可以正确编译。
【分析】
主要考查几种基本数据类型在运算时的，由低到高会自动转换，而由高到低时会强制转换。
5、Java对象初始化顺序？【腾鹏科技面试题】
【参考答案】
分为两种，一种是本类的初始化，一种是含有父类的初始化顺序。这里分开来说，
本类的初始化顺序是：静态变量、静态初始化块、变量、初始化块、构造函数
继承类的初始化顺序是：父类静态变量、父类静态初始化块、子类静态变量、子类静态初始块、父类变量、父类初始化块、父类构造函数、子类变量、子类初始化块、子类构造函数。
【分析】
static{
System.out.println("静态块");
}
{
System.out.println("初始化模块"); }
public ClassName() {
System.out.println("构造方法");
}
说明：
原则上回答全面的话，应该是完整的说出带有继承的这种类的初始化过程，下面有个步骤可以参考：
1.装载程序的时候首先找到的是它的基（父）类,如果有多层基（父）类则会一级一级的往上找最后找到根基（父）类。
2.执行根基础（父）类中的static初始化,再执行下一个衍生类中的static,依此类推,一直保持这个顺序。
3.此时类已经装载完毕,开始创建对象,所有的基本数据类型都会设成它们的默认值,对象句柄设为null
4.调用基础（父）类的构造方法,基础（父）类的构建采用与衍生类构造方法完全相同的处理过程。
5.构造方法初始完之后,进行变量的初始化。
6.执行构造方法中剩余的部分。
6、写几个线程安全类，不安全的，支持排序的类名？【软通动力面试题】
【参考答案】
Ø线程安全类：Vector、Hashtable、Stack。
Ø线程不安全的类：ArrayList、Linkedlist、HashSet、TreeSet、HashMap、TreeMap等。
Ø支持排序的类有HashSet、LinkedHashSet、TreeSet等（Set接口下的实现都支持排序）
【分析】
此题主要考查集合框架的知识。在集合框架中Collection接口为集合的根类型，提供集合操作的常用API方法，该接口下派生出两个子接口，一个是不支持排序的List接口，一个是有自身排序的Set接口，所以回答排序与不排序分别从两接口的实现中在作答。线程安全上来说，Vector类比同属于List接口的ArrayList要早，是一个线程安全的类，在JDK1.2以后才推出一个异步的ArrayList类，比Vector类效率高。同理Stack继承自Vector也线程安全的类，另外在在Map接口的实现在Hashtable也是个线程安全的类。
7、哪几个方法可以实现一个线程？【上海华信面试题】
【参考答案】
一是继承Thread，重写Thread类的方法run方法；另种是实现runnable接口并实现run方法。
【分析】
考查线程的基本实现，很多公司喜欢考查这方面知识，另外补充一下关于线程的run方法，在多线程API中启动一个线程是调用start()方法，线程进入就绪状态。
8、STOP()和SUSPEND()不推荐使用的原因？
【参考答案】
stop()是因为它不安全。它会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，假如一个线程正在执行：synchronized void { x = 3; y = 4;}由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记线程的stop方法，以后我们再也不要说“停止线程”了。而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。
suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
【分析】
9、"=="和equals方法有什么区别？【中科软】
【参考答案】
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input =…;input.equals(“quit”)，如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
10、静态变量和实例变量的区别？
【参考答案】
在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。
public class VariantTest
{
public static int staticVar = 0;
public int instanceVar = 0;
public VariantTest()
{
staticVar++;
instanceVar++;
System.out.println(“staticVar=”+ staticVar +”,instanceVar=”+ instanceVar);
}
}
备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！
11、构造器的名能不能和类的名字相同？
【参考答案】
构造器的名称必须与类名相同。
【分析】
构造器或构造函数（有些书这样叫）主要用来对类的成员变量进行初始化，当类创建实例时调用。
12、在一个主方法类可不可以调用一个非静态的方法？
【参考答案】
可以调用。因为Java的主方法（main）方法本身也是static类型方法，一个static类型方法，发起对另一个static方法的调用没有问题。
【分析】
静态方法可以调用其它的静态方法，但是不能调用非静态方法，这个好比Java中的类变量与实例变量的关系。类变量是被所有类成员共享，而实例变量只被该实例共享，
13、一个类中可不可以有2个公共的方法？
【参考答案】
可以。Java中对公共方法的个数没有约束，但是对公共的类有约束，一个Java源文件中只能定义一个public类型的类。
14、GC是什么，为什么要使用它？【阿斯拓】
【参考答案】
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域，从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
【分析】
15、说一下垃圾回收的原理，可以直接从内存中回收吗?
【参考答案】
Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收,因为Java语言规范并不保证GC一定会执行。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
【分析】
16、Java的异常有哪几种，有什么区别？
【参考答案】
两大类，一般异常和运行时异常。一般异常，这些异常是在定义方法时声明抛出的，这些异常必需用try catch抛出，或throws处理，如果不处理，程序将编译失败。比如：IOException、FileNotFoundException、SQLException等。
运行时异常是程序运行时可能报出的异常。可以用try catch抓取，也可以不做任何处理。例如：NullPointerException异常就是一种比较常见的运行时异常。
【分析】
17、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
【参考答案】
在switch（表达式）中，括号表达式只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。
18、Integer与int的区别？
【参考答案】
int是java提供的8种原始数据类型之一，另外Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。
19、Java Reflection是什么？【】
【参考答案】
JAVA反射，Reflection是Java程序开发语言的特征之一，它允许运行中的Java程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。
【分析】
20、写几个java.lang.Object类中的方法名称。
【参考答案】
主要有equals()、toString()、getClass()、hashCode()、clone()、notify()、wait()、notify()方法。
【分析】
这种题能记多少个就说多少个，不一定要求你所有的都记住，但是要理解其中部分重要方法的含义和作用。
21、&和&&的区别？
【参考答案】
&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。
&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位。
【分析】
先说分别说两者的作用，再说出&&和&各自的不同之处。
22、数组有没有length()这个方法，String有没有length()这个方法。
【参考答案】
数组没有length()方法，但有length属性
String有length()方法。
【分析】
考查平时使用数组和字符串的一些细节，一般在使用
23、String s=new String(“xyz”)创建了几个对象
【参考答案】
2个string对象,一个是=null的s，一个是=“xyz”的string
两个或一个”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。
【分析】
24、能不能自己写个类，也叫java.lang.String？
可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。
虽然java提供了endorsed技术，可以覆盖jdk中的某些类，具体做法是….。但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。
例如，运行下面的程序：
package java.lang;
public class String {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("string");
}
}
报告的错误如下：
java.lang.NoSuchMethodError: main
Exception in thread "main"
这是因为加载了jre自带的java.lang.String，而该类中没有main方法。
25、你对面向对象思想的理解？
【参考答案】
面向对象编程（Object-Oriented Programming）简称OOP技术，是开发计算机应用程序的一种新方法、新思想。过去的面向过程编程中常常会导致所有的代码都包含在几个模块中，使程序难以阅读和维护，在做一些修改时常常牵一动百，使以后的开发和维护难以为继。而使用OOP技术，使用许多代码模块，每个模块都只提供特定的功能，它们是彼此独立的，可以增加代码重用的几率，更加有利于软件的开发、维护和升级。另外OOP的三大核心特性：继承、封装、多态的特性，使得在面对象编上能够设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低，所以这一编程思想是目前一种应用最为普遍的软件设计思想。
【分析】
26、最常见的runtime exception运行时异常？
【参考答案】
ClassCastException（类型转换异常）、NumberFormatException（格式化异常）、
ArrayIndexOutOfBoundsException（数组越界异常）、ArithmeticException（算术异常）、NullPointerException（空指针异常）等等
【分析】
这道题主要考查大家平时在项目开发过程中经常遇到的一些异常类型信息，通过这些异常来考查大家的项目经验与项目排错能力。
27、用JDBC来实现访问数据库记录可以采用下面的几个步骤：
【参考答案】
1、通过驱动器管理器获取连接接口（Connection）。
2、获得Statement或它的子类。
3、指定Statement中的参数。
4、通过Statement发送SQL语句。
5、检查并处理返回的结果。
6、关闭Statement。
7、关闭连接接
【分析】
28、Error和exception的区别与联系？
【参考答案】
error表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等，不可能指望程序能处理的一类错误。
Exception表示一种由程序设计或实现问题，像我们常说的异常处理，就是属于这类，一般程序可以捕获和处理这些异常。
【分析】
这道题的难点在Error很多时候由于我们无法重现这种Error导致很多同学甚至不知道Error到底是什么，所以很容易把题目中的两种错误划上等号。
29、String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？
【参考答案】
没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是"Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即StringBuffer。
30、Jdk1.5的新特性？
【参考答案】
JDK1.5的一个重要主题就是通过新增一些特性来简化开发，这些特性主要包括：泛型、ForEach循环、自动装包/拆包、枚举、可变参数、静态导入这些。
【分析】
31、面向对象的特征有哪些方面？
【参考答案】
面向对象的编程语言有封装、继承、多态等3个主要的特征。
u封装
封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。
u继承
在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
u多态
多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。
32、JVM工作原理？
运行jvm字符码的工作是由解释器来完成的。解释执行过程分三步进行：
代码的装入、代码的校验、和代码的执行。
装入代码的工作由“类装载器class loader”完成。类装载器负责装入运行一个程序需要的所有代码，这也包括程序代码中的类所继承的类和被调用的类。当类装载器装入一个类时，该类被放在自己的名字空间中。除了通过符号引用自己名字空间以外的类，类之间没有其他办法可以影响其他类。在本台计算机的所有类都在同一地址空间中，而所有从外部引进的类，都有一个自己独立的名字空间。这使得本地类通过共享相同的名字空间获得较高的运行效率，同时又保证它们与从外部引进的类不会相互影响。当装入了运行程序需要的所有类后，解释器便可确定整个可执行程序的内存布局。解释器为符号引用与特定的地址空间建立对应关系及查询表。通过在这一阶段确定代码的内布局，java很好地解决了由超类改变而使子类
崩溃的问题，同时也防止了代码的非法访问。随后，被装入的代码由字节码校验器进行检查。校验器可以发现操作数栈益处、非法数据类型转化等多种错误。通过校验后，代码便开始执行了。
Java字节码的执行有两种方式：
1）即时编译方式：解释器先将字节编译成机器码，然后再执行该机器码。
2）解释执行方式：解释器通过每次解释并执行一小段代码来完成java字节。
码程序的所有操作。
33、说说Java中的内存分配?
Java把内存分成两种，一种叫做栈内存，一种叫做堆内存
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作它用。
堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。
引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。但是在写程序的时候，可以人为的控制。
34、final, finally, finalize的区别。
【参考答案】
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用
35、Extends和Implement的不同？
【参考答案】
extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了
比如class A extends B implements C,D,E
36、抽象类是否可以没有抽象方法？为什么？
【参考答案】
可以在java中用abstract关键字来修饰一个类时，这个类叫做抽象类。
抽象类中不一定要包含abstract方法，但一个类中包含了abstract方法，则这个类必须声明为abstract类。
37、静态的多态和动态的多态的区别？
【参考答案】
静态的多态:即为重载；方法名相同，参数个数或类型不相同。(overloading)
动态的多态:即为重写；子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法实现接口的实例传与接口的引用调用的实现类的方法。
38、说出一些常用的类，包，接口，请各举5个?
【参考答案】
常用的类：String、StringBuffer、Integer、Vector、ArrayList、Hashtable等
常用的包：java.lang java.io java.util、java.sql。
常用的接口：集合中的List、Set、Map接口；与Servlet API相关的Servlet接口、HttpServletRequest,HttpServletResponse,HttpSession接口等。
39、Collections和Collection的区别【天晟科技】
【参考答案】
Collection是个java.util下的接口，它是各种集合结构的父接口，定义了集合对象的基本操作方法。Collections是个java.util下的工具类，它包含有各种有关集合操作的静态方法，主要是针对集合类的一个帮助类或者叫包装类，它提供一系列对各种集合的搜索，排序，线程安全化等操作方法。
40、Class.forName的作用?为什么要用?
【参考答案】
按参数中指定的字符串形式的类名去搜索并加载相应的类，如果该类字节码已经被加载过，则返回代表该字节码的Class实例对象，否则，按类加载器的委托机制去搜索和加载该类，如果所有的类加载器都无法加载到该类，则抛出ClassNotFoundException。加载完这个Class字节码后，接着就可以使用Class字节码的newInstance方法去创建该类的实例对象了。有时候，我们程序中所有使用的具体类名在设计时（即开发时）无法确定，只有程序运行时才能确定，这时候就需要使用Class.forName去动态加载该类，这个类名通常是在配置文件中配置的，例如，spring的ioc中每次依赖注入的具体类就是这样配置的，jdbc的驱动类名通常也是通过配置文件来配置的，以便在产品交付使用后不用修改源程序就可以更换驱动类名。
41、Socket如何获取本地ip地址？
【参考答案】
InetAddress类提供的API来访问。InetAddress.getLocalAddress()
【分析】
42、接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类【天威诚信面试题】
【参考答案】
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承具体类。抽象类中可以有静态的main方法。
备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是java语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。
只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。
43、用最有效率的方法算出2乘以8等於几?
【参考答案】
2 << 3
【分析】
因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以2乘以8等於几的最效率的方法是2 << 3。
44、char型变量中能不能存贮一个中文汉字?为什么?
【参考答案】
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
45、写clone()方法时，通常都有一行代码，是什么？
【参考答案】
clone有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。
46、说说常用集合类有哪些？有哪些方法？
【参考答案】
通常我们使用的集合类都大多是由List、Set、Map这三类接口派生出来的类，例如：
ArrayList、Vector、LinkedList、Stack、TreeSet、Hashtable、HashMap等
集合类的大部分方法都是由Collection接口定义的，主要包括有：
add(Ee)、remove(Object e)、addAll(),remove()、contains(Object obj)、clear()等
47、请说出作用域public，private，protected，以及不写时的区别?【天威诚信面试题】
【参考答案】
这四个作用域的可见范围如下表所示。
说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly。
作用域同一类同一package子孙类其他package
public√√√√
protected√√√×
friendly√√××
private√×××
备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。
48、构造器Constructor是否可被override?【亿阳通讯面试题】
【参考答案】
构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。
49、是否可以从一个static方法内部发出对非static方法的调用？【世承软件面试题】
【参考答案】
不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。
50、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?【雾隐美地传媒】
【参考答案】
Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整，所以，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，所以，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
51、abstract class（抽象类）和interface（接口）有什么区别?【百度应用中心面试题】
【参考答案】
含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5.抽象类中可以包含静态方法，接口中不能包含静态方法
6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7.一个类可以实现多个接口，但只能继承一个抽象类。
下面接着再说说两者在应用上的区别：
【分析】
这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等方面来回答。
52、Collection框架中实现比较要实现什么接口?
【参考答案】
Comparable、Comparator接口
53、是否可以继承String类?
【参考答案】
String类是final类故不可以继承。
54、String和StringBuffer的区别
【参考答案】
JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。String类表示内容不可改变的字符串。而StringBuffer类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。
String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。
55、StringBuffer与StringBuilder的区别
【参考答案】
StringBuffer和StringBuilder类都表示内容可以被修改的字符串，StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用StringBuffer。
56、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?【杭州天眼科技】
【参考答案】
答案是在return之前。
【分析】
程序代码的运行结果：
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Test().test());;
}
static int test()
{
int x = 1;
try
{
return x;
}
finally
{
++x;
}
}
}
---------执行结果---------
1
运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
下面的程序代码输出的结果是多少？
public class smallT
{
public static void main(String args[])
{
smallT t = new smallT();
int b = t.get();
System.out.println(b);
}
public int get()
{
try
{
return 1 ;
}
finally
{
return 2 ;
}
}
}
返回的结果是2。
我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
在讲解答案时可以用下面的程序来帮助分析：
public class Test {
/**
* @param args add by zxx ,Dec 9, 2008
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Test().test());;
}
int test()
{
try
{
return func1();
}
finally
{
return func2();
}
}
int func1()
{
System.out.println("func1");
return 1;
}
int func2()
{
System.out.println("func2");
return 2;
}
}
-----------执行结果-----------------
func1
func2
2
结论：finally中的代码比return和break语句后执行。
57、Java中的异常处理机制的简单原理和应用。
【参考答案】
异常是指java程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。
Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。
58、多线程有几种实现方法?同步有几种实现方法?
【参考答案】
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口。
同步的实现方面有两种，分别是synchronized,wait与notify。
a.wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
b.sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
c.notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
d.allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
59、启动一个线程是用run()还是start()?
【参考答案】
启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。
60、内部类可以引用外部类的成员吗？有没有什么限制？
【参考答案】
完全可以。如果不是静态内部类，那没有什么限制！
如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员。
61、List和Map区别?【软通动力】
【参考答案】
一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
62、ArrayList和Vector的区别【博炎科技】
【参考答案】
这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，并且其中的数据是允许重复的。
接着说ArrayList与Vector的区别，这主要包括两个方面：
1、同步性：
Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。
备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。
2、数据增长：
ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长为原来的1.5倍。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。
63、heap和stack有什么区别。
【参考答案】
Java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。
堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用
new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使
用final修饰后，放在堆中，而不是栈中。
64、Java类实现序列化的方法（二种）？如在collection框架中实现排序，要实现什么样的接口
【参考答案】
java.io.Serializable接口或实现Externalizable接口。
Collection框架中实现比较要实现Comparable接口或Comparator接口，并实现比较方法
65、JAVA实现向数据库添加一列。
【参考答案】
Connection con = null;
ResultSet rs = null;
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";
Connection con = DriverManager.getConnection(url,"","");
StateManager sm =con.createStateMent();
String sql = " alter table student add age int; ";
rs = sm.excute(sql);
66、什么是Java序列化，如何实现java序列化？或者请解释Serializable接口的作用。【东软国际】
【参考答案】
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出,那么在另一端，通过ObjectInputStream对象的readObject(Object obj)获取到字节流数据后，要将字节流转换成原对象，这叫反序列化,以便将数据存储在文件中或在网络传输。
Serializable接口描述启用其序列化功能，未实现此接口的类将无法使其任何状态序列化或反序列化。Serializable接口没有方法或字段，仅用于标识可序列化的语义，标识实现了该接口的对象属性可被序列化。
67、Java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
【参考答案】
字节流，字符流两种类型流。字节流继承于InputStream、OutputStream；字符流继承于Reader、Writer。其它与IO操作相关的类都是派生至上述4个抽象类，如字节相关的：FileInputStream、FileOutputStream类；字符相关的：BufferedReader、BufferedWriter类
68、用JDBC如何调用存储过程
【参考答案】
通过JDBC组件中的CallableStatement接口实现调用存储过程。
核心代码如下：
Class.forName("com.mysql.jdbc.Driver");
Connection conn=
DriverManager.getConnection("jdbc:mysql:///test","root","root");
CallableStatement cstmt = cn.prepareCall("{call insert_Student(?,?,?)}");
cstmt.registerOutParameter(3,Types.INTEGER);
cstmt.setString(1, "wangwu");
cstmt.setInt(2, 25);
cstmt.execute();
69、JAVA事件有哪些模式？
【参考答案】
1、事件直接驱动模式。它的特点是直接而且快，是必须经常使用的，主要适合于迅速处理前台的命令，通常就是我们说的command（命令）模式。。2.监控式事件模式。主要借助第三者来监控和触发事件，就是通常我们说的观察者模式。特点是：有一个观察者置身事外在定期独立运行着，我们将我们要监听的事件向这个观察者注册，这样观察者就代替我们来监听这个事件，应用客户端通过观察者来获得事件状况。
【分析】
70、JVM加载class文件原理？
【参考答案】
所谓装载就是寻找一个类或是一个接口的二进制形式并用该二进制形式来构造代表这个类或是这个接口的class对象的过程.
在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化,其中链接又可以分成校验、准备、解析
装载：查找和导入类或接口的二进制数据；
链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的；
校验：检查导入类或接口的二进制数据的正确性；
准备：给类的静态变量分配并初始化存储空间；
解析：将符号引用转成直接引用；
初始化：激活类的静态变量的初始化Java代码和静态Java代码块
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类
一个Java应用程序使用两种类型的类装载器：根装载器(bootstrap)和用户定义的装载器(user-defined)。
根装载器以某种默认的方式将类装入，包括那些Java API的类。在运行期间一个Java程序能安装用户自己定义的类装载器。根装载器是虚拟机固有的一部分，而用户定义的类装载器则不是，它是用Java语言写的，被编译成class文件之后然后再被装入到虚拟机，并像其它的任何对象一样可以被实例化。Java类装载器的体系结构如下所示：
Bootstrap(根装载器)
|
Extension (扩展装载器)
|
System
|
UserDefine1
/ \
UserDefine2 UserDefine3
|
UserDefine4
Java的类装载模型是一种代理(delegation)模型。当JVM要求类装载器CL(ClassLoader)装载一个类时,CL首先将这个类装载请求转发给他的父装载器。只有当父装载器没有装载并无法装载这个类时,CL才获得装载这个类的机会。这样,所有类装载器的代理关系构成了一种树状的关系。树的根是类的根装载器(bootstrap ClassLoader) ,在JVM中它以"null"表示。除根装载器以外的类装载器有且仅有一个父装载器。在创建一个装载器时,如果没有显式地给出父装载器,那么JVM将默认系统装载器为其父装载器
下面针对各种类装载器分别进行详细的说明：
根(Bootstrap)装载器:该装载器没有父装载器，它是JVM实现的一部分，从sun.boot.class.path装载运行时库的核心代码。
扩展(Extension)装载器:继承的父装载器为根装载器，不像根装载器可能与运行时的操作系统有关，这个类装载器是用纯Java代码实现的，它从java.ext.dirs (扩展目录)中装载代码。
系统(System or Application)装载器:装载器为扩展装载器，我们都知道在安装JDK的时候要设置环境变量(CLASSPATH )，这个类装载器就是从java.class.path(CLASSPATH环境变量)中装载代码的，它也是用纯Java代码实现的，同时还是用户自定义类装载器的缺省父装载器。
小应用程序(Applet)装载器:装载器为系统装载器，它从用户指定的网络上的特定目录装载小应用程序代码。
71、SOCKET中有几中连接方式，各有什么区别？
【参考答案】
Sockets有两种主要的操作方式:面向连接(TCP/IP)的和无连接(UDP)的。无连接的操作使用数据报协议，无连接的操作是快速的和高效的,但是数据安全性不佳.面向连接的操作使用TCP协议.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高
【分析】
72、抽象类能否被实例化？抽象类的作用是什么？
【参考答案】
抽象类一般不能被实例化；抽象类通常不是由程序员定义的，而是由项目经理或模块设计人设计抽象类的原因通常是为了规范方法名抽象类必须要继承，不然没法用，作为模块设计者，可以把让底层程序员直接用得方法直接调用，而一些需要让程序员覆盖后自己做得方法则定义称抽象方法
【分析】
73、Linkedlist、Arraylist内部是如何实现的（更深入的问了LinkedList与ArrayList的区别）【天威诚信面试题】
【参考答案】
ArrayList的内部实现是基于内部数组Object[]，它更像是对数组实现的一种封装，所以在向ArrayList的前面或中间插入数据时，必须将其后的所有数据相应的后移，这样必然要花费较多时间。
而LinkedList的内部实现是基于一组双向链表实现的存储特性，所以提供了链表一样访问的API接口，它们在性能上有很大的差别。当你访问Linkedlist链表中的某个元素时，就必须从链表的一端开始沿着连接方向一个一个元素地去查找，直到找到所需的元素为止，所以，当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。
而当你的操作是在一列数据的后面添加数据而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能。
【分析】
74、Hashtable的原理【北辰网络】
【参考答案】
通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址
75、JDBC中的PreparedStatement相比Statement的好处？
【参考答案】
预编译语句java.sql.PreparedStatement ,扩展自Statement,不但具有Statement的所有能力而且具有更强大的功能。不同的是，PreparedStatement是在创建语句对象的同时给出要执行的sql语句。这样，sql语句就会被系统进行预编译，执行的速度会有所增加，尤其是在执行大语句的时候，效果更加理想
76、sleep()和wait()区别
【参考答案】
sleep()方法：线程主动放弃CPU，使得线程在指定的时间内进入阻塞状态，不能得到CPU时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep()被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
wait( )：与notify()配套使用，wait()使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，当指定时间参数时对应的notify()被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的notify()被调用
（网上的答案：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。）
sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。对于wait的讲解一定要配合例子代码来说明，才显得自己真明白。
package com.huawei.interview;
public class MultiThread {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
new Thread(new Thread1()).start();
try {
Thread.sleep(10);
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
new Thread(new Thread2()).start();
}
private static class Thread1 implements Runnable
{
@Override
public void run() {
// TODO Auto-generated method stub
//由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。
synchronized (MultiThread.class) {
System.out.println("enter thread1...");
System.out.println("thread1 is waiting");
try {
//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围，另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。
MultiThread.class.wait();
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("thread1 is going on...");
System.out.println("thread1 is being over!");
}
}
}
private static class Thread2 implements Runnable
{
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (MultiThread.class) {
System.out.println("enter thread2...");
System.out.println("thread2 notify other thread can release wait status..");
//由于notify方法并不释放锁，即使thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得不到锁。
MultiThread.class.notify();
System.out.println("thread2 is sleeping ten millisecond...");
try {
Thread.sleep(10);
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("thread2 is going on...");
System.out.println("thread2 is being over!");
}
}
}
}）
77、概述反射和序列化
【参考答案】
Reflection:是Java被视为动态语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。
序列化:就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时的问题。
78、Java中实现多态的机制是什么?
【参考答案】
重写，重载
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
79、Overload和Override的区别？Overloaded的方法是否可以改变返回值的类型?【软通动力】
【参考答案】
Overload是重载的意思，Override是覆盖的意思，也就是重写。
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
是否可以改变返回值类型，在重载的定义中，与方法是什么类型返回值无关。
【分析】
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
80、ClassLoader如何加载class。
【参考答案】
jvm里有多个类加载，每个类加载可以负责加载特定位置的类，例如，bootstrap类加载负责加载jre/lib/rt.jar中的类，我们平时用的jdk中的类都位于rt.jar中。extclassloader负责加载jar/lib/ext/*.jar中的类，appclassloader负责classpath指定的目录或jar中的类。除了bootstrap之外，其他的类加载器本身也都是java类，它们的父类是ClassLoader。
81、ArrayList如何实现插入的数据按自定义的方式有序存放
【参考答案】
实现Comparable比较接口，并实现compareTo方法。排序的方法，取决于compareTo方法中的比较定义的返回值,一般有3个返回值：1、-1、0表示不同的比较结果。
程序示例：
class MyBean implementsComparable{
public intcompareTo(Object obj){
if(! obj instanceof MyBean)
throw new ClassCastException();
MyBean other = (MyBean) obj;
return age > other.age?1:age== other.age?0:-1;
}
}
class MyTreeSet {
private ArrayList datas = new ArrayList();
public void add(Object obj){
for(int i=0;i
if(obj.compareTo(datas.get(i) != 1){
datas.add(i,obj);
}
}
}
}
82、hashCode方法的作用？
【参考答案】
hashcode这个方法是用来鉴定2个对象是否相等的。hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码。我们一般在覆盖equals的同时也要覆盖hashcode，让他们的逻辑一致。
83、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
【参考答案】
abstract的method不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！
native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的api实现，例如，在windows用c语言实现的，所以，查看jdk的源代码，可以发现FileOutputStream的open方法的定义如下：
private native void open(String name) throws FileNotFoundException;
如果我们要用java调用别人写的c语言函数，我们是无法直接调用的，我们需要按照java的要求写一个c语言的函数，又我们的这个c语言函数去调用别人的c语言函数。由于我们的c语言函数是按java的要求来写的，我们这个c语言函数就可以与java对接上，java那边的对接方式就是定义出与我们这个c函数相对应的方法，java中对应的方法不需要写具体的代码，但需要在前面声明native。
关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。
84、Anonymous Inner Class (匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
【参考答案】
可以继承其他类或实现其他接口。不仅是可以，而是必须!
85、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
【参考答案】
Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。而throws\throw\try、catch、finally就是Java中用来对异常进行处理的几个关键字，在Java编程中规容Java编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，一般异常必须要求被捕获和处理，而系统异常可以处理也可以不处理，所以编译器不强制用try..catch处理或用throws、throw声明异常。而finally一般与try或try\catch一起使用做为异常的最后处理出口。
86、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
【参考答案】
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
87、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
【参考答案】
分几种情况：
1.其他方法前是否加了synchronized关键字，如果没加，则能。
2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。
3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。
4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。
88、线程的基本概念、线程的基本状态以及状态之间的关系
【参考答案】
一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即main方法执行的那个线程。如果只是一个cpu，它怎么能够同时执行多段程序呢？这是从宏观上来看的，cpu一会执行a线索，一会执行b线索，切换时间很快，给人的感觉是a,b在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为a传数据，一会为b传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。
状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。
调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。
89、简述synchronized和java.util.concurrent.locks.Lock的异同？
【参考答案】
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。
90、HashMap和Hashtable的区别？【北通网科】
【参考答案】
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都实现Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是synchronized的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
91、List、Set、Map是否继承自Collection接口?
【参考答案】
List、Set是，Map不是；Map接口定义的是Key-Value存储的特性，与List和Set不同，Map在存储对象时，先要定义这个对象的key的值，再存入与这个key相对应的Object，Map集合的取值时根据存入的key（关键字）来获取与这个关键字对应的对象。
92、List、Map、Set三个接口，存取元素时，各有什么特点？
【参考答案】
首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口Collection接口。Set里面不允许有重复的元素，即不能有两个相等的对象。
List表示有先后顺序的集合，当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。
Map与List和Set不同，它是双列的集合每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key所对应的value。另外，也可以获得所有的key的结合。
【分析】
总结：List以特定次序来持有元素，可有重复元素。Set无法拥有重复元素,内部排序。Map保存key-value值，value可多值。上面是大致不同，另外上述3个只是接口，而具体实现类中，用法大同小异，只是实现的数据结构不同，例如List接口下的LinkedList主要实现了双链表的存储特点，Vector是线程安全的集合类。
93、说出ArrayList,Vector, LinkedList的存储性能和特性。【大唐动力面试题】
【参考答案】
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
94、如何去掉一个Vector集合中重复的元素
【参考答案】
Vector newVector = new Vector();
for (int i=0;i
{
Object obj = vector.get(i);
if(!newVector.contains(obj);
newVector.add(obj);
}
还有一种简单的方式，HashSet set = new HashSet(vector);
95、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals()?它们有何区别?
【参考答案】
Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。
96、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
【参考答案】
对。
如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。
如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode方法。
97、字节流与字符流的区别
【参考答案】
要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。
在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。
底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。
字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，
其实是转成该字符的某种编码的字节形式，读取也是反之的道理。
讲解字节流与字符流关系的代码案例：
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class IOTest {
public static void main(String[] args) throws Exception {
String str = "中国人";
/*FileOutputStream fos = new FileOutputStream("1.txt");
fos.write(str.getBytes("UTF-8"));
fos.close();*/
/*FileWriter fw = new FileWriter("1.txt");
fw.write(str);
fw.close();*/
PrintWriter pw = new PrintWriter("1.txt","utf-8");
pw.write(str);
pw.close();
/*FileReader fr = new FileReader("1.txt");
char[] buf = new char[1024];
int len = fr.read(buf);
String myStr = new String(buf,0,len);
System.out.println(myStr);*/
/*FileInputStream fr = new FileInputStream("1.txt");
byte[] buf = new byte[1024];
int len = fr.read(buf);
String myStr = new String(buf,0,len,"UTF-8");
System.out.println(myStr);*/
BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream("1.txt"),"UTF-8"
)
);
String myStr = br.readLine();
br.close();
System.out.println(myStr);
}
}
98、java里面的io跟nio有什么区别
【参考答案】
1、Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。
2、Java IO的各种流是阻塞的。而Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。
3、选择器上，Java IO无选择器，而NIO有选择器，Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。
99、Java中会存在内存泄漏吗，请简单描述。
【参考答案】
所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象变成了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的，例如下面的代码可以看到这种情况的内存回收：
package com.huawei.interview;
import java.io.IOException;
public class GarbageTest {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
try {
gcTest();
}catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("has exited gcTest!");
System.in.read();
System.in.read();
System.out.println("out begin gc!");
for(int i=0;i<100;i++)
{
System.gc();
System.in.read();
System.in.read();
}
}
private static void gcTest() throws IOException {
System.in.read();
System.in.read();
Person p1 = new Person();
System.in.read();
System.in.read();
Person p2 = new Person();
p1.setMate(p2);
p2.setMate(p1);
System.out.println("before exit gctest!");
System.in.read();
System.in.read();
System.gc();
System.out.println("exit gctest!");
}
private static class Person
{
byte[] data = new byte[20000000];
Person mate = null;
public void setMate(Person other)
{
mate = other;
}
}
}
java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。
检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。
如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。
[]是对象已不可到达，而内存又没有回收，真正的内存黑洞。
而Java的泄漏，则是因为各种原因，对象对应用已经无用，但一直被持有，一直可到达。
总结原因无外乎几方面：
1.被生命周期极长的集合类不当持有，号称是Java内存泄漏的首因。
这些集合类的生命周期通常极长，而且是一个辅助管理性质的对象，在一个业务事务运行完后，如果没有将某个业务对象主动的从中清除的话，这个集合就会吃越来越多内存，可以用WeakReference，如WeakHashMap，使得它持有的对象不增加对象的引用数。
2.Scope定义不对，这个很简单了，方法的局部变量定义成类的变量，类的静态变量等。
3.异常时没有加finally{}来释放某些资源，JDBC时代也是很普遍的事情。
4.另外一些我了解不深的原因，如：Swing里的Listener没有显式remove；内部类持有外部对象的隐式引用；Finalizers造成关联对象没有被及时清空等。
内存泄漏的检测
有不少工具辅助做这个事情的，如果手上一个工具也没有，可以用JDK自带的小工具：
·看看谁占满了Heap？
用JDK6的jmap可以显示运行程序中对象的类型，个数与所占的大小
先用jps找到进程号，然后jmap -histo pid显示或jmap -dump:file=heap_file_name pid导出heap文件
·为什么这些对象仍然可以到达？
用jhat(Java Heap Analysis Tool)分析刚才导出的heap文件。
先jhat heap_file_name，然后打开浏览器http://localhost:7000/浏览。
100、Hashcode和Equals的联系
【参考答案】
首先equals()和hashcode()这两个方法都是从object类中继承过来的，主要用来比较对象时进行调用。在object类中定义如下：
a)、如果两个对象相同，那么它们的hashCode值一定要相同；
b)、如果两个对象的hashCode相同，它们并不一定相同上面说的对象相同指的是用eqauls方法比较。
101、Tread和Threadlocal的作用及区别？
【参考答案】
答：threadlocal是线程局部变量（thread local variable），为每一个使用该线程的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本产生冲突。
102、TCP和UDP的区别？
【参考答案】
TCP/IP的运输层有两个不同的协议：①用户数据报协议UDP②传输控制协议TCP
二者最大区别:TCP是面向连接的,而UDP是无连接的.区别大致如下:
1）UDP传送的数据单位协议是UDP报文或用户数据报,TCP传送的数据单位协议是TCP报文段。
2）UDP发送数据之前不需要建立连接,因此减少了开销和发送之前的时延。TCP提供面向连接的服务,不提供广播或多播服务。
3）对方的运输层在收到UDP报文后,不需要给出任何确认。TCP则需要确认。
4）UDP没有拥塞控制,因此网络出现的拥塞不会使源主机的发送速率降低,也不保证可靠交付,因此主机不需要维持具有许多参数的、复杂的连接状态表。TCP要提供可靠的、面向连接的运输服务,因此不可避免地增加了许多的开销,这不仅使协议数据单元的首部增大很多,还要占用许多的处理机资源。
5）UDP用户数据报只有8个字节的首部开销,比TCP的20个字节的首部要短。
103、启动一个线程用什么方法？【北京永中软件面试题】
【参考】
使用Thread类的start()方法来启动一个线程，使线程进入就绪状态。如果自定义的类是Thread类的子类的话，可以直接使用Start()来启，如果是实现的Runnable接口的话，还要将该类的实例作为参数传入到Thread对象中来启动。
104、作用域public等写不写的区别？【北京永中软件面试题】
【参考】
作用域不写将采用默认的作用域,默认作用域的访问权限是包的权限，也就是除本包中的所有类能访问，不同包只有子类能访问。
105、同步和异步有何异同
【参考答案】
同步(synchronized)和异步(asynchronized)是对于多线程(multi-threading)而言的
同步可防止并发主要出于数据安全的考虑
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
异步允许并发
ajax技术通常都是异步实现的，异步主要使用在当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
106、Static方法和static字段有什么用处？可以被重载吗？
【参考答案】
用static修饰的方法叫类方法，被所有实例共享；static修饰的字段为类变量，被所有实例共享，在使用类变量时，一般会结合final一起使用定义类常量，不允许被其它的类实例修改。
可以被重载，重载只是参数类型、顺序和个数不同。
http://blog.duywl.com/java/java%E9%9D%A2%E8%AF%95%E9%A2%98-java%E9%83%A8%E5%88%86/
网友评论