build设者总是要公开吗？

我的第一个问题是 – 

class Explain() { public Explain() { } }

应该构造函数总是宣布为公共？

如果我创build一个private构造函数呢？

我总是看到build设者是隐含public 。 那么为什么private构造函数是有用的？ 或者根本没有用处 因为没有人能够调用它，或者从来没有一个对象（因为private构造函数）！ 这是我的第二个问题。

不， 构造函数可以是public ， private ， protected或default （根本不需要访问修饰符）。

private并不意味着没有人可以访问它。 这仅仅意味着课堂以外的任何人都不能访问它。 所以private构造函数也是有用的。

private构造函数的一个用途是服务单例类。 单例类是将创build对象的数量限制为一个。 使用private构造函数，我们可以确保一次只能创build一个以上的对象。

示例 – 

 public class Database { private static Database singleObject; private int record; private String name; private Database(String n) { name = n; record = 0; } public static synchronized Database getInstance(String n) { if (singleObject == null) { singleObject = new Database(n); } return singleObject; } public void doSomething() { System.out.println("Hello StackOverflow."); } public String getName() { return name; } }

有关 访问修饰符的 更多信息 。

是的，构造函数可以有任何访问说明符/访问修饰符。

私有构造函数对创buildsingleton类非常有用。

Singleton – Singleton类是一个只能在运行时（每个JVM）创build一个对象的类。

一个简单的单例类的例子是 – 

 class Ex { private static Ex instance; int a; private Ex() { a = 10; } public static Ex getInstance() { if(instance == null) { instance = new Ex(); } return instance; } }

请注意，对于上面的类，获取对象（在此类之外）的唯一方法是调用getInstance（）函数，该函数只会创build一个实例并继续返回。

另外请注意，这不是线程安全的。

构造函数可以是公共的，默认的或私有的，这一切都取决于你想要做什么。

例如，如果你正在定义一个Singleton类，你最好隐藏 （意味着它是私有的，只有它所属的类可用）构造函数，以防止其他类按照自己的意愿实例化你的类。

您可能希望将其声明为默认值（假设为testing目的），以便同一个包中的testing用例可以访问它。

更详细的信息可以在这里find

没有规定构造函数是公开的。通常我们定义它是公开的，因为我们也想从其他类实例化它。

私人构造意味着，“我不让任何人创build我的实例，除了我”。 所以通常你会这样做，当你喜欢有一个单身模式。

以下是使用私有构造函数的JDK中的类。 

 public class Runtime { private static Runtime currentRuntime = new Runtime(); public static Runtime getRuntime() { return currentRuntime; } // Don't let anyone else instantiate this class private Runtime() { } }

不，构造函数可以使用任何访问修饰符，包括私有的。 （私有构造器意味着只有类中的代码才能实例化该types的对象，所以如果私有构造器类想要允许使用该类的实例，则该类必须提供一个静态方法或variables，以允许访问从类中创build的实例。）

例 

 class Alpha { static String s = " "; protected Alpha() { s += "alpha "; } } class SubAlpha extends Alpha { private SubAlpha() { s += "sub "; } } public class SubSubAlpha extends Alpha { private SubSubAlpha() { s += "subsub "; } public static void main(String[] args) { new SubSubAlpha(); System.out.println(s); } }

以上程序的输出将是

alpha subsub

构造函数可以有各种访问修饰符。 在构造函数上使用不同的访问修饰符是不同的。

如果您希望从任何地方实例化类，则可以构造一个public构造函数。

如果您希望inheritance类并实例化其inheritance的类，则可以构造一个protected的构造函数。

如果你希望这个类只是从它自己的成员（通常是一个静态块或者静态方法）中实例化出来，你就可以构造一个private构造器。 这意味着你需要控制实例化类，并在实例化上应用一些规则。 私有构造函数的使用示例是单例devise模式。

我同意以前的答案，Singleton是一个有私有构造函数的类的好例子。 我会尽pipe推荐一个不同的实现：一个线程安全Singleton： 

 /** * Thread safe singleton */ public class Singleton { private static volatile Singleton instance = null; /** * Private constructor */ private Singleton() { } /** * Gets the Instance of the Singleton in a thread safe way. * @return */ public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }

以一种线程安全的方式使用一个单例可以为您在并行代码中解决很多痛苦。

构造函数必须至less受保护，甚至在创build自定义工厂类时才是私有的，例如： 

 public final class MyFactory { private MyFactory(){} // this one prevents instances of your factory } public static void doSomething(){} // access that with MyFactory.doSomething

请注意，这只是一个示例，显示构造函数何时不应该公开。

这些答案中的大部分都涉及单例或工厂类。 另外一个私人构造函数出现在（例如） java.lang.Math类中 ，其中一切都是静态的，没有人应该调用构造函数（包括类本身）。 通过使用私有构造函数，可以防止类外的任何人调用构造函数。 （这不会阻止类内部的某个人调用构造函数，但是他们违背了他们自己的规则。）

其他人已经注意到，构造函数可能有访问修饰符; 尚未提及的一个方面是构造函数上的aspect修饰符控制了构造的两个非常不同的方面，但是不允许它们被单独控制：

  1. 谁可以创buildClassName 实例 ，以及允许使用哪些构造函数。
  2. 谁可以创buildClassName 扩展名以及允许使用哪些构造函数。

Java和.NET都要求将这两个问题的答案放在一起; 如果一个类不是final （或者是sealed ）并且允许外部代码使用构造函数来创build新的实例，那么外部代码也将完全自由地使用相同的构造函数来创build派生types。

在许多情况下，对于一个类来说，只有package-private（ internal ）构造函数可能是合适的，但是公开了返回新实例的公共方法。 如果一个人从头开始devise一个类似String的types，就可以使用这种方法。 一个包含String的包可以将它定义为一个抽象types，但是包含AsciiString和UCS16String等具体派生types，它们的内容分别存储为byte[]和Char[] ; 返回String方法可以根据string是否包含ASCII范围外的字符返回其中一个派生types。 如果String和任何派生types都没有在其包中暴露任何构造函数，并且包内的所有派生types都像一个string一样行为，那么接收到一个Stringtypes的引用的代码可以期望它的行为理解为一个string例如保证任何关于其价值的观察将永远保持真实）。 然而，在包之外暴露构造函数会使得派生types以怪异和怪异的方式行事（例如，在它们经过检查和validation之后更改它们的内容）。

从句法的angular度来看，可以说Fnord foo = new Fnord(123); 比不得不说Fnord foo = Fnord.Create(123); ，但是需要后者语法的类Fnord可以更好地控制对象创build过程。

简单的解释是，如果类中没有构造函数，编译器会自动创build一个默认的构造函数。

构造函数并不总是声明为public，它也可以是private，protected或default。

私人构造函数阻止一个类由其调用者完全清楚地表示/表示。 在这种情况下，私有构造函数是有用的。 如果我们不需要我们的类被分类，我们可以使用私有构造函数。

Interesting Posts