[转载]转 构造最全的java面试题整理（基础篇一）

原文地址：转 构造最全的java面试题整理（基础篇一）作者：锵鹏鹏

1、区别作用域public,private,protected,以及不写时的区别
答：区别如下：

 

作用域	当前类	同一package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

不写时默认为friendly

 

 

2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
答：匿名的内部类是没有名字的内部类。可以extends(继承) 其它类，也可以实现其他类

 

3、Static Nested Class 和 Inner Class的不同
答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。

Nested class分为静态Static nested class 的和非静态的 inner class,

静态的Static nested class是不可以直接调用它的外部类enclosing class的，但是可以通过外部类的引用来调用，就像你在一个类中写了main方法一样。

非静态类inner class 可以自由的引用外部类的属性和方法，但是它与一个实例绑定在了以其，不可以定义静态的属性、方法。

注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

 

4、&和&&的区别
答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）

5、Collection 和 Collections的区别
答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

6、什么时候用assert
答：assertion (断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个 boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下， 系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能， 在软件发布后，assertion检查通常是关闭的

7、String s = new String("xyz");创建了几个String Object
答：一个或者两个，如果字符串对象"xyz"存在，则会创建一个"xyz"，否则就是两个。看如下解释：

关于String类的说明：

1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能
再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的(immutable).

2.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个
String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,
一个是编译期,一个是运行期!

3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.

4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.

String的创建方法一般有如下几种
1.直接使用""引号创建.
2.使用new String()创建.
3.使用new String("someString")创建以及其他的一些重载构造函数创建.
4.使用重载的字符串连接操作符+创建.

例1
    //
    * "sss111"是编译期常量,编译时已经能确定它的值,在编译
    * 好的class文件中它已经在String Pool中了,此语句会在
    * String Pool中查找等于"sss111"的字符串(用equals(Object)方法确定),
    * 如果存在就把引用返回,付值给s1.不存在就会创建一个"sss111"放在
    * String Pool中,然后把引用返回,付值给s1.
    * 
    //
    String s1 = "sss111";

    //此语句同上
    String s2 = "sss111";

    //
    * 由于String Pool只会维护一个值相同的String对象
    * 上面2句得到的引用是String Pool中同一个对象,所以
    * 他们引用相等
    //
    System.out.println(s1 == s2); //结果为true


例2
    //
    * 在java中,使用new关键字会创建一个新对象,在本例中,不管在
    * String Pool中是否已经有值相同的对象,都会创建了一个新的
    * String对象存储在heap中,然后把引用返回赋给s1.
    * 本例中使用了String的public String(String original)构造函数.
    //
    String s1 = new String("sss111");     
    //此句会按照例1中所述在String Pool中查找
    String s2 = "sss111";   
    //
     * 由于s1是new出的新对象,存储在heap中,s2指向的对象
     * 存储在String Pool中,他们肯定不是同一个对象,只是
     * 存储的字符串值相同,所以返回false.
     //
    System.out.println(s1 == s2); //结果为false


例3
    String s1 = new String("sss111");
    //
    * 当调用intern方法时，如果String Pool中已经包含一个等于此String对象
    * 的字符串(用 equals(Object)方法确定),则返回池中的字符串.否则,将此
    * String对象添加到池中，并返回此String对象在String Pool中的引用.
    //
    s1 = s1.intern();
   
    String s2 = "sss111";
    
    //
     * 由于执行了s1 = s1.intern(),会使s1指向String Pool中值为"sss111"
     * 的字符串对象,s2也指向了同样的对象,所以结果为true
     //
    System.out.println(s1 == s2);


例4
    String s1 = new String("111");
    String s2 = "sss111";
    
    //
    * 由于进行连接的2个字符串都是常量,编译期就能确定连接后的值了,
    * 编译器会进行优化直接把他们表示成"sss111"存储到String Pool中,
    * 由于上边的s2="sss111"已经在String Pool中加入了"sss111",
    * 此句会把s3指向和s2相同的对象,所以他们引用相同.此时仍然会创建出
    * "sss"和"111"两个常量,存储到String Pool中.
    //
    String s3 = "sss" + "111";
    
    //
     * 由于s1是个变量,在编译期不能确定它的值是多少,所以
     * 会在执行的时候创建一个新的String对象存储到heap中,
     * 然后赋值给s4.
     //
    String s4 = "sss" + s1;
   
    System.out.println(s2 == s3); //true
    System.out.println(s2 == s4); //false
    System.out.println(s2 == s4.intern()); //true


例5
这个是The Java Language Specification中3.10.5节的例子,有了上面的说明,这个应该不难理解了
    package testPackage;
    class Test {
            public static void main(String[] args) {
                    String hello = "Hello", lo = "lo";
                    System.out.print((hello == "Hello") + " ");
                    System.out.print((Other.hello == hello) + " ");
                    System.out.print((other.Other.hello == hello) + " ");
                    System.out.print((hello == ("Hel"+"lo")) + " ");
                    System.out.print((hello == ("Hel"+lo)) + " ");
                    System.out.println(hello == ("Hel"+lo).intern());
            }
    }
    class Other { static String hello = "Hello"; }

    package other;
    public class Other { static String hello = "Hello"; }

输出结果为true true true true false true,请自行分析!

结果上面分析,总结如下:
1.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中.
2.使用new String("")创建的对象会存储到heap中,是运行期新创建的.
3.使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中.
4.使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中.
6.使用"aa" + s1以及new String("aa" + s1)形式创建的对象是否加入到String Pool中我不太确定,可能是必须
调用intern()方法才会加入,希望高手能回答 @_@符对象引用对象

 

8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少
答:  Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor

9、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译）

10、Java有没有goto
答：java中的保留字，现在没有在java中使用

11、数组有没有length()这个方法? String有没有length()这个方法
答：数组没有length()这个方法，有length的属性。String有有length()这个方法

12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
答：方 法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重 载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写  (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方 法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

13、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别
答：set代表无序不可重复的集合,Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
    equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

14、给我一个你最常见到的runtime exception
答：最常见的Runtime Exception莫过于NullPointerException，常见的运行时异常有还如下这些ArithmeticException, ArrayStoreException,  BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, 

ClassCastException, CMMException, 

ConcurrentModificationException, 

DOMException, EmptyStackException, 

IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, 

IllegalStateException, ImagingOpException, IndexOutOfBoundsException, 

MissingResourceException, NegativeArraySizeException, NoSuchElementException, 

NullPointerException, ProfileDataException, ProviderException, RasterFormatException, 

SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, 

UnsupportedOperationException

15、error和exception有什么区别
答：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况
    exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

16、List, Set, Map是否继承自Collection接口
答： List，Set是，Map不是. (java集合大致上可分为：set,list,map三种体系，其中set代表无序不可重复的集合，list代表有序可重复的集合，map代表具有映射关系的集合。set和list接口都实现了collection接口 .)

17、abstract class和interface有什么区别
答：在abstract class方式中，可以有自己的数据成员，也可以有非 abstract的成员方法，而在interface方式的实现中，只能够有静态的不能被修改的数据成员（也就是必须是static final 的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的 abstract class。（接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。）

在具体的使用上面还是有一些区别的：
    首先，abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系(因为Java不支持多继承 -- 转注)。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧.
    其次，在abstract class的定义中，我们可以赋予方法的默认行为（所谓默认行为，就是上面说的可以有非abstract方法）。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会增加一些复杂性，有时会造成很大的麻烦。

17.1、abstract class和interface都有构造函数吗？
答：abstract class有构造函数，就算自己没写，编译器也会给加上（不能有抽象构造函数和抽象静态方法）。interface没有构造函数，想了几个接口中不能定义构造器的理由：
1. 构造器用于初始化成员变量，接口没有成员变量
2. 类可以实现多个接口，若多个接口都有自己的构造器，则不好决定构造器链的调用次序
3. 构造器是属于类自己的，不能继承。因为是纯虚的，接口不需要构造器。

18、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized
答：都不能

 

19、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)
答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类可以继承实体类，但是和实体类的继承一样，也要求父类可继承，并且拥有子类可访问到的构造器。解释如下：

一般学习者会写的简单试验代码：

 

class A{}

abstract class B extends A{}

 

结果完全正常，编译通过。似乎和“实体类必须有明确的构造函数”完全没有关系。

 

这个问题涉及到两个个基础知识：

1.

所有的class都必须有一个构造方法，如果你没有在代码里声明构造方法，系统会自动给你生成一个公有无参的构造方法。而只要你自己声明了一个构造方法，无论有参无参，私有公有，系统就不再帮你生成默认无参构造器了。

2.

所有的子类构造器都要求在第一行代码中调用父类构造器，如果不写，系统默认去调用父类的无参构造器。

 

 

所以，如果把系统默认配给的方法也算进去，class A{}的代码实际上是

class A{

public A(){}

}

 

B继承 A 的时候，则是

abstract class B extends A{

public B(){

super();

}

}

 

要试验出这继承规则的内部情况，也很简单，在最上面那个简单试验代码里，加上个私有构造器，有参无参都行。

class A{

private A(){}

}

这个时候，如基础知识(1) 中所说，系统不再给你默认无参构造器， B的构造器根据（2）中的规则去调用super()，却找不到A的无参构造器，所以导致abstract class B extends A{} 编译不能通过。（因为A中没有任何构造器可供子类调用，其实这个时候A只能够供内部类继承，我用的Eclipse的3.4版本会建议给B改名，但是这解决不了这个问题。）

 

现在，你应该了解了资料给的那句语焉不详的“实体类必须有明确的构造函数”的含义：

1.没写构造器的，那是拥有默认无参公有构造函数的，子类可以什么都不写，让默认构造器去调用它。这是最初那两行代码的情况。

2.写了子类可访问的无参构造器的，也是一样，子类里可以什么都不写，用默认机制调用。

3.写了 有参构造器却没写无参构造器的，父类里没有子类可访问的无参构造器，子类必须在子类构造器里的第一句写明，调用父类有参构造器，并把参数传进去。

4.声明为final的以及所有构造器都不在子类访问权限之内的类无法继承

 

其实只要是在类的继承中，无论抽象还是实体，都需要符合这个规则的。在这个继承试验中随时删掉或是加上abstract的前缀，结果都没有变化。个人觉得“实体类必须有明确的构造函数”一句实在是无法把这个情况表达清楚，所以广大求职者还是写得清楚些好。

 

 

20、构造器Constructor是否可被override
答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading

 

21、是否可以继承String类
答：String类是final类故不可以继承

22、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后
答：会执行，在return前执行

23、用最有效率的方法算出2乘以8等於几
答：2 << 3

24、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对
答：不对，有相同的hash code.（哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是，因为如果那个地址已经有数据了，就得再散列其他地址）。Java对于eqauls方法和hashCode方法是这样规定的：1、如果两个对象相同，那么它们的hashCode值一定要相同；2、如果两个对象的hashCode相同，它们并不一定相同    上面说的对象相同指的是用eqauls方法比较。 你当然可以不按要求去做了，但你会发现，相同的对象可以出现在Set集合中。同时，增加新元素的效率会大大下降。

25、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递
答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的

26、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
答：witch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich

27、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

28、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

29、GC是什么? 为什么要有GC
答：GC 是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至 崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

要请求垃圾收集，可以调用下面的方法之一： System.gc()
Runtime.getRuntime().gc()

30、float型float f=3.4是否正确?
答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4

 

31、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射

32、抽象类与接口？
答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。
JAVA类实现序例化的方法是实现java.io.Serializable接口
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

33、STRING与STRINGBUFFER的区别。
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

34、谈谈final, finally, finalize的区别
答：final —修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定 初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
finalize —方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

 

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

39、说出ArrayList,Vector, LinkedList的存储性能和特性
答：ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的 素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差， 而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

35、面向对象的特征有哪些方面 
答：主要有以下四方面：
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继 承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继 承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增 加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

36、String是最基本的数据类型吗
答：基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

37、int 和 Integer 有什么区别
答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。原始类型封装类booleanBoolean,

charCharacter,byteByte,shortShort,intInteger,

longLong,floatFloat,doubleDouble，

 

 

 

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关

 

40、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的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。