Java面试题（二）

1、int 和 Integer 有什么区别

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类booleanBoolean  charCharacter  byteByte  shortShort  intInteger  longLong  floatFloat  doubleDouble
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

2、String 和StringBuffer的区别

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用 StringBuffers来动态构造字符数据。

3、运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

4、说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元 素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差， 而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

5、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行 同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途 径往往更有效率。

6、heap和stack有什么区别。

栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素

7、Java的接口和C++的虚类的相同和不同处。

由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的 灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。

8、Java中的异常处理机制的简单原理和应用。

当Java 程序违反了Java的语义规则时，Java虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。（1）一种是Java类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。（2）另一种情况就是Java允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是 java.lang.Thowable的子类。

9、垃圾回收的优点和原理。并考虑2种回收机制。

Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考 虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使 用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程 序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收

10、请说出你所知道的线程同步的方法。

wait ():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉 InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

11、你所知道的集合类都有哪些？主要方法？

最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。

12、描述一下JVM加载class文件的原理机制?

JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

13、char型变量中能不能存贮一个中文汉字?为什么?

能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

14、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 ,同步的实现方面有两种，分别是synchronized,wait与notify

15、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
public class ThreadTest1 {
    private int j;
    public static void main(String args[]) {
        ThreadTest1 tt = new ThreadTest1();
        Inc inc = tt.new Inc();
        Dec dec = tt.new Dec();

        for (int i = 0; i < 2; i++) {
            Thread t = new Thread(inc);

            t.start();
            t = new Thread(dec);
            t.start();
        }
    }

    private synchronized void inc() {
        j++;
        System.out.println(Thread.currentThread().getName() + "-inc:" + j);
    }

    private synchronized void dec() {
        j--;
        System.out.println(Thread.currentThread().getName() + "-dec:" + j);
    }
    class Inc implements Runnable {
        public void run() {
            for (int i = 0; i < 100; i++) {
                inc();
            }
        }
    }


    class Dec implements Runnable {
        public void run() {
            for (int i = 0; i < 100; i++) {
                dec();
            }
        }
    }
}

16、 面向对象的特征有哪些方面

（1）. 抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

（2）继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个 过程称为类继 承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可 以修改或增加新的方法使之更适合特殊的需要。

（3）封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

（4）多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

<jsp:include flush="true" page="included.jsp">17、线程的基本概念、线程的基本状态以及状态之间的关系</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。Java中的线程有四种状态分别是：运行、就绪、挂起、结束。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 18、简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">区别主要答两点：a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型b.逻辑操作不会产生短路

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 19、简述synchronized和java.util.concurrent.locks.Lock的异同 ？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp"> 主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 20、排序都有哪几种方法？请列举。用JAVA实现一个快速排序。</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码。/ /使用快速排序方法对a[ 0 :n- 1 ]排序，
从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e，该元素为支点，把余下的元素分割为两段left 和r i g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点，递归地使用快速排序方法对left 进行排序，递归地使用快速排序方法对right 进行排序，所得结果为l e f t + m i d d l e + r i g h t。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 21、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它 子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是 通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛 出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。用try来指定一块预防所 有“异常”的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。throw语句用来明确地抛出一个“异常”。 throws用来标明一个成员函数可能抛出的各种“异常”。Finally为确保一段代码不管发生什么“异常”都被执行一段代码。可以在一个成员函数调用 的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try 语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try语句。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 22、一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">可以。必须只有一个类名与文件名相同。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 23、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">有两种实现方法，分别是继承Thread类与实现 Runnable接口用synchronized 关键字修饰同步方法反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下 检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在 这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被“挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任 何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出 线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 24、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp"> 字节流，字符流。字节流继承于InputStream \ OutputStream，字符流继承于InputStreamReader \ OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 25、java中会存在内存泄漏吗，请简单描述。</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">会。如：int i,i2;  return (i-i2);   //when i为足够大的正数,i2为足够大的负数。结果会造成溢位，导致错误。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 26、java中实现多态的机制是什么？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 27、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">对于GC来说，当程序员创建对象时，GC就开始监控这个 对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"， 哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC 运行，但是Java语言规范并不保证GC一定会执行。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 28、静态变量和实例变量的区别？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">static i = 10; //常量； class A a;  a.i =10;//可变

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 29、什么是java序列化，如何实现java序列化？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">序列化就是一种用来处理对象流的机制，所谓对象流也就是 将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列 化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法， implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 30、是否可以从一个static方法内部发出对非static方法的调用？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">不可以,如果其中包含对象的method()；不能保证对象初始化.

31、写clone()方法时，通常都有一行代码，是什么？
Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。

</jsp:include>

<jsp:include flush="true" page="included.jsp"> 32、在JAVA中，如何跳出当前的多重嵌套循环？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">用break; return 方法。

33、List、Map、Set三个接口，存取元素时，各有什么特点？
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

</jsp:include>

<jsp:include flush="true" page="included.jsp">34、内部类可以引用他包含类的成员吗？有没有什么限制？</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">一个内部类对象可以访问创建它的外部类对象的内容
</jsp:include>

<jsp:include flush="true" page="included.jsp">35、Java代码查错</jsp:include>

<jsp:include flush="true" page="included.jsp"></jsp:include>

<jsp:include flush="true" page="included.jsp">（1）
abstract class Name {
    private String name;
    public abstract boolean isStupidName(String name) {}
} 大侠们，这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。

（2）
public class Something {
    void doSomething () { 
        private String s = ""; 
        int l = s.length();
    }
} 有错吗?
答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量(final如同abstract和strictfp，都是非 访问修饰符，strictfp只能修饰class和method而非variable)。

（3）
abstract class Something {
    private abstract String doSomething ();
} 这好像没什么错吧?
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎 么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

（4）
public class Something {
    public int addOne(final int x) {
        return ++x;
    }
} 这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

（5）
public class Something {
    public static void main(String[] args) {
        Other o = new Other();
        new Something().addOne(o);
    } 

    public void addOne(final Other o) {  o.i++; }
} 

class Other { public int i;}
和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。

（6）
class Something {
    int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
}
有什么错呢? 看不出来啊。
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。

（7）
class Something {
    final int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
}
和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?
答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

（8）.
public class Something {
    public static void main(String[] args) {
        Something s = new Something();
        System.out.println("s.doSomething() returns " + doSomething());
    }
    public String doSomething() {
        return "Do something ...";
    }
}
看上去很完美。
答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。

（9）.
此处，Something类的文件名叫OtherThing.java
class Something {
    private static void main(String[] something_to_do) {
        System.out.println("Do something ...");
    }
}
这个好像很明显。
答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。

（10）．
interface A{
    int x = 0;
}
class B{
    int x =1;
}
class C extends B implements A {
    public void pX(){
        System.out.println(x);
    }
    public static void main(String[] args) {
        new C().pX();
    }
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

（11）.
interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;
    }
    public void play() {
        ball = new Ball("Football");
        System.out.println(ball.getName());
    }
}
这个错误不容易发现。
答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。</jsp:include>

评论

1 楼 huazang_2010 2010-06-20  

、第2部分。