请别再拿“String s = new String("xyz");创建了多少个String实例”来面试了吧

这帖是用来回复高级语言虚拟机圈子里的一个问题，一道Java笔试题的。
本来因为见得太多已经吐槽无力，但这次实在忍不住了就又爆发了一把。写得太长干脆单独开了一帖。

顺带广告：对JVM感兴趣的同学们同志们请多多支持高级语言虚拟机圈子 

以下是回复内容。文中的“楼主”是针对原问题帖而言。

===============================================================

楼主是看各种宝典了么……以后我面试人的时候就要专找宝典答案是错的来问，方便筛人orz

楼主要注意了：这题或类似的题虽然经常见，但使用这个描述方式实际上没有任何意义：

引用

问题：

String s = new String("xyz");

创建了几个String Object？

这个问题自身就没有合理的答案，楼主所引用的“标准答案”自然也就不准确了：

引用

答案：两个(一个是“xyz”,一个是指向“xyz”的引用对象s)

（好吧这个答案的吐槽点很多……大家慢慢来）

这问题的毛病是什么呢？它并没有定义“创建了”的意义。
什么叫“创建了”？什么时候创建了什么？
而且这段Java代码片段实际运行的时候真的会“创建两个String实例”么？

如果这道是面试题，那么可以当面让面试官澄清“创建了”的定义，然后再对应的回答。这种时候面试官多半会让被面试者自己解释，那就好办了，好好晒给面试官看。

如果是笔试题就没有提问要求澄清的机会了。不过会出这种题目的地方水平多半也不怎么样。说不定出题的人就是从各种宝典上把题抄来的，那就按照宝典把那不大对劲的答案写上去就能混过去了

===============================================================

先换成另一个问题来问：

引用

问题：

String s = new String("xyz");

在运行时涉及几个String实例？

一种合理的解答是：

引用

答案：两个，一个是字符串字面量"xyz"所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与"xyz"相同的实例

这是根据Java语言规范相关规定可以给出的合理答案。考虑到Java语言规范中明确指出了：

The Java Language Specification, Third Edition 写道

The Java programming language is normally compiled to the bytecoded instruction set and binary format defined in The Java Virtual Machine Specification, Second Edition (Addison-Wesley, 1999).

也就是规定了Java语言一般是编译为Java虚拟机规范所定义的Class文件，但并没有规定“一定”（must），留有不使用JVM来实现Java语言的余地。
考虑上Java虚拟机规范，确实在这段代码里涉及的常量种类为CONSTANT_String_info的字符串常量也只有"xyz"一个。CONSTANT_String_info是用来表示Java语言中String类型的常量表达式的值（包括字符串字面量）用的常量种类，只在这个层面上考虑的话，这个解答也没问题。
所以这种解答可以认为是合理的。

值得注意的是问题中“在运行时”既包括类加载阶段，也包括这个代码片段自身执行的时候。下文会再讨论这个细节与楼主原本给出的问题的关系。

碰到这种问题首先应该想到去查阅相关的规范，这里具体是Java语言规范与Java虚拟机规范，以及一些相关API的JavaDoc。很多人喜欢把“按道理说”当作口头禅，规范就是用来定义各种“道理”的——“为什么XXX是YYY的意思？”“因为规范里是这样定义的！”——无敌了。

在Java虚拟机规范中相关的定义有下面一些：

The Java Virtual Machine Specification, Second Edition 写道

2.3 Literals

A literal is the source code representation of a value of a primitive type (§2.4.1), the String type (§2.4.8), or the null type (§2.4). String literals and, more generally, strings that are the values of constant expressions are "interned" so as to share unique instances, using the method String.intern.

The null type has one value, the null reference, denoted by the literal null. The boolean type has two values, denoted by the literals true and false.

2.4.8 The Class String

Instances of class String represent sequences of Unicode characters (§2.1). A String object has a constant, unchanging value. String literals (§2.3) are references to instances of class String.

2.17.6 Creation of New Class Instances

A new class instance is explicitly created when one of the following situations occurs:

• Evaluation of a class instance creation expression creates a new instance of the class whose name appears in the expression.
• Invocation of the newInstance method of class Class creates a new instance of the class represented by the Class object for which the method was invoked.

A new class instance may be implicitly created in the following situations:

• Loading of a class or interface that contains a String literal may create a new String object (§2.4.8) to represent that literal. This may not occur if the a String object has already been created to represent a previous occurrence of that literal, or if the String.intern method has been invoked on a String object representing the same string as the literal.
• Execution of a string concatenation operator that is not part of a constant expression sometimes creates a new String object to represent the result. String concatenation operators may also create temporary wrapper objects for a value of a primitive type (§2.4.1).

Each of these situations identifies a particular constructor to be called with specified arguments (possibly none) as part of the class instance creation process.

5.1 The Runtime Constant Pool

...

● A string literal (§2.3) is derived from a CONSTANT_String_info structure (§4.4.3) in the binary representation of a class or interface. The CONSTANT_String_info structure gives the sequence of Unicode characters constituting the string literal.

● The Java programming language requires that identical string literals (that is, literals that contain the same sequence of characters) must refer to the same instance of class String. In addition, if the method String.intern is called on any string, the result is a reference to the same class instance that would be returned if that string appeared as a literal. Thus,

("a" + "b" + "c").intern() == "abc"

must have the value true.

● To derive a string literal, the Java virtual machine examines the sequence of characters given by the CONSTANT_String_info structure.

  ○ If the method String.intern has previously been called on an instance of class String containing a sequence of Unicode characters identical to that given by the CONSTANT_String_info structure, then the result of string literal derivation is a reference to that same instance of class String.

  ○ Otherwise, a new instance of class String is created containing the sequence of Unicode characters given by the CONSTANT_String_info structure; that class instance is the result of string literal derivation. Finally, the intern method of the new String instance is invoked.

...

The remaining structures in the constant_pool table of the binary representation of a class or interface, the CONSTANT_NameAndType_info (§4.4.6) and CONSTANT_Utf8_info (§4.4.7) structures are only used indirectly when deriving symbolic references to classes, interfaces, methods, and fields, and when deriving string literals.

把Sun的JDK看作参考实现（reference implementation, RI），其中String.intern()的JavaDoc为：

JavaDoc 写道

public String intern()

    Returns a canonical representation for the string object.

    A pool of strings, initially empty, is maintained privately by the class String.

    When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

    It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

    All literal strings and string-valued constant expressions are interned. String literals are defined in §3.10.5 of the Java Language Specification

    Returns:
        a string that has the same contents as this string, but is guaranteed to be from a pool of unique strings.

===============================================================

再换一个问题来问：

引用

问题：

String s = new String("xyz");

涉及用户声明的几个String类型的变量？

答案也很简单：

引用

答案：一个，就是String s。

把问题换成下面这个版本，答案也一样：

引用

问题：

String s = null;

涉及用户声明的几个String类型的变量？

Java里变量就是变量，引用类型的变量只是对某个对象实例或者null的引用，不是实例本身。声明变量的个数跟创建实例的个数没有必然关系，像是说：

String s1 = "a";
String s2 = s1.concat("");
String s3 = null;
new String(s1);

这段代码会涉及3个String类型的变量，
1、s1，指向下面String实例的1
2、s2，指向与s1相同
3、s3，值为null，不指向任何实例

以及3个String实例，
1、"a"字面量对应的驻留的字符串常量的String实例
2、""字面量对应的驻留的字符串常量的String实例
（String.concat()是个有趣的方法，当发现传入的参数是空字符串时会返回this，所以这里不会额外创建新的String实例）
3、通过new String(String)创建的新String实例；没有任何变量指向它。

===============================================================

回到楼主开头引用的问题与“标准答案”

引用

问题：

String s = new String("xyz");

创建了几个String Object？
答案：两个(一个是“xyz”,一个是指向“xyz”的引用对象s)

用归谬法论证。假定问题问的是“在执行这段代码片段时创建了几个String实例”。如果“标准答案”是正确的，那么下面的代码片段在执行时就应该创建4个String实例了：

String s1 = new String("xyz");
String s2 = new String("xyz");

马上就会有人跳出来说上下两个"xyz"字面量都是引用了同一个String对象，所以不应该是创建了4个对象。

那么应该是多少个？

运行时的类加载过程与实际执行某个代码片段，两者必须分开讨论才有那么点意义。

为了执行问题中的代码片段，其所在的类必然要先被加载，而且同一个类最多只会被加载一次（要注意对JVM来说“同一个类”并不是类的全限定名相同就足够了，而是<类全限定名, 定义类加载器>一对都相同才行）。

根据上文引用的规范的内容，符合规范的JVM实现应该在类加载的过程中创建并驻留一个String实例作为常量来对应"xyz"字面量；具体是在类加载的resolve阶段进行的。这个常量是全局共享的，只在先前尚未有内容相同的字符串驻留过的前提下才需要创建新的String实例。

等到真正执行原问题中的代码片段时，JVM需要执行的字节码类似这样：

0: new	#2; //class java/lang/String
3: dup
4: ldc	#3; //String xyz
6: invokespecial	#4; //Method java/lang/String."<init>":(Ljava/lang/String;)V
9: astore_1

这之中出现过多少次new java/lang/String就是创建了多少个String对象。也就是说原问题中的代码在每执行一次只会新创建一个String实例。
这里，ldc指令只是把先前在类加载过程中已经创建好的一个String对象（"xyz"）的一个引用压到操作数栈顶而已，并不新创建String对象。

所以刚才用于归谬的代码片段：

String s1 = new String("xyz");
String s2 = new String("xyz");

每执行一次只会新创建2个String实例。

---------------------------------------------------------------

为了避免一些同学犯糊涂，再强调一次：

在Java语言里，“new”表达式是负责创建实例的，其中会调用构造器去对实例做初始化；构造器自身的返回值类型是void，并不是“构造器返回了新创建的对象的引用”，而是new表达式的值是新创建的对象的引用。

对应的，在JVM里，“new”字节码指令只负责把实例创建出来（包括分配空间、设定类型、所有字段设置默认值等工作），并且把指向新创建对象的引用压到操作数栈顶。此时该引用还不能直接使用，处于未初始化状态（uninitialized）；如果某方法a含有代码试图通过未初始化状态的引用来调用任何实例方法，那么方法a会通不过JVM的字节码校验，从而被JVM拒绝执行。
能对未初始化状态的引用做的唯一一种事情就是通过它调用实例构造器，在Class文件层面表现为特殊初始化方法“<init>”。实际调用的指令是invokespecial，而在实际调用前要把需要的参数按顺序压到操作数栈上。在上面的字节码例子中，压参数的指令包括dup和ldc两条，分别把隐藏参数（新创建的实例的引用，对于实例构造器来说就是“this”）与显式声明的第一个实际参数（"xyz"常量的引用）压到操作数栈上。
在构造器返回之后，新创建的实例的引用就可以正常使用了。

关于构造器的讨论，可以参考我之前的一帖，实例构造器是不是静态方法？

===============================================================

以上讨论都只是针对规范所定义的Java语言与Java虚拟机而言。概念上是如此，但实际的JVM实现可以做得更优化，原问题中的代码片段有可能在实际执行的时候一个String实例也不会完整创建（没有分配空间）。

例如说，在x86、Windows Vista SP2、Sun JDK 6 update 14的fastdebug版上跑下面的测试代码：

public class C2EscapeAnalysisDemo {
  private static void warmUp() {
    IFoo[] array = new IFoo[] {
      new FooA(), new FooB(), new FooC(), new FooD()
    };
    for (int i = 0; i < 1000000; i++) {
      array[i % array.length].foo(); // megamorphic callsite to prevent inlining
    }
  }
  
  public static void main(String[] args) {
    while (true) {
      warmUp();
    }
  }
}

interface IFoo {
  void foo();
}

class FooA implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
  }
}

class FooB implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
    String s2 = new String("xyz");
  }
}

class FooC implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
    String s2 = new String("xyz");
    String s3 = new String("xyz");
  }
}

class FooD implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
    String s2 = new String("xyz");
    String s3 = new String("xyz");
    String s4 = new String("xyz");
  }
}

照常用javac用默认参数编译，然后先用server模式的默认配置来跑，顺带打出GC和JIT编译日志来看

java -server -verbose:gc -XX:+PrintCompilation C2EscapeAnalysisDemo

看到的日志的开头一段如下：

  1       java.lang.String::charAt (33 bytes)
  2       java.lang.Object::<init> (1 bytes)
  3       java.lang.String::<init> (61 bytes)
  1%      C2EscapeAnalysisDemo::warmUp @ 47 (71 bytes)
  4       FooA::foo (11 bytes)
  5       FooB::foo (21 bytes)
  6       FooC::foo (31 bytes)
  7       FooD::foo (42 bytes)
[GC 3072K->168K(32768K), 0.0058325 secs]
[GC 3240K->160K(32768K), 0.0104623 secs]
[GC 3232K->160K(32768K), 0.0027323 secs]
[GC 3232K->160K(35840K), 0.0026220 secs]
[GC 6304K->160K(35840K), 0.0173733 secs]
[GC 6304K->144K(41664K), 0.0059720 secs]
[GC 12432K->144K(41664K), 0.0353320 secs]
[GC 12432K->144K(54016K), 0.0139333 secs]
  8       C2EscapeAnalysisDemo::warmUp (71 bytes)
[GC 24720K->160K(54016K), 0.0697970 secs]
[GC 24736K->160K(68800K), 0.0261921 secs]
[GC 39520K->160K(68800K), 0.0958433 secs]
[GC 39520K->160K(87168K), 0.0433377 secs]
[GC 57888K->160K(87168K), 0.0542482 secs]
[GC 57888K->148K(87168K), 0.0533140 secs]
[GC 57876K->164K(84288K), 0.0533537 secs]
[GC 55204K->164K(81728K), 0.0596820 secs]
[GC 52644K->164K(79488K), 0.0515090 secs]
[GC 50212K->164K(76992K), 0.0491227 secs]
[GC 47908K->164K(74944K), 0.0450666 secs]
[GC 45668K->164K(72640K), 0.0467671 secs]
[GC 43556K->152K(70784K), 0.0420757 secs]
[GC 41560K->168K(68736K), 0.0391296 secs]
[GC 39656K->168K(67072K), 0.0397539 secs]
[GC 37864K->188K(65216K), 0.0360861 secs]

上面的日志中，后面的方法名的行是JIT编译的日志，而以[GC开头的是minor GC的日志。
程序一直跑，GC的日志还会不断的打出来。这是理所当然的对吧？HotSpot的堆就那么大，而测试代码在不断新创建String对象，肯定得不断触发GC的。

用不同的VM启动参数来跑的话，

java -server -verbose:gc -XX:+PrintCompilation -XX:+DoEscapeAnalysis -XX:+EliminateAllocations C2EscapeAnalysisDemo

还是同样的Java测试程序，同样的Sun JDK 6 update 14，但打开了逃逸分析和空间分配消除功能，再运行，看到的全部日志如下：

  1       java.lang.String::charAt (33 bytes)
  2       java.lang.Object::<init> (1 bytes)
  3       java.lang.String::<init> (61 bytes)
  1%      C2EscapeAnalysisDemo::warmUp @ 47 (71 bytes)
  5       FooB::foo (21 bytes)
  4       FooA::foo (11 bytes)
  6       FooC::foo (31 bytes)
  7       FooD::foo (42 bytes)
[GC 3072K->176K(32768K), 0.0056527 secs]
  8       C2EscapeAnalysisDemo::warmUp (71 bytes)

继续跑下去也没有再打出GC日志了。难道新创建String对象都不吃内存了么？

实际情况是：经过HotSpot的server模式编译器的优化后，FooA、FooB、FooC、FooD四个版本的foo()实现都不新创建String实例了。这样自然不吃内存，也就不再触发GC了。
经过的分析和优化笼统说有方法内联（method inlining）、逃逸分析（escape analysis）、标量替换（scalar replacement）、无用代码削除（dead-code elimination）之类。

FooA.foo()最短，就以它举例来大致演示一下优化的过程。
它其实就是创建并初始化了一个String对象而已。调用的构造器的源码是：

public String(String original) {
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // The array representing the String is bigger than the new
       // String itself.  Perhaps this constructor is being called
       // in order to trim the baggage, so make a copy of the array.
      int off = original.offset;
      v = Arrays.copyOfRange(originalValue, off, off+size);
    } else {
       // The array representing the String is the same
       // size as the String, so no point in making a copy.
      v = originalValue;
    }
    this.offset = 0;
    this.count = size;
    this.value = v;
}

因为参数是"xyz"，可以确定在我们的测试代码里不会走到构造器的if分支里，下面为了演示方便就省略掉那部分代码（实际代码还是存在的，只是没执行而已）

public String(String original) {
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }
    this.offset = 0;
    this.count = size;
    this.value = v;
}

那么把构造器内联到FooA.foo()里，

public FooA implements IFoo {
  public void foo() {
    String s = AllocateString(); // 这里虚构一个只分配空间，不调用构造器的函数
    String original = "xyz";

    // 下面就是内联进来的构造器内容
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }

    s.offset = 0;
    s.count = size;
    s.value = v;
  }
}

然后经过逃逸分析与标量替换，

public FooA implements IFoo {
  public void foo() {
    String original = "xyz";
    
    // 下面就是内联进来的构造器内容
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }
    
    // 原本s的实例变量被标量替换为foo()的局部变量
    int sOffset = 0;
    int sCount = size;
    char[] sValue = v;
  }
}

注意，到这里就已经把新创建String在堆上分配空间的代码全部削除了，原本新建的String实例的字段变成了FooA.foo()的局部变量。
最后再经过无用代码削除，把sOffset、sCount和sValue这三个没被读过的局部变量给削除掉，

public FooA implements IFoo {
  public void foo() {
    String original = "xyz";
    
    // 下面就是内联进来的构造器内容
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }
    
    // 几个局部变量也干掉了
  }
}

这就跟FooA.foo()被优化编译后实际执行的代码基本一致了。
实际执行的x86代码如下：

0x0247aeec: mov    %eax,-0x4000(%esp) ; 检查栈是否溢出（stack bang），若溢出则这条指令会引发异常
0x0247aef3: push   %ebp               ; 保存老的栈帧指针
0x0247aef4: sub    $0x18,%esp         ; 为新栈帧分配空间
0x0247aefa: mov    $0x1027e9a8,%edi   ; String original /* EDI */ = "xyz"
0x0247aeff: mov    0x8(%edi),%ecx     ; char[] originalValue /* ECX */ = original.value;
0x0247af02: mov    0x8(%ecx),%ebx     ; EBX = originalValue.length
0x0247af05: mov    0x10(%edi),%ebp    ; int size /* EBP */ = original.count;
0x0247af08: cmp    %ebp,%ebx          ; 比较originalValue.length与size
0x0247af0a: jg     0x0247af17         ; 如果originalValue.length > size则跳转到0x0247af17
                                      ;   实际不会发生跳转（就是不会执行if分支），所以后面代码省略
0x0247af0c: add    $0x18,%esp         ; 撤销栈帧分配的空间
0x0247af0f: pop    %ebp               ; 恢复老的栈帧指针
0x0247af10: test   %eax,0x310000      ; 方法返回前检查是否需要进入safepoint （{poll_return}）
0x0247af16: ret                       ; 方法返回
0x0247af17: ; 以下是if分支和异常处理器的代码，因为实际不会执行，省略

看，确实没有新创建String对象了。

另外三个版本的foo()实现也是类似，HotSpot成功的把无用的new String("xyz")全部干掉了。
关于逃逸分析的例子，可以参考我以前一篇帖，HotSpot 17.0-b12的逃逸分析/标量替换的一个演示

再回头看看楼主的原问题，问题中的代码片段执行的时候（对应到FooA.foo()被调用的时候）一个String对象也没有新建。于是那“标准答案”在现实中的指导意义又有多少呢？

===============================================================

另外，楼主还提到了PermGen：

QM42977 写道

"xyz"在perm gen应该还会生成一个对象，因为常量("xyz")都会保存在perm gen中

这里也是需要强调一点：永生代（“Perm Gen”）只是Sun JDK的一个实现细节而已，Java语言规范和Java虚拟机规范都没有规定必须有“Permanent Generation”这么一块空间，甚至没规定要用什么GC算法——不用分代式GC算法哪儿来的“永生代”？

HotSpot的PermGen是用来实现Java虚拟机规范中的“方法区”（method area）的。如果使用“方法区”这个术语，在讨论概念中的JVM时就安全得多——大家都必须实现出这个表象。
当然如何实现又是另一回事了。Oracle JRockit没有PermGen，IBM J9也没有，事实上有这么一块空间特别管理的反而是少数吧orz

事实上新版HotSpot VM也在计划去除PermGen，转而使用native memory来实现方法区存储元数据。在JDK8的HotSpot VM中已经实现了这点。
可以参考这帖：http://rednaxelafx.iteye.com/blog/905273

===============================================================

费那么多口舌，最后点题：请别再拿“String s = new String("xyz");创建了多少个String实例”来面试了吧，既没意义又不涨面子。

困，睡觉去……

评论

59 楼 zhaoshun0417 2010-09-30  

k看这自卑！！原来我这么菜！

58 楼 RednaxelaFX 2010-09-30  

allskylove 写道

兄弟你方向搞错了，<init> 方法只是jvm内部调用的，并不是语言级别的，而是虚拟机调用的！真正到语言级别方法（构造器调用的时候） 返回的是类本身 ，比如 MyClassA a=new MyClassA(); 明显返回了类本身，才赋值给了变量a, 另外如果没有返回值，不管是方法还是构造器 都应该有些void ，由此看来， 构造器自身返回的类型是它自己本身.

确实有只能由JVM调用、而不能由用户代码显式调用的初始化方法，不过那个是<clinit>，对应于Java语言中类的静态初始化器。

The Java Virtual Machine, Second Edition 写道

3.9 Specially Named Initialization Methods

...

A class or interface has at most one class or interface initialization method and is initialized (§2.17.4) by invoking that method. The initialization method of a class or interface is static and takes no arguments. It has the special name <clinit>. This name is supplied by a compiler. Because the name <clinit> is not a valid identifier, it cannot be used directly in a program written in the Java programming language. Class and interface initialization methods are invoked implicitly by the Java virtual machine; they are never invoked directly from any Java virtual machine instruction, but are invoked only indirectly as part of the class initialization process.

如果您能读懂规范的话。

57 楼 paranoid945 2010-09-30  

其实这些是比较底层的东西，理想下Java程序员是不需要懂的，但是面试的时候如果大家知道的都一样，就比不出来了，就出了个这个问题，也能反映出这个人爱学习。
其实涉及到底层，东西多了去了，如果java设计的不好些，不仅需要了解jvm，bytecode，甚至c++实现或者汇编也会涉及。例如之前很著名的字符串循环+会造成系统变慢的事，那是jvm自己的问题，别的语言有这个问题嘛？新版本也fix了。搞的别人不知道就是菜鸟一样。

56 楼 RednaxelaFX 2010-09-30  

allskylove 写道

orcl_zhang 写道

引用

在Java语言里，“new”表达式是负责创建实例的，其中会调用构造器去对实例做初始化；构造器自身的返回值类型是void，并不是“构造器返回了新创建的对象的引用”，而是new表达式的值是新创建的对象的引用。

虽然java学的不好，也忘的差不多了。至少看到这，还是懂了。。

构造器自身的返回值类型是void？ 构造器自身返回的类型是它自己本身，不然怎么构造实例呢？返回都没有返回！

请先阅读Java虚拟机规范第二版的相关内容：

The Java Virtual Machine Specification, Second Edition 写道

2.12 Constructors

A constructor is used in the creation of an object that is an instance of a class. The constructor declaration looks like a method declaration that has no result type.

3.9 Specially Named Initialization Methods

At the level of the Java virtual machine, every constructor (§2.12) appears as an instance initialization method that has the special name <init>. This name is supplied by a compiler. Because the name <init> is not a valid identifier, it cannot be used directly in a program written in the Java programming language. Instance initialization methods may be invoked only within the Java virtual machine by the invokespecial instruction, and they may be invoked only on uninitialized class instances. An instance initialization method takes on the access permissions (§2.7.4) of the constructor from which it was derived.

4.3.3 Method Descriptors

A method descriptor represents the parameters that the method takes and the value that it returns:

MethodDescriptor:
     ( ParameterDescriptor* ) ReturnDescriptor

A parameter descriptor represents a parameter passed to a method:

ParameterDescriptor:
     FieldType

A return descriptor represents the type of the value returned from a method. It is a series of characters generated by the grammar:

ReturnDescriptor:
     FieldType
    V

The character V indicates that the method returns no value (its return type is void).

4.4.2 CONSTANT_Fieldref, CONSTANT_Methodref, and CONSTANT_InterfaceMethodref
   ...
       name_and_type_index

The value of the name_and_type_index item must be a valid index into the constant_pool table. The constant_pool entry at that index must be a CONSTANT_NameAndType_info (§4.4.6) structure. This constant_pool entry indicates the name and descriptor of the field or method.

If the name of the method of a CONSTANT_Methodref_info or CONSTANT_InterfaceMethodref_info begins with a '<' ('u003c'), then the name must be one of the special internal methods (§3.8), either <init> or <clinit>. In this case, the method must return no value.

4.9.4 Instance Initialization Methods and Newly Created Objects

Creating a new class instance is a multistep process. The Java statement

    ...

    new myClass(i, j, k);
    ...

can be implemented by the following:

    ...

    new     #1                   // Allocate uninitialized space for myClass
    dup                          // Duplicate object on the operand stack
    iload_1                      // Push i
    iload_2                      // Push j
    iload_3                      // Push k
    invokespecial myClass.<init> // Initialize object
    ...

This instruction sequence leaves the newly created and initialized object on top of the operand stack. (More examples of compiling Java code to the instruction set of the Java Virtual Machine are given in Chapter 7, "Compiling for the Java Virtual Machine.")
The instance initialization method <init> for class myClass sees the new uninitialized object as its this argument in local variable 0. It must either invoke an alternative instance initialization method for class myClass or invoke the initialization method of a superclass on the this object before it is allowed to do anything else with this.

Java语言里类的实例构造器，在Class文件和JVM里方法名是<init>，返回值类型是void，这是规范里规定的。
如果您不愿意阅读规范，可以用您已经知道的javap工具来看看下面的代码对应的Class文件的内容：

public class CtorDemo {
    public static void main(String[] args) {
        new Object();
    }
}

main()的内容是：

0:   new     #2; //class java/lang/Object
3:   dup
4:   invokespecial   #1; //Method java/lang/Object."<init>":()V
7:   pop
8:   return

调用Object的默认构造器时，可以看到调用的java.lang.Object上的<init>()V方法。
()V是该构造器对应的初始化方法的描述符，在前面引用的规范里有写，意思是接受0个参数，返回值类型是void，也就是不返回任何值。

如果您仍然不相信，那么请看看上面例子里CtorDemo的默认构造器的内容：

0:   aload_0
1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
4:   return

会返回内容的返回指令是带有类型前缀的，例如返回int类型的值的方法使用ireturn，返回引用类型的值的方法是用areturn，而无前缀的return指令则不返回任何值，对应的返回值类型为void。

正是因为实例构造器不返回值，所以new指令后才通常会跟着dup，将新创建对象的引用复制一份，这样在操作数栈顶就有两份指向刚创建的对象的引用；其中一份传给实例构造器作为隐藏参数this，另一份做后续用途，例如赋值给变量或用于调用别的方法等。

55 楼 米霍克丶 2010-09-30  

被你们搞晕了。

54 楼 chrisx 2010-09-30  

讨论这种问题没有任何意义

53 楼 qiren83 2010-09-30  

其实面试官也许只是为了考下，java中常量字符串放在哪的问题

52 楼 aria 2010-09-30  

allskylove 写道

aria 写道

zx339 写道

iq527 写道

allskylove 写道

简直是一派胡言，这样的帖子也能评为精华？无语了。。。。。， 对jvm 的了解很是无语，还长篇大论的。就下面问题抛给楼主：你知道什么事字面量吗？ 什么是常量吗？ 什么是基本数据类型？什么是对象数据类型，什么是过渡类型？

比较讨厌这种带有"挑衅"性质的回复,如果您知道, 那请您来给大家解释下吧... 

allskylove本来就是反对低调对待技术问题的人，他认为“互相攻击”才能带来实质的内容，你可以看看他大部分的回复，
都是"挑衅"性的。所以别动不动就讨厌这个人，那个人，难道批评就一定是为了显得自己NB？ 批评就不能不带目的性？

我看了他的大部分回复都没有"挑衅"性，只提这些范范的问题而又不给出自己的间接难道不是为了显得自己NB？

中国名族真是郁闷的名族，闷骚的名族，你闷骚得还有道理了，连点刺激都受不了，搞什么飞机，钓鱼岛，你继续强烈谴责吧！打他娘的！还说个毛！

不要激动呀 我是针对zx339 他发这贴时您还没贴出长篇大论呢
赠您几句话 不偏谓之中,不易谓之庸 
谣言止于智者，您要是因为想发泄而喷算我什么都没说

51 楼 aria 2010-09-30  

zx339 写道

iq527 写道

allskylove 写道

简直是一派胡言，这样的帖子也能评为精华？无语了。。。。。， 对jvm 的了解很是无语，还长篇大论的。就下面问题抛给楼主：你知道什么事字面量吗？ 什么是常量吗？ 什么是基本数据类型？什么是对象数据类型，什么是过渡类型？

比较讨厌这种带有"挑衅"性质的回复,如果您知道, 那请您来给大家解释下吧... 

allskylove本来就是反对低调对待技术问题的人，他认为“互相攻击”才能带来实质的内容，你可以看看他大部分的回复，
都是"挑衅"性的。所以别动不动就讨厌这个人，那个人，难道批评就一定是为了显得自己NB？ 批评就不能不带目的性？

我看了他的大部分回复都没有"挑衅"性，只提这些范范的问题而又不给出自己的间接难道不是为了显得自己NB？

50 楼 mercyblitz 2010-09-30  

allskylove 写道

算了，yy一下就行了，此贴没有水平！ 和这些混蛋交流真是无语了，难道讨论问题非得在平静的水面上交流，中国人的表面平静，就是内心阴险的表现！ 笨不出来什么大牛，大鸟，顶多就是个鸟蛋而已。

首先不讨论水平，你可以写出更好的？

49 楼 geminiyellow 2010-09-30  

allskylove 写道

allskylove 写道

关于 String a=new String(“abc”); 究竟产生几个String对象实例问题的讨论？
首先说明：
问此题的人，其实是草包一个，是半瓶水而已，就像问中国究竟有多少人一样？中国究竟有多少人呢？这问题本身就有问题，你是说中国现在有多少人，还是新中国成立的时候有多少人？还是全球有多少中国人?
问问题之前先要明白环境是什么？上下文是什么？那么java 也一样，你不了解java语言本身，或者jvm 本质很难回答看似简单，其实并非简单的问题。往往简单的问题，比较难回答，为什么呢？因为简单的问题没有环境约束，它没有限制出环境。任何东西脱离了周围环境，就没有它存在的价值，就好比 1+1 等于2 如何证明它一样。怎么证明呢？这个问题，你首先考虑的并不是证明不证明的问题。我们要考虑它是怎么来的？这个还真难考虑。不过怎么去证明它，首先你要知道，1+1 是否是规定就等于2，如果规定的东西，不要证明，我规定了1+1 等于二 那么证明它就显得很苍白，原因很简单规定必证明的优先权高，没有方法啊，你总不能越过规定吧，这是自然规律。首先你要这自然规律的约束下发展其自己，就像你活着地球上一样，你要看清地球本身，你光这地球上是不行的。
好废话少说，开始我们的讨论：
我定义了两个类
类一：StringDemo1
public class StringDemo1 {
public static void main(String[] args) {
String a=new String("abc");
}
}
类二：StringDemo2
public class StringDemo2 {
public static void main(String[] args) {
String b="abc";
String a=new String("abc");
}
}
这是很简单的两个类，没有什么可解释的，唯一不同是StringDemo2 比StringDemo1多加了一行代码 String b="abc"; 换句话说是加了一个上文的环境。
有人就会问我这有什么关系呢？那么请看我下面的分析，很简单，我不会像论坛上的一些人一样，故意那么研究得深刻，把一些不明白的人往火坑里推，显得自己很高深似的。
开始动手：
步骤一：
Javac 编译两个类(各位自己这命令行编译，这里就不列出了了)
步骤二：
javap -c  使用此命令，这个命令可能一般人就没有使用过，自己上网查查，都是jdk命令;此命令使用的例子：javap -c StringDemo1  javap -c StringDemo2  分别这命令行敲上面的两条命令
好，下面的是我cmd 命令行的输出(你自己的输出应该也差不多)
注：我用红色的字体来注释行：

D:\String>javac StringDemo1.java

D:\String>javac StringDemo2.java

D:\String>javap -c StringDemo1
Compiled from "StringDemo1.java"
public class StringDemo1 extends java.lang.Object{
public StringDemo1();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   new     #2; //class java/lang/String 此句new 了一个对象，产生了一个对象，毫无疑问
   3:   dup  
   4:   ldc     #3; //String abc  此句将String abc常量值从常量池中推送至栈顶 ，那这算不算对象，当然算了，只不过时创建时间可能不是现在哦 “#” 后面的为索引地址，我们可以从索引地址可以看到，这里有#2,#3,那么String a=new String("abc");
这是一句代码哦，可以看出此题目中这此句产生了两个String 对象。
   6:   invokespecial   #4; //Method java/lang/String."<init>":(Ljava/lang/Strin
g;)V
   9:   astore_1
   10:  return
}

D:\String>javap -c StringDemo2
Compiled from "StringDemo2.java"
public class StringDemo2 extends java.lang.Object{
public StringDemo2();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   ldc     #2; //String abc  此句将String abc常量值从常量池中推送至栈顶
   2:   astore_1 //存储变量，也就是赋值操作
   3:   new     #3; //class java/lang/String  此句产生一个对像
   6:   dup
   7:   ldc     #2; //String abc   这里很有意思哦，我们看到 #2 索引地址已经出现过来，对了，上面 code 0： 就出现过了 他只不过是把地址，引用要过来了，并没有产生String对象，也就是从Stirng常量池里面要了个地址，自己知道地址就知道他的家了哦，
那么这里就有一个问题呀？什么问题？那这样的话，多个Sting变量有可能引用一个Strng实例，那么会产生String共享不安全的问题，多线程的情况下。这个不要担心了，String是线程安全的，因为它是final 类型的，没有办法改变！哦，恍然大悟！原来这样，怪不得sun这样做，有利于减少内存浪费啊（此问题其实还会产生String碎片，那就扯远了和StringBuffere有关系了，暂不讨论）。那么这么说来String a=new String("abc"); 此句产生了一个String对象。
   9:   invokespecial   #4; //Method java/lang/String."<init>":(Ljava/lang/Strin
g;)V
   12:  astore_2
   13:  return
}


总结一下吧：
String a=new String("abc");这样的问题没有什么意义，脱离上下文的环境本身就没有意思了。从上面的分析，我们得出两个结论，第一个结论，也就是StringDemo1 中的请求，此句产生两个对象，其中一个特殊的String对象在String常量池里，另外一个就是对象堆中的(这个普通的Java类一样)
第二个结论，也就是StringDemo2， 那一句只产生了一个对象，只有堆中的一个对象，因为上网已经产生了一个String常量对象，后面就不产生了，直接使用地址索引了。
String 是一个特殊的数据类型，说白了它是从简单到对象类型过渡的一种类型；它既有简单类型那样的快速又有对象类型的特性。对应String的不足，那么String家族里面已经有了补充的类，完善的类，StringBuffere 各位不用担心，StringBuffere完全面向对象了，怎么证明呢？很简单
String a=“abc”； 这样可以直接复制常量值个String类型的。就好像简单类型的可以使用字面量来直接初始化 一样。例如 int a=123;
StringBuffere a=“abc”； 这样就不行啦

最后的结论，1个或者2个
补充下：jvm 指令 可以参考 http://samwong.iteye.com/blog/710737

还真的没有办法了，javaeye 这群猪，我现在引用我自己写的帖子总可以吧，靠，我这这个帖子上被扣60分，日，javaeye 就是一个流氓的地方，怎么没有审核制度，真是漏洞百出。

有举报制度。JE正在向民主靠拢，所有的事情都需要举报。

48 楼 yanfeijun 2010-09-30  

这么咬文嚼字有啥意思呢......说不定人家本来就是想问涉及到几个变量而已

47 楼 mercyblitz 2010-09-30  

其实，这个题目意义在于场景。对于一般的开发没有什么意义，如果是高性能系统的话，情况就不同了。

我举个例子，我想很多人没有过String#intern 方法。

想起Robbin的一句话，现在知识体系全面正的不多。

利用技术看场景，但是前提是你要了解本质问题是什么。回到这里，对Heap和Permanent分别的作用是什么，到底存放了什么东西。Heap又有多少内置的区域等等。可能理论上知晓，可任何理论都是要用于实处的，不是只为简单记忆和临时面试。

46 楼 东川々靖竹 2010-09-30  

声明一个String  本来还懂点  看完之后 迷糊了。。。。。

45 楼 firemanliu 2010-09-30  

当然很有意义，那个allsky说的简直就是废话，lz已经说了你想解释的，
不就是第一次去看这段string常量池中有没有被创建，有就返回一个引用。
lz的那段汇编解释的很清楚了。

44 楼 googya 2010-09-30  

allskylove 写道

哎！javaeye会员没有人性啊，怎么回事，我发表了一篇帖子，哈哈，把我的帖子弄成了隐藏贴，30分不见了，我看帖子浏览次数总共才10此呀！ 狗日的javaeye! 哈哈！一点自由都没有，培训出来的这些枪手！

兄弟点背啊，刚好10个人看了，就投了10个隐藏贴！


我觉得不是枪手的问题，而是je上人的问题！


我的帖子也多次被评为隐藏贴了，fuc！

有问题大家一起来讨论讨论嘛（不是纯粹的提问，那就不好放到提问频道上去了吧），知道的，说个方法，不想说的不看也可以，干嘛投个隐藏贴呢？javaeye就不应该设置这样的东西！

43 楼 spell 2010-09-30  

搞这个除了面试还有啥意义呢？基本上我只知道怎么用才是正确的，然后我就一直这样用，没有必要用个东西都要一个个的拆零部件似的，看电视的时候，你有必要去想里面的某个晶体管是怎么制作出来的，用的啥材料吗？

42 楼 arong 2010-09-30  

了解这些对一般程序员确实有难度，我要疯啦。。。。。。

41 楼 dolwenjian 2010-09-30  

slaser 写道

这个问题对java应用几乎没什么意义。

正解。。
不过多了解下 jvm 对我们coding有好处

40 楼 slaser 2010-09-30  

这个问题对java应用几乎没什么意义。