Two declared constructors in inner class

Question

I have a public class with a private class inside it:

public class A {

   private class B
   {
   }

   private final B b = new B();

   public static void main(String[] args) {
       Class<?> bClass = A.class.getDeclaredClasses()[0];
       Constructor<?>[] declaredConstructors = bClass.getDeclaredConstructors();
       System.out.println(declaredConstructors.length);  //result = 2
   }
}

The problem is, that the declared constructors in class B equals two.

Although in other cases, the number of constructors in class B equals one:

public class A {

   private class B
   {
       public B()
       {
       }
   }

   private final B b = new B();

   public static void main(String[] args) {
       Class<?> bClass = A.class.getDeclaredClasses()[0];
       Constructor<?>[] declaredConstructors = bClass.getDeclaredConstructors();
       System.out.println(declaredConstructors.length);  //result = 1
   }
}

and

public class A {

   private class B
   {
   }

   public static void main(String[] args) {
       Class<?> bClass = A.class.getDeclaredClasses()[0];
       Constructor<?>[] declaredConstructors = bClass.getDeclaredConstructors();
       System.out.println(declaredConstructors.length);  //result = 1
   }
}

The question is why in the first case 2 constructors? Thanks!

Why not have a look at what those constructors are rather than worrying simply about how many there are. — Andy Turner, Mar 05 '18 at 07:13
@AndyTurner While you're certainly right, the concept of a synthetic constructor isn't obvious from reading the javap. — chrylis -cautiouslyoptimistic-, Mar 05 '18 at 07:15
@Henry, I expect one constructor, and I get two. Why are there two сonstructors, if the сonstructor is there alone. — Дмитрий Мельников, Mar 05 '18 at 07:16
@AndyTurner I wrote this for an example, to make sure that there is one constructor. — Дмитрий Мельников, Mar 05 '18 at 07:18
Right. But the *number* is unimportant, because there are the number of constructors there are. Look at the parameters to get insight into *why* the compiler created them. For example, you may be seeing a manifestation of this: https://stackoverflow.com/q/47589638/3788176 — Andy Turner, Mar 05 '18 at 07:30
Is it unimportant though? Because as far as I knew synthethic methods can theoretically expose data you expected to be private. — Ben, Mar 05 '18 at 07:33

Ben · Accepted Answer · 2018-03-05T07:40:42.690

As already shortly mentioned by chrylis what you are seeing here is a synthetic constructor.

Basically, whenever you access private attributes of a nested class from the nesting class the compiler needs to create a synthetic method for this access.

In your first example the default constructor is private so when you call it a synthetic method is created (thus "2" constructors exist).

In your second example the constructor is declared as public and no such issue exists.

In your third example once again it is private but also never accessed so there is no need to create a synthetic method.

If you are interested in more detail, read into Chapter 13.1.7 of the Java Language Specification (https://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html) where it is explained a bit further.

Also if you are interested in the implications of synthetic method this post might be interesting to you, discussing the implications of them in regards to security (and performance): What's the penalty for Synthetic methods?

Also, if you want to read more into the inner workings of this concept, I can recommend the following article: https://www.javaworld.com/article/2073578/java-s-synthetic-methods.html (which (to my knowledge) should still be up to date)

Two declared constructors in inner class

1 Answers1