JAVA面试题解惑系列

 

JAVA面试题解惑系列

分类： javase 2013-08-12 20:09  252人阅读  评论(0)  收藏  举报

目录(?)[+]

JAVA面试题解惑系列(一)——类的初始化顺序

• 博客分类：  
• JAVA面试题解惑系列

面试 java

对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器。我们也可以通过下面的测试代码来验证这一点： 
Java代码  
public class InitialOrderTest {   
  
    // 静态变量   
    public static String staticField = "静态变量";   
    // 变量   
    public String field = "变量";   
  
    // 静态初始化块   
    static {   
        System.out.println(staticField);   
        System.out.println("静态初始化块");   
    }   
  
    // 初始化块   
    {   
        System.out.println(field);   
        System.out.println("初始化块");   
    }   
  
    // 构造器   
    public InitialOrderTest() {   
        System.out.println("构造器");   
    }   
  
    public static void main(String[] args) {   
        new InitialOrderTest();   
    }   
}  

运行以上代码，我们会得到如下的输出结果： 
静态变量 
静态初始化块 
变量 
初始化块 
构造器 

这与上文中说的完全符合。那么对于继承情况下又会怎样呢？我们仍然以一段测试代码来获取最终结果： 
Java代码  
class Parent {   
    // 静态变量   
    public static String p_StaticField = "父类--静态变量";   
    // 变量   
    public String p_Field = "父类--变量";   
  
    // 静态初始化块   
    static {   
        System.out.println(p_StaticField);   
        System.out.println("父类--静态初始化块");   
    }   
  
    // 初始化块   
    {   
        System.out.println(p_Field);   
        System.out.println("父类--初始化块");   
    }   
  
    // 构造器   
    public Parent() {   
        System.out.println("父类--构造器");   
    }   
}   
  
public class SubClass extends Parent {   
    // 静态变量   
    public static String s_StaticField = "子类--静态变量";   
    // 变量   
    public String s_Field = "子类--变量";   
    // 静态初始化块   
    static {   
        System.out.println(s_StaticField);   
        System.out.println("子类--静态初始化块");   
    }   
    // 初始化块   
    {   
        System.out.println(s_Field);   
        System.out.println("子类--初始化块");   
    }   
    // 构造器   
    public SubClass() {   
        System.out.println("子类--构造器");   
                 }   
    // 程序入口   
    public static void main(String[] args) {   
        new SubClass();   
    }   
}  

运行一下上面的代码，结果马上呈现在我们的眼前： 
父类--静态变量 
父类--静态初始化块 
子类--静态变量 
子类--静态初始化块 
父类--变量 
父类--初始化块 
父类--构造器 
子类--变量 
子类--初始化块 
子类--构造器 

现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。 

那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。 

同样，我们还是写一个类来进行测试： 
Java代码  
public class TestOrder {   
    // 静态变量   
    public static TestA a = new TestA();   
       
    // 静态初始化块   
    static {   
        System.out.println("静态初始化块");   
    }   
       
    // 静态变量   
    public static TestB b = new TestB();   
  
    public static void main(String[] args) {   
        new TestOrder();   
    }   
}   
  
class TestA {   
    public TestA() {   
        System.out.println("Test--A");   
    }   
}   
  
class TestB {   
    public TestB() {   
        System.out.println("Test--B");   
    }   
}  

运行上面的代码，会得到如下的结果： 
Test--A 
静态初始化块 
Test--B 

大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。 

了解了继承情况下类的初始化顺序之后，如何判断最终输出结果就迎刃而解了。

JAVA面试题解惑系列(二)——到底创建了几个String对象

• 博客分类：  
• JAVA面试题解惑系列

面试 java 

Java代码  
1. String str=new String("abc");  

紧接着这段代码之后的往往是这个问题，那就是这行代码究竟创建了几个String对象呢？相信大家对这道题并不陌生，答案也是众所周知的，2个。接下来我们就从这道题展开，一起回顾一下与创建String对象相关的一些JAVA知识。 

我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String("abc")了。那么，new String("abc")为什么又能被看成"abc"和new String()呢？我们来看一下被我们调用了的String的构造器： 
Java代码  
1. public String(String original) {   
2.     //other code ...   
3. }  

大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种： 
1. 使用new创建对象。 
2. 调用Class类的newInstance方法，利用反射机制创建对象。 

我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。 

这种方式是String特有的，并且它与new的方式存在很大区别。 
Java代码  
1. String str="abc";  

毫无疑问，这行代码创建了一个String对象。 
Java代码  
1. String a="abc";   
2. String b="abc";  

那这里呢？答案还是一个。 
Java代码  
1. String a="ab"+"cd";  

再看看这里呢？答案仍是一个。有点奇怪吗？说到这里，我们就需要引入对字符串池相关知识的回顾了。 

在JAVA虚拟机（JVM）中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。由于String类是final的，它的值一经创建就不可改变，因此我们不用担心String对象共享而带来程序的混乱。字符串池由String类维护，我们可以调用intern()方法来访问字符串池。 

我们再回头看看String a="abc";，这行代码被执行的时候，JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象，它的判断依据是String类equals(Object obj)方法的返回值。如果有，则不再创建新的对象，直接返回已存在对象的引用；如果没有，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。因此，我们不难理解前面三个例子中头两个例子为什么是这个答案了。 

对于第三个例子： 
Java代码  
1. String a="ab"+"cd";  

由于常量的值在编译的时候就被确定了。在这里，"ab"和"cd"都是常量，因此变量a的值在编译时就可以确定。这行代码编译后的效果等同于： 
Java代码  
1. String a="abcd";  

因此这里只创建了一个对象"abcd"，并且它被保存在字符串池里了。 

现在问题又来了，是不是所有经过“+”连接后得到的字符串都会被添加到字符串池中呢？我们都知道“==”可以用来比较两个变量，它有以下两种情况： 
1. 如果比较的是两个基本类型（char，byte，short，int，long，float，double，boolean），则是判断它们的值是否相等。 
2. 如果表较的是两个对象变量，则是判断它们的引用是否指向同一个对象。 

下面我们就用“==”来做几个测试。为了便于说明，我们把指向字符串池中已经存在的对象也视为该对象被加入了字符串池： 
Java代码  
1. public class StringTest {   
2.     public static void main(String[] args) {   
3.         String a = "ab";// 创建了一个对象，并加入字符串池中   
4.         System.out.println("String a = \"ab\";");   
5.         String b = "cd";// 创建了一个对象，并加入字符串池中   
6.         System.out.println("String b = \"cd\";");   
7.         String c = "abcd";// 创建了一个对象，并加入字符串池中   
8.   
9.         String d = "ab" + "cd";   
10.         // 如果d和c指向了同一个对象，则说明d也被加入了字符串池   
11.         if (d == c) {   
12.             System.out.println("\"ab\"+\"cd\" 创建的对象 \"加入了\" 字符串池中");   
13.         }   
14.         // 如果d和c没有指向了同一个对象，则说明d没有被加入字符串池   
15.         else {   
16.             System.out.println("\"ab\"+\"cd\" 创建的对象 \"没加入\" 字符串池中");   
17.         }   
18.   
19.         String e = a + "cd";   
20.         // 如果e和c指向了同一个对象，则说明e也被加入了字符串池   
21.         if (e == c) {   
22.             System.out.println(" a  +\"cd\" 创建的对象 \"加入了\" 字符串池中");   
23.         }   
24.         // 如果e和c没有指向了同一个对象，则说明e没有被加入字符串池   
25.         else {   
26.             System.out.println(" a  +\"cd\" 创建的对象 \"没加入\" 字符串池中");   
27.         }   
28.   
29.         String f = "ab" + b;   
30.         // 如果f和c指向了同一个对象，则说明f也被加入了字符串池   
31.         if (f == c) {   
32.             System.out.println("\"ab\"+ b   创建的对象 \"加入了\" 字符串池中");   
33.         }   
34.         // 如果f和c没有指向了同一个对象，则说明f没有被加入字符串池   
35.         else {   
36.             System.out.println("\"ab\"+ b   创建的对象 \"没加入\" 字符串池中");   
37.         }   
38.   
39.         String g = a + b;   
40.         // 如果g和c指向了同一个对象，则说明g也被加入了字符串池   
41.         if (g == c) {   
42.             System.out.println(" a  + b   创建的对象 \"加入了\" 字符串池中");   
43.         }   
44.         // 如果g和c没有指向了同一个对象，则说明g没有被加入字符串池   
45.         else {   
46.             System.out.println(" a  + b   创建的对象 \"没加入\" 字符串池中");   
47.         }   
48.     }   
49. }  

运行结果如下： 
1. String a = "ab"; 
2. String b = "cd"; 
3. "ab"+"cd" 创建的对象 "加入了" 字符串池中 
4. a +"cd" 创建的对象 "没加入" 字符串池中 
5. "ab"+ b 创建的对象 "没加入" 字符串池中 
6. a + b 创建的对象 "没加入" 字符串池中 

从上面的结果中我们不难看出，只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中，对此我们不再赘述。 

但是有一种情况需要引起我们的注意。请看下面的代码： 
Java代码  
1. public class StringStaticTest {   
2.     // 常量A   
3.     public static final String A = "ab";   
4.   
5.     // 常量B   
6.     public static final String B = "cd";   
7.   
8.     public static void main(String[] args) {   
9.         // 将两个常量用+连接对s进行初始化   
10.         String s = A + B;   
11.         String t = "abcd";   
12.         if (s == t) {   
13.             System.out.println("s等于t，它们是同一个对象");   
14.         } else {   
15.             System.out.println("s不等于t，它们不是同一个对象");   
16.         }   
17.     }   
18. }  

这段代码的运行结果如下： 
• s等于t，它们是同一个对象 

这又是为什么呢？原因是这样的，对于常量来讲，它的值是固定的，因此在编译期就能被确定了，而变量的值只有到运行时才能被确定，因为这个变量可以被不同的方法调用，从而可能引起值的改变。在上面的例子中，A和B都是常量，值是固定的，因此s的值也是固定的，它在类被编译时就已经确定了。也就是说： 
Java代码  
1. String s=A+B;  

等同于： 
Java代码  
1. String s="ab"+"cd";  

我对上面的例子稍加改变看看会出现什么情况： 
Java代码  
1. public class StringStaticTest {   
2.     // 常量A   
3.     public static final String A;   
4.   
5.     // 常量B   
6.     public static final String B;   
7.   
8.     static {   
9.         A = "ab";   
10.         B = "cd";   
11.     }   
12.   
13.     public static void main(String[] args) {   
14.         // 将两个常量用+连接对s进行初始化   
15.         String s = A + B;   
16.         String t = "abcd";   
17.         if (s == t) {   
18.             System.out.println("s等于t，它们是同一个对象");   
19.         } else {   
20.             System.out.println("s不等于t，它们不是同一个对象");   
21.         }   
22.     }   
23. }  

它的运行结果是这样： 
• s不等于t，它们不是同一个对象 

只是做了一点改动，结果就和刚刚的例子恰好相反。我们再来分析一下。A和B虽然被定义为常量（只能被赋值一次），但是它们都没有马上被赋值。在运算出s的值之前，他们何时被赋值，以及被赋予什么样的值，都是个变数。因此A和B在被赋值之前，性质类似于一个变量。那么s就不能在编译期被确定，而只能在运行时被创建了。 

由于字符串池中对象的共享能够带来效率的提高，因此我们提倡大家用引号包含文本的方式来创建String对象，实际上这也是我们在编程中常采用的。 

接下来我们再来看看intern()方法，它的定义如下： 
Java代码  
1. public native String intern();  

这是一个本地方法。在调用这个方法时，JAVA虚拟机首先检查字符串池中是否已经存在与该对象值相等对象存在，如果有则返回字符串池中对象的引用；如果没有，则先在字符串池中创建一个相同值的String对象，然后再将它的引用返回。 

我们来看这段代码： 
Java代码  
1. public class StringInternTest {   
2.     public static void main(String[] args) {   
3.         // 使用char数组来初始化a，避免在a被创建之前字符串池中已经存在了值为"abcd"的对象   
4.         String a = new String(new char[] { 'a', 'b', 'c', 'd' });   
5.         String b = a.intern();   
6.         if (b == a) {   
7.             System.out.println("b被加入了字符串池中，没有新建对象");   
8.         } else {   
9.             System.out.println("b没被加入字符串池中，新建了对象");   
10.         }   
11.     }   
12. }  

运行结果： 
1. b没被加入字符串池中，新建了对象 

如果String类的intern()方法在没有找到相同值的对象时，是把当前对象加入字符串池中，然后返回它的引用的话，那么b和a指向的就是同一个对象；否则b指向的对象就是JAVA虚拟机在字符串池中新建的，只是它的值与a相同罢了。上面这段代码的运行结果恰恰印证了这一点。 

最后我们再来说说String对象在JAVA虚拟机（JVM）中的存储，以及字符串池与堆（heap）和栈（stack）的关系。我们首先回顾一下堆和栈的区别： 
• 栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（register），快于堆。 
• 堆（heap）：用于存储对象。 

我们查看String类的源码就会发现，它有一个value属性，保存着String对象的值，类型是char[]，这也正说明了字符串就是字符的序列。 

当执行String a="abc";时，JAVA虚拟机会在栈中创建三个char型的值'a'、'b'和'c'，然后在堆中创建一个String对象，它的值（value）是刚才在栈中创建的三个char型值组成的数组{'a','b','c'}，最后这个新创建的String对象会被添加到字符串池中。如果我们接着执行String b=new String("abc");代码，由于"abc"已经被创建并保存于字符串池中，因此JAVA虚拟机只会在堆中新创建一个String对象，但是它的值（value）是共享前一行代码执行时在栈中创建的三个char型值值'a'、'b'和'c'。 

说到这里，我们对于篇首提出的String str=new String("abc")为什么是创建了两个对象这个问题就已经相当明了了。

解惑系列(三)——变量(属性)的覆盖

• 博客分类：  
• JAVA面试题解惑系列

java

Java代码  
class ParentClass {   
    public int i = 10;   
}   
  
public class SubClass extends ParentClass {   
    public int i = 30;   
  
    public static void main(String[] args) {   
        ParentClass parentClass = new SubClass();   
        SubClass subClass = new SubClass();   
        System.out.println(parentClass.i + subClass.i);   
    }   
}  


控制台的输出结果是多少呢？20？40？还是60？ 

变量，或者叫做类的属性，在继承的情况下，如果父类和子类存在同名的变量会出现什么情况呢？这就是这道题要考查的知识点——变量（属性）的覆盖。 

这个问题虽然简单，但是情况却比较复杂。因为我们不仅要考虑变量、静态变量和常量三种情况，还要考虑private、friendly（即不加访问修饰符）、protected和public四种访问权限下对属性的不同影响。 

我们先从普通变量说起。依照我们的惯例，先来看一段代码： 
Java代码  
class ParentClass {   
    private String privateField = "父类变量--private";   
  
    /* friendly */String friendlyField = "父类变量--friendly";   
  
    protected String protectedField = "父类变量--protected";   
  
    public String publicField = "父类变量--public";   
  
    // private的变量无法直接访问，因此我们给他增加了一个访问方法   
    public String getPrivateFieldValue() {   
        return privateField;   
    }   
}   
  
public class SubClass extends ParentClass {   
    private String privateField = "子类变量--private";   
  
    /* friendly */String friendlyField = "子类变量--friendly";   
  
    protected String protectedField = "子类变量--protected";   
  
    public String publicField = "子类变量--public";   
  
    // private的变量无法直接访问，因此我们给他增加了一个访问方法   
    public String getPrivateFieldValue() {   
        return privateField;   
    }   
  
    public static void main(String[] args) {   
        // 为了便于查阅，我们统一按照private、friendly、protected、public的顺序   
        // 输出下列三种情况中变量的值   
  
        // ParentClass类型，ParentClass对象   
        ParentClass parentClass = new ParentClass();   
        System.out.println("ParentClass parentClass = new ParentClass();");   
        System.out.println(parentClass.getPrivateFieldValue());   
        System.out.println(parentClass.friendlyField);   
        System.out.println(parentClass.protectedField);   
        System.out.println(parentClass.publicField);   
  
        System.out.println();   
  
        // ParentClass类型，SubClass对象   
        ParentClass subClass = new SubClass();   
        System.out.println("ParentClass subClass = new SubClass();");   
        System.out.println(subClass.getPrivateFieldValue());   
        System.out.println(subClass.friendlyField);   
        System.out.println(subClass.protectedField);   
        System.out.println(subClass.publicField);   
  
        System.out.println();   
  
        // SubClass类型，SubClass对象   
        SubClass subClazz = new SubClass();   
        System.out.println("SubClass subClazz = new SubClass();");   
        System.out.println(subClazz.getPrivateFieldValue());   
        System.out.println(subClazz.friendlyField);   
        System.out.println(subClazz.protectedField);   
        System.out.println(subClazz.publicField);   
    }   
}  

这段代码的运行结果如下： 
ParentClass parentClass = new ParentClass(); 
父类变量--private 
父类变量--friendly 
父类变量--protected 
父类变量--public 

ParentClass subClass = new SubClass(); 
子类变量--private 
父类变量--friendly 
父类变量--protected 
父类变量--public 

SubClass subClazz = new SubClass(); 
子类变量--private 
子类变量--friendly 
子类变量--protected 
子类变量--public 

从上面的结果中可以看出，private的变量与其它三种访问权限变量的不同，这是由于方法的重写（override）而引起的。关于重写知识的回顾留给以后的章节，这里我们来看一下其它三种访问权限下变量的覆盖情况。 

分析上面的输出结果就会发现，变量的值取决于我们定义的变量的类型，而不是创建的对象的类型。 

在上面的例子中，同名的变量访问权限也是相同的，那么对于名称相同但是访问权限不同的变量，情况又会怎样呢？事实胜于雄辩，我们继续来做测试。由于private变量的特殊性，在接下来的实验中我们都把它排除在外，不予考虑。 

由于上面的例子已经说明了，当变量类型是父类（ParentClass）时，不管我们创建的对象是父类（ParentClass）的还是子类（SubClass）的，都不存在属性覆盖的问题，因此接下来我们也只考虑变量类型和创建对象都是子类（SubClass）的情况。 
Java代码  
class ParentClass {   
    /* friendly */String field = "父类变量";   
}   
  
public class SubClass extends ParentClass {   
    protected String field = "子类变量";   
  
    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(subClass.field);   
    }   
}  

运行结果： 
• 子类变量 

Java代码  
class ParentClass {   
    public String field = "父类变量";   
}   
  
public class SubClass extends ParentClass {   
    protected String field = "子类变量";   
  
    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(subClass.field);   
    }   
}  

运行结果： 
• 子类变量 

上面两段不同的代码，输出结果确是相同的。事实上，我们可以将父类和子类属性前的访问修饰符在friendly、protected和public之间任意切换，得到的结果都是相同的。也就是说访问修饰符并不影响属性的覆盖，关于这一点大家可以自行编写测试代码验证。 

对于静态变量和常量又会怎样呢？我们继续来看： 
Java代码  
class ParentClass {   
    public static String staticField = "父类静态变量";   
  
    public final String finalField = "父类常量";   
  
    public static final String staticFinalField = "父类静态常量";   
}   
  
public class SubClass extends ParentClass {   
    public static String staticField = "子类静态变量";   
  
    public final String finalField = "子类常量";   
  
    public static final String staticFinalField = "子类静态常量";   
  
    public static void main(String[] args) {   
        SubClass subClass = new SubClass();   
        System.out.println(SubClass.staticField);   
        System.out.println(subClass.finalField);   
        System.out.println(SubClass.staticFinalField);   
    }   
}  

运行结果如下： 
子类静态变量 
子类常量 
子类静态常量 

虽然上面的结果中包含“子类静态变量”和“子类静态常量”，但这并不表示父类的“静态变量”和“静态常量”可以被子类覆盖，因为它们都是属于类，而不属于对象。 

上面的例子中，我们一直用对象来对变量（属性）的覆盖做测试，如果是基本类型的变量，结果是否会相同呢？答案是肯定的，这里我们就不再一一举例说明了。 

最后，我们来做个总结。通过以上测试，可以得出一下结论： 
由于private变量受访问权限的限制，它不能被覆盖。 
属性的值取父类还是子类并不取决于我们创建对象的类型，而是取决于我们定义的变量的类型。 
friendly、protected和public修饰符并不影响属性的覆盖。 
静态变量和静态常量属于类，不属于对象，因此它们不能被覆盖。 
常量可以被覆盖。 
对于基本类型和对象，它们适用同样的覆盖规律。 

我们再回到篇首的那道题，我想大家都已经知道答案了，输出结果应该是40。