- 相关推荐
java面试中常问的问题
1、请说出作用域public，private，protected，以及不写时的区别
这四个作用域的可见范围如下表所示。
说明：如果在修饰的元素上面没有写任何访问修饰符，则表示 friendly 。
作用域 当前类 同一 package 子孙类 其他 package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
备注：只要记住了有 4 种访问权限， 4 个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。
2、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
重载 Overload 表示同一个类中可以有多个名称相同的方法 ，但这些方法的参数列表各不相同 （即参数个数或类型不同）。
重写 Override 表示子类中的方法可以与父类中的某个方法的名称和参数完全相同 ，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法 ，这相当于把父类中定义的那个完全相同的方法给覆盖 了，这也是面向对象编程的多态性 的一种表现。
如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载 Overload 。 java 就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断 。
http://cankao.gcw818.com和Hashtable的区别
(1 )HashMap不是线程安全的 .
hashmap是一个接口 是map接口的子接口，是将键映射到值的对象，其中键和值都是对象 ，并且不能包含重复键 ，但可以包含重复值 。HashMap允许 null key 和 null value ，而hashtable不允许。
(2) HashTable是线程安全的一个Collection。
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 interf-ace的一个实现。
最大的不同是，Hashtable 的方法是 Synchronize 的，而HashMap不是，在多个线程访问 Hashtable 时，不需要自己为它的方法实现同步 ，而HashMap 就必须为之提供外同步 。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
4. ArrayList 和 LinkedList
List 接口对 Collection 进行了简单的扩充，它的具体实现类常用的有 ArrayList 和 LinkedList 。你可以将任何东西放到一个 List 容器中，并在需要时从中取出。 ArrayList 从其命名中可以看出它是一种类似数组 的形式进行存储，因此它的随机访问速度极快 ，而 LinkedList 的内部实现是链表， 它适合于在链表中间需要频繁进行插入和删除 操作。在具体应用时可以根据需要自由选择。前面说的 Iterator 只能对容器进行向前遍历 ，而 ListIterator 则继承了 Iterator 的思想，并提供了对 List 进行双向遍历 的方法。
5. .hashCode方法的作用？
（网友提供的一段，待改进： hashcode这个方法是用来鉴定 2 个对象是否相等的 。
那你会说，不是还有equals这个方法吗？
不错，这2个方法都是用来判断2个对象是否相等的。但是他们是有区别的。
一般来讲，equals这个方法是给用户调用的，如果你想判断2个对象是否相等，你可以重写equals方法，然后在代码中调用，就可以判断他们是否相等了。简单来讲，equals方法主要是用来判断从表面上看或者从内容上看，2个对象是不是相等。举个例子，有个学生类，属性只有姓名和性别，那么我们可以认为只要姓名和性别相等，那么就说这2个对象是相等的。
hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码，就好像文件中的md5，他和equals不同就在于他返回的是 int 型 的，比较起来不直观。我们一般在覆盖equals的同时也要覆盖hashcode，让他们的逻辑一致。举个例子，还是刚刚的例子，如果姓名和性别相等就算2个对象相等的话，那么hashcode的方法也要返回姓名的hashcode值加上性别的hashcode值，这样从逻辑上，他们就一致了。
要从物理上判断 2 个对象是否相等，用 == 就可以了。
）
6、静态变量和实例变量的区别？
在语法定义上的区别：静态变量前要加 static 关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象 ，其中的实例变量才会被分配空间 ，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间 ，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用
7、Integer与int的区别
int 是 java 提供的 8 种原始数据类型之一 。 Java 为每个原始类型提供了封装类， Integer 是 java为 int 提供的封装类。 int 的默认值为 0 ，而 Integer 的默认值为 null ，即 Integer 可以区分出未赋值和值为 0 的区别 ， int 则无法表达出未赋值的情况，
8、http://cankao.gcw818.com(11.5)等於多少? http://cankao.gcw818.com(-11.5)等於多少?
Math 类中提供了三个与取整有关的方法： ceil 、 floor 、 round ，这些方法的作用与它们的英文名称的含义相对应，例如， ceil 的英文意义是天花板，该方法就表示向上取整 ，所以， http://cankao.gcw818.com(11.3) 的结果为 12,http://cankao.gcw818.com(-11.3) 的结果是 -11 ； floor 的英文意义是地板，该方法就表示向下取整 ，所以， http://cankao.gcw818.com(11.6) 的结果为 11,http://cankao.gcw818.com(-11.6) 的结果是 -12 ；最难掌握的是 round 方法，它表示“四舍五入”， 算法为 http://cankao.gcw818.com(x+0.5) ，即将原来的数字加上 0.5 后再向下取整，所以，http://cankao.gcw818.com(11.5)的结果为12，http://cankao.gcw818.com(-11.5)的结果为-11。
http://cankao.gcw818.com
(1).概念介绍：所谓AOP，即Aspect orientied program,就是面向方面 ( 切面 ) 的编程，
(2).解释什么是方面：贯穿到系统的各个模块中的系统一个功能就是一个方面，
比如，记录日志，统一异常处理，事务处理，权限检查 ，这些功能都是软件系统
的一个面，而不是一点，在各个模块中都要出现。
（3）.什么是面向方面编程：把系统的一个方面的功能封装成对象 的形式来处理
（4）.怎么进行面向方面编程：把功能模块对应的对象作为切面嵌入到原来的各个系统模块中，采用代理技术，代理会调用目标 ，同时把切面功能的代码（对象）加入 进来，所以，
用spring配置代理对象时只要要配两个属性，分别表示目标 和切面对象 （Advisor）。
10、构造器Constructor是否可被override?
构造器 Constructor 不能被继承，因此不能重写 Override ，但可以被重载 Overload 。
11、写clone()方法时，通常都有一行代码，是什么？
clone 有缺省行为 ， http://cankao.gcw818.com(); 因为首先要把父类中的成员复制到位，然后才是复制自己的成员。
12、java中实现多态的机制是什么？
靠的是父类或接口 定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
13、abstract class和interf-ace有什么区别?
含有 abstract 修饰符的 class 即为抽象类， abstract 类不能创建的实例对象 。含有 abstract 方法的类必须定义为 abstract class ， abstract class 类中的方法不必是抽象的。 abstract class 类中定义抽象方法必须在具体 (Concrete) 子类中实现，所以，不能有抽象构造方法或抽象静态方法 。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为 abstract 类型。
接口（ interf-ace ）可以说成是抽象类的一种特例 ，接口中的所有方法都必须是抽象 的。接口中的方法定义默认为 public abstract 类型，接口中的成员变量类型默认为 public static final 。
下面比较一下两者的语法区别：
1. 抽象类可以有构造方法 ，接口中不能有 构造方法。
2. 抽象类中可以有普通成员变量，接口中没有普通成员变量
3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是 public ， protected 和（默认类型 , 虽然
eclipse 下不报错，但应该也不行），但接口中的抽象方法只能是 public 类型的，并且默认即为 public abstract 类型。
5. 抽象类中可以包含静态 方法，接口中不能包含 静态方法
6. 抽象类和接口中都可以包含静态成员 变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是 public static final 类型，并且默认即为 public static final 类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet 类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的 Servlet 都继承这个抽象基类，在抽象基类的 service 方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：
public abstract class BaseServlet extends HttpServlet
{
public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException
{
记录访问日志
进行权限判断
if( 具有权限 )
{
try
{
doService(request,response);
}
catch(Excetpion e)
{
记录异常信息
}
}
}
protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException;
// 注意访问权限定义成 protected ，显得既专业，又严谨，因为它是专门给子类用的
}
public class MyServlet1 extends BaseServlet
{
protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException
{
本 Servlet 只处理的具体业务逻辑代码
}
}
父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。
备注：这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等 6 个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。
14. jdk中哪些类是不能继承的？
不能继承的是类是那些用 final 关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是 final 的，在 jdk 中 System ,String ,StringBuffer 等都是基本类型
15、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。
16、java中会存在内存泄漏吗，请简单描述。
所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象编程了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java 使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的，例如下面的代码可以看到这种情况的内存回收：
package http://cankao.gcw818.com
import http://cankao.gcw818.com
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
http://cankao.gcw818.com();
}
http://cankao.gcw818.com( "has exited gcTest!" );
http://cankao.gcw818.com();
http://cankao.gcw818.com();
http://cankao.gcw818.com( "out begin gc!" );
for ( int i=0;i<100;i++)
{
http://cankao.gcw818.com();
http://cankao.gcw818.com();
http://cankao.gcw818.com();
}
}
private static void gcTest() throws IOException {
http://cankao.gcw818.com();
http://cankao.gcw818.com();
Person p1 = new Person();
http://cankao.gcw818.com();
http://cankao.gcw818.com();
Person p2 = new Person();
http://cankao.gcw818.com(p2);
http://cankao.gcw818.com(p1);
http://cankao.gcw818.com( "before exit gctest!" );
http://cankao.gcw818.com();
http://cankao.gcw818.com();
http://cankao.gcw818.com();
http://cankao.gcw818.com( "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中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。
如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。
下面内容来自于网上（主要特点就是清空堆栈中的某个元素，并不是彻底把它从数组中拿掉，而是把存储的总数减少，本人写得可以比这个好，在拿掉某个元素时，顺便也让它从数组中消失，将那个元素所在的位置的值设置为null即可）：
我实在想不到比那个堆栈更经典的例子了,以致于我还要引用别人的例子，下面的例子不是我想到的，是书上看到的，当然如果没有在书上看到，可能过一段时间我自己也想的到，可是那时我说是我自己想到的也没有人相信的。
public class Stack {
private Object[] elements=new Object[10];
private int size = 0;
public void push(Object e){
ensureCapacity();
elements[size++] = e;
}
public Object pop(){
if( size == 0)
throw new EmptyStackException();
return elements[--size];
}
private void ensureCapacity(){
if(http://cankao.gcw818.com){
Object[] oldElements = elements;
elements = new Object[2 * http://cankao.gcw818.com];
http://cankao.gcw818.com(oldElements,0, elements, 0, size);
}
}
}
上面的原理应该很简单，假如堆栈加了10个元素，然后全部弹出来，虽然堆栈是空的，没有我们要的东西，但是这是个对象是无法回收的，这个才符合了内存泄露的两个条件：无用，无法回收。
但是就是存在这样的东西也不一定会导致什么样的后果，如果这个堆栈用的比较少，也就浪费了几个K内存而已，反正我们的内存都上G了，哪里会有什么影响，再说这个东西很快就会被回收的，有什么关系。下面看两个例子。
例子 1
public class Bad{
public static Stack s=Stack();
static{
http://cankao.gcw818.com(new Object());
http://cankao.gcw818.com(); //这里有一个对象发生内存泄露
http://cankao.gcw818.com(new Object()); // 上面的对象可以被回收了，等于是自愈了
}
}
因为是static，就一直存在到程序退出，但是我们也可以看到它有自愈功能，就是说如果你的Stack最多有100个对象，那么最多也就只有100个对象无法被回收其实这个应该很容易理解，Stack内部持有100个引用，最坏的情况就是他们都是无用的，因为我们一旦放新的进取，以前的引用自然消失！
内存泄露的另外一种情况：当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄露。
17、多线程有几种实现方法?同步有几种实现方法?
多线程有两种实现方法，分别是继承 Thread 类与实现 Runnable 接口
同步的实现方面有两种， 一种同步方法，一种同步代码！ 分别是 synchronized,wait 与 notify
wait(): 使一个线程处于等待状态，并且释放所持有的对象的 lock 。
sleep(): 使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException 异常。
notify() : 唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 确定唤醒哪个线程，而且不是按优先级。
Allnotity() : 唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争
18、sleep() 和 wait() 有什么区别?
（网上的答案：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 http://cankao.gcw818.com
public class MultiThread {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
new Thread( new Thread1()).start();
try {
http://cankao.gcw818.com(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
http://cankao.gcw818.com();
}
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 不是同一个对象。我们用http://cankao.gcw818.com这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。
synchronized (MultiThread. class ) {
http://cankao.gcw818.com( "enter thread1..." );
http://cankao.gcw818.com( "thread1 is waiting" );
try {
//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了 synchronized 关键字管辖的代码范围，另一种方式就是在 synchronized 关键字管辖的代码内部调用监视器对象的 wait 方法。这里，使用 wait 方法释放锁。
MultiThread.class .wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
http://cankao.gcw818.com();
}
http://cankao.gcw818.com( "thread1 is going on..." );
http://cankao.gcw818.com( "thread1 is being over!" );
}
}
}
private static class Thread2 implements Runnable
{
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (MultiThread. class ) {
http://cankao.gcw818.com( "enter thread2..." );
http://cankao.gcw818.com( "thread2 notify other thread can release wait status.." );
// 由于 notify 方法并不释放锁， 即使 thread2 调用下面的 sleep 方法休息了 10 毫秒，但 thread1仍然不会执行，因为 thread2 没有释放锁，所以 Thread1 无法得不到锁。
MultiThread.class .notify ();
http://cankao.gcw818.com( "thread2 is sleeping ten millisecond..." );
try {
http://cankao.gcw818.com(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
http://cankao.gcw818.com();
}
http://cankao.gcw818.com( "thread2 is going on..." );
http://cankao.gcw818.com( "thread2 is being over!" );
}
}
}
}
19、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？
java5以前，有如下两种：
第一种：
new Thread(){}.start(); 这表示调用Thread子类对象的run 方法 ，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：
new Thread(){
public void run(){
}
}.start();
第二种：
new Thread(new Runnable(){}).start(); 这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：
new Thread(new Runnable(){
public void run(){
}
}
).start();
从java5开始，还有如下一些线程池创建多线程 的方式：
ExecutorService pool = http://cankao.gcw818.com(3)
for(int i=0;i<10;i++)
{
http://cankao.gcw818.com(new Runable(){public void run(){}});
}
http://cankao.gcw818.com().execute(new Runable(){public void run(){}});
http://cankao.gcw818.com().execute(new Runable(){public void run(){}});
有两种实现方法，分别使用new Thread()和new Thread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即new SubThread()。第二种调用runnable的run方法。
有两种实现方法，分别是继承 Thread 类与实现 Runnable 接口
用 synchronized 关键字修饰 同步方法
反对使用stop()，是因为它不安全。 它会解除由线程获取的所有锁定 ，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁 。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
20、Java中的异常处理机制的简单原理和应用。
异常是指java程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息 。
Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为http://cankao.gcw818.com，Throwable下面又派生了两个子类： Error 和 Exception ，Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。
21、final, finally, finalize的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用
22、数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。String有length()这个方法。
http://cankao.gcw818.com与StringBuilder的区别
StringBuffer和StringBuilder类都表示内容可以被修改的字符串 ，StringBuilder是线程不安全的 ，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它 ，不存在不安全的因素了，则用 StringBuilder 。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程 环境下使用，那么最好用 StringBuffer 。
24、String 和StringBuffer的区别
String类表示内容不可改变 的字符串。而StringBuffer类表示内容可以被修改 的字符串
25、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interf-ace(接口)?
可以继承其他类或实现其他接口。不仅是可以，而是必须 !
http://cankao.gcw818.com单例模式
Java中 单例模式是一种常见的设计模式，
单例模式分三种：懒汉式单例、饿汉式单例、登记式单例
单例模式有一下特点：
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
27、说出一些数据库优化方面的经验?
用PreparedStatement 一般来说比Statement性能高：一个sql 发给服务器去执行，涉及步骤：语法检查、语义分析， 编译，缓存
“inert into user values(1,1,1)”-à二进制
“inert into user values(2,2,2)”-à二进制
“inert into user values(?,?,?)”-à二进制
有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就去掉外键。（比喻：就好比免检产品，就是为了提高效率，充分相信产品的制造商）
（对于hibernate来说，就应该有一个变化：empleyee->Deptment对象，现在设计时就成了employeeàdeptid）
看mysql帮助文档子查询章节的最后部分，例如，根据扫描的原理，下面的子查询语句要比第二条关联查询的效率高：
1. select http://cankao.gcw818.com(select id from employee where name='zxx');
2. select http://cankao.gcw818.com
http://cankao.gcw818.com'zxx';
表中允许适当冗余，譬如，主题帖的回复数量和最后回复时间等
将姓名和密码单独从用户表中独立出来。这可以是非常好的一对一的案例哟！
sql语句全部大写，特别是列名和表名都大写。特别是sql命令的缓存功能，更加需要统一大小写，sql语句à发给oracle服务器à语法检查和编译成为内部指令à缓存和执行指令。根据缓存的特点，不要拼凑条件，而是用?和PreparedStatment
还有索引对查询性能的改进也是值得关注的。
28、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？
a: 两种形式 dtd schema， b: 本质区别 :schema 本身是 xml 的，可以被 XML 解析器解析 ( 这也是从DTD 上发展 schema 的根本目的 ) ， c: 有 DOM,SAX,STAX 等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由 DOM 的树结构所造成的，这种结构占用的内存较多，而且 DOM 必须在解析文件之前把整个文档装入内存 , 适合对 XML 的随机访问
SAX: 不现于 DOM,SAX 是事件驱动型的 XML 解析方式。它顺序读取 XML 文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理 XML 文件，适合对 XML 的顺序访问
STAX:Streaming API for XML (StAX)
29、hibernate中的update()和saveOrUpdate()的区别，session的load()和get()的区别。
update针对的是已存在的实体对象
saveOrUpdate()对象存在与否都不会有任何影响
session的load()和get()的区别
load是只在缓存中加载数据
get是先缓存中查找或者缓存中没有到数据库中查找
30. How to set many-to-many relationship in Hibernate?
Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系 )
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-many
31如何优化Hibernate？
* 使用双向一对多关联，不使用单向一对多
* 灵活使用单向一对多关联
* 不用一对一，用多对一取代
* 配置对象缓存，不使用集合缓存
* 一对多集合使用Bag,多对多集合使用Set
* 继承类使用显式多态
* 表字段要少，表关联不要怕多，有二级缓存撑腰