默认构造器在javac里是什么时候加上去的？

读到ZangXT写的默认构造方法并非总是public的，顺便一提。

碰到语言问题先看规范。Java语言规范第三版8.8.9小节如是说：

Java Language Specification, 3rd Edition 写道

8.8.9 Default Constructor

...

In an enum type (§8.9), the default constructor is implicitly private. Otherwise, if the class is declared public, then the default constructor is implicitly given the access modifier public (§6.6); if the class is declared protected, then the default constructor is implicitly given the access modifier protected (§6.6); if the class is declared private, then the default constructor is implicitly given the access modifier private (§6.6); otherwise, the default constructor has the default access implied by no access modifier.

如ZangXT同学所说，默认构造器的可访问性是与类自身的可访问性相关的，并不总是public。

看完规范看实现。在Sun的javac编译器中，com.sun.tools.javac.main.JavaCompiler类中的compile()方法里有：

delegateCompiler = processAnnotations(enterTrees(stopIfError(parseFiles(sourceFileObjects))),
                                      classnames);

delegateCompiler.compile2();

同一个类中的compile2()方法里有：

while (todo.nonEmpty())
    generate(desugar(flow(attribute(todo.next()))));

也就是说javac编译Java源码可以分为下述几步：
1、解析（parseFiles），如果有语法错误则停止（stopIfError）；
2、将类型的信息补全，检查是否存在循环依赖等问题，没有问题则将类型信息输入到符号表里（enterTrees）；
3、处理注解（processAnnotations），如果这步生成了新的类型则对新类型从第1步开始递归处理；
4、为语法树标注属性（attribute）；
5、对程序做流相关分析（flow），用于检查确定性赋值等流相关语义分析；
6、解语法糖（desugar）：将泛型类型转换为非泛型的；将for-each等语法糖转换为基本语法结构，包括Java 7新增的switch里的String支持也在这步；将内部类和嵌套类转换后当作顶层类处理；
7、生成Class文件（generate），包括元信息和字节码。

在OpenJDK的Compiler项目中也有描述javac的编译步骤的文档。
（不过OpenJDK站上不是所有文档都完全可信。在Compiler Grammar项目中的介绍：

引用

The parser that is currently in the javac compiler is a hand-written LALR parser.

就是错的。实际上现在的javac是基于LL(1)语法的递归下降式+运算符优先级解析，之前一帖已经提过了。）

在上述流程中，默认构造器是在哪一步加进来的呢？下面用一段代码为例说明：

package test.debug.javac;

public class TestDefaultConstructorVisibility {
    public class TestDefaultConstructorVisibilityPublicInnerClass {
    }

    class TestDefaultConstructorVisibilityDefaultInnerClass {
    }

    protected class TestDefaultConstructorVisibilityProtectedInnerClass {
    }

    private class TestDefaultConstructorVisibilityPrivateInnerClass {
    }
}

class TestDefaultConstructorVisibilityPackageVisibilityCase {
}

打开调试器，跟踪javac的编译过程，观察解析出来的语法树toString()之后的样子：
parseFiles后：

package test.debug.javac;

public class TestDefaultConstructorVisibility {
    
    public class TestDefaultConstructorVisibilityPublicInnerClass {
    }
    
    class TestDefaultConstructorVisibilityDefaultInnerClass {
    }
    
    protected class TestDefaultConstructorVisibilityProtectedInnerClass {
    }
    
    private class TestDefaultConstructorVisibilityPrivateInnerClass {
    }
}
class TestDefaultConstructorVisibilityPackageVisibilityCase {
}

stopIfError对语法树没有修改。

enterTrees后：

package test.debug.javac;

public class TestDefaultConstructorVisibility {
    
    public TestDefaultConstructorVisibility() {
        super();
    }
    
    public class TestDefaultConstructorVisibilityPublicInnerClass {
        
        public TestDefaultConstructorVisibilityPublicInnerClass() {
            super();
        }
    }
    
    class TestDefaultConstructorVisibilityDefaultInnerClass {
        
        TestDefaultConstructorVisibilityDefaultInnerClass() {
            super();
        }
    }
    
    protected class TestDefaultConstructorVisibilityProtectedInnerClass {
        
        protected TestDefaultConstructorVisibilityProtectedInnerClass() {
            super();
        }
    }
    
    private class TestDefaultConstructorVisibilityPrivateInnerClass {
        
        private TestDefaultConstructorVisibilityPrivateInnerClass() {
            super();
        }
    }
}
class TestDefaultConstructorVisibilityPackageVisibilityCase {
    
    TestDefaultConstructorVisibilityPackageVisibilityCase() {
        super();
    }
}

嗯，默认构造器已经加进来了。那么关注一下enterTrees里的逻辑。

在Enter.complete()里，classEnter(trees, null);后都还没加上默认构造器。是在紧随其后的循环中clazz.complete();的调用加上了默认构造器。这是"enterTree"中的第二阶段，调用了MemberEnter.complete()。
com.sun.tools.javac.comp.MemberEnter.complete()

/* ********************************************************************
* Source completer
*********************************************************************/

/** Complete entering a class.
 *  @param sym         The symbol of the class to be completed.
 */
public void complete(Symbol sym) throws CompletionFailure {
    // Suppress some (recursive) MemberEnter invocations
    // ...

    ClassSymbol c = (ClassSymbol)sym;
    ClassType ct = (ClassType)c.type;
    Env<AttrContext> env = enter.typeEnvs.get(c);
    JCClassDecl tree = (JCClassDecl)env.tree;
    boolean wasFirst = isFirst;
    isFirst = false;

    JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
    try {
        // ...

        // Add default constructor if needed.
        if ((c.flags() & INTERFACE) == 0 &&
            !TreeInfo.hasConstructors(tree.defs)) {
            List<Type> argtypes = List.nil();
            List<Type> typarams = List.nil();
            List<Type> thrown = List.nil();
            long ctorFlags = 0;
            boolean based = false;
            if (c.name.len == 0) {
                JCNewClass nc = (JCNewClass)env.next.tree;
                if (nc.constructor != null) {
                    Type superConstrType = types.memberType(c.type,
                                                            nc.constructor);
                    argtypes = superConstrType.getParameterTypes();
                    typarams = superConstrType.getTypeArguments();
                    ctorFlags = nc.constructor.flags() & VARARGS;
                    if (nc.encl != null) {
                        argtypes = argtypes.prepend(nc.encl.type);
                        based = true;
                    }
                    thrown = superConstrType.getThrownTypes();
                }
            }
            JCTree constrDef = DefaultConstructor(make.at(tree.pos), c,
                                                typarams, argtypes, thrown,
                                                ctorFlags, based);
            tree.defs = tree.defs.prepend(constrDef);
        }

        // ...
    } catch (CompletionFailure ex) {
        chk.completionError(tree.pos(), ex);
    } finally {
        log.useSource(prev);
    }

    // ...
}

其中在DefaultConstructor()方法中：

/** Generate default constructor for given class. For classes different
 *  from java.lang.Object, this is:
 *
 *    c(argtype_0 x_0, ..., argtype_n x_n) throws thrown {
 *      super(x_0, ..., x_n)
 *    }
 *
 *  or, if based == true:
 *
 *    c(argtype_0 x_0, ..., argtype_n x_n) throws thrown {
 *      x_0.super(x_1, ..., x_n)
 *    }
 *
 *  @param make     The tree factory.
 *  @param c        The class owning the default constructor.
 *  @param argtypes The parameter types of the constructor.
 *  @param thrown   The thrown exceptions of the constructor.
 *  @param based    Is first parameter a this$n?
 */
JCTree DefaultConstructor(TreeMaker make,
                        ClassSymbol c,
                        List<Type> typarams,
                        List<Type> argtypes,
                        List<Type> thrown,
                        long flags,
                        boolean based) {
    List<JCVariableDecl> params = make.Params(argtypes, syms.noSymbol);
    List<JCStatement> stats = List.nil();
    if (c.type != syms.objectType)
        stats = stats.prepend(SuperCall(make, typarams, params, based));
    if ((c.flags() & ENUM) != 0 &&
        (types.supertype(c.type).tsym == syms.enumSym ||
         target.compilerBootstrap(c))) {
        // constructors of true enums are private
        flags = (flags & ~AccessFlags) | PRIVATE | GENERATEDCONSTR;
    } else
        flags |= (c.flags() & AccessFlags) | GENERATEDCONSTR;
    if (c.name.len == 0) flags |= ANONCONSTR;
    JCTree result = make.MethodDef(
        make.Modifiers(flags),
        names.init,
        null,
        make.TypeParams(typarams),
        params,
        make.Types(thrown),
        make.Block(0, stats),
        null);
    return result;
}

正是其中的 flags |= (c.flags() & AccessFlags) | GENERATEDCONSTR; 这句实现了默认构造器的可访问性与类的可访问性挂钩。c.flags()返回的long是一组标识位，其中包含了可访问性修饰符的记录。

评论

4 楼 ZangXT 2010-02-23  

的一本书，好像叫深入cpp对象模型，则花了很多篇幅讲述了产生默认构造函数的意义.

mxswl 写道

受益了.
这篇文章讲述了在编译阶段javac何时帮你拼凑constructor.
以前看过的一本书，好像叫深入cpp对象模型，则花了很多篇幅讲述了产生默认构造函数的意义.

cpp太麻烦，啥时候生成，啥时候不生成……
java起码编译层保持个一致性

3 楼 mxswl 2010-02-23  

受益了.
这篇文章讲述了在编译阶段javac何时帮你拼凑constructor.
以前看过的一本书，好像叫深入cpp对象模型，则花了很多篇幅讲述了产生默认构造函数的意义.

2 楼 RednaxelaFX 2010-02-23  

zhxing 写道

说实话，没怎么看明白你。。可能功力不够深。。
最近也在看深入Java 虚拟机，大概意思是，Java 编译器为它编译的每一个类至少生成一个实例初始化方法（也就是构造方法），如果没有显示声明的任何构造方法的话，会默认生成一个无参数的构造方法，如果一个类没有显示调用另外一个构造方法的话，会自动生成一个超类的无参数的构造方法的调用。
在P168 页上有说明。但未说明它的访问权限。

我这里是写得很简略……文中提到的官方文档对javac编译器的编译步骤描述的详细些，可以先阅读那个作为背景。

《深入Java虚拟机》第二版的第7章确实提到了构造器而没有提到可访问性的问题。本来这就是Java语言中的定义而不是JVM的定义，在这么一本书里没做全面的描述也是可以理解的。上面我已经引用了Java语言规范中相应的规定及其链接，读读规范会有更清晰的理解的。

我这篇东西只是作为ZangXT同学的那帖的补充，将规范中的定义与编译器中实现该特性的地方指出来而已。具体有什么不明白的地方我们也可以展开来讨论一下 ^_^

1 楼 zhxing 2010-02-23  

说实话，没怎么看明白你。。可能功力不够深。。
最近也在看深入Java 虚拟机，大概意思是，Java 编译器为它编译的每一个类至少生成一个实例初始化方法（也就是构造方法），如果没有显示声明的任何构造方法的话，会默认生成一个无参数的构造方法，如果一个类没有显示调用另外一个构造方法的话，会自动生成一个超类的无参数的构造方法的调用。
在P168 页上有说明。但未说明它的访问权限。