是的，它用于防止实例化和随后重写。这最常用于单例类中。

我以为有人会提到这一点(第二点)，但是…私有构造函数有三种用法:

to prevent instantiation outside of the object, in the following cases: singleton factory method static-methods-only (utility) class constants-only class . to prevent sublcassing (extending). If you make only a private constructor, no class can extend your class, because it can't call the super() constructor. This is some kind of a synonym for final overloaded constructors - as a result of overloading methods and constructors, some may be private and some public. Especially in case when there is a non-public class that you use in your constructors, you may create a public constructor that creates an instance of that class and then passes it to a private constructor.

受到Robert C. Martin的“Clean Code”的启发，我整理了一个例子:

/**
When overloading constructors, it is best practise to only allow the use of
different constructors than the standart one by explicitly enforcing the 
useage of a static function to highlight the use of the overloaded constructor

in example:
Animal a = Animal.CreateInsectOrArachnia(2, "black", 8); //hatch a black widow
*/


class Animal
{
   private int size;
   private String color;
   private int legs;

   public Animal(int size, String color)
   {
       this.size = size;
       this.color = color;
       this.legs = 4;
   }

   //will prevent the instanciation of Animal with this constructor
   private Animal(int size, String color, int legs)
   {
       this.size = size;
       this.color = color;
       this.legs = legs;
   }


   public static Animal CreateInsectOrArachnia(int size, String color, int legs)
   {
    return new Animal (size, color, legs);
   }

}

Martins明确指出，应该阻止用户访问“标准构造函数”以外的构造函数，并应该强制使用静态初始化函数，以强调“你所做的可能没有错，但它与该类的预期使用不同”。

[他没有使用这个确切的措辞，我试图把它挤进这个定义-对不起，罗伯特:^)]

作为旁注，完全可以将类中唯一的构造函数(即标准构造函数)完全声明为private，并让静态函数返回类实例-请参阅单例模式。但是，非常不鼓励实现单例模式，除非在一些通信只在一个方向上流动的用例中，例如在编写记录器类时

是的，它可以。私有构造函数的存在是为了防止类被实例化，或者因为构造只在内部发生，例如工厂模式。更多信息请参见这里。

是的，类可以有一个私有构造函数。需要禁止从其他类访问构造函数，并在定义的类中保持它的可访问性。

为什么要只在内部创建类的对象?出于任何原因都可以这样做，但一个可能的原因是您想实现单例对象。单例是一种设计模式，它只允许创建类的一个实例，这可以通过使用私有构造函数来实现。

是的，构造函数可以是私有的。这个有不同的用法。其中一种用途是用于单例设计反模式，我建议您不要使用这种反模式。另一个更合理的用途是委托构造函数;你可以有一个构造函数它有很多不同的选项这是一个实现细节，所以你把它设为私有，但是你剩下的构造函数都委托给它。

作为委托构造函数的一个例子，下面的类允许您保存一个值和一个类型，但它只允许您为类型的子集这样做，因此需要将通用构造函数设置为私有，以确保只使用允许的类型。公共私有构造函数有助于代码重用。

public class MyClass {
     private final String value;
     private final String type;

     public MyClass(int x){
         this(Integer.toString(x), "int");
     }

     public MyClass(boolean x){
         this(Boolean.toString(x), "boolean");
     }

     public String toString(){
         return value;
     }

     public String getType(){
         return type;
     }

     private MyClass(String value, String type){
         this.value = value;
         this.type = type;
     }
}

编辑 几年后再看这个答案，我想指出，这个答案既不完整，也有点极端。单例的确是一种反模式，通常应该尽可能避免使用;然而，除了单例外，私有构造函数还有很多用途，我的回答只提到了一种。

再举几个使用私有构造函数的例子:

To create an uninstantiable class that is just a collection of related static functions (this is basically a singleton, but if it is stateless and the static functions operate strictly on the parameters rather than on class state, this is not as unreasonable an approach as my earlier self would seem to suggest, though using an interface that is dependency injected often makes it easier to maintain the API when the implementation requires larger numbers of dependencies or other forms of context). When there are multiple different ways to create the object, a private constructor may make it easier to understand the different ways of constructing it (e.g., which is more readable to you new ArrayList(5) or ArrayList.createWithCapacity(5), ArrayList.createWithContents(5), ArrayList.createWithInitialSize(5)). In other words, a private constructor allows you to provide factory function's whose names are more understandable, and then making the constructor private ensures that people use only the more self-evident names. This is also commonly used with the builder pattern. For example: MyClass myVar = MyClass .newBuilder() .setOption1(option1) .setOption2(option2) .build();