Java 私有构造函数的应用

在Java中，构造函数的访问级别通常是public, 它提供了一个构造该类对象的接口。可是你知不知道，把构造函数的级别设为private, 有一些特别用处。

先来看一段代码：
//Shape.java
public class Shape {
private Shape() {
/* set something here */
}

public static Shape makeShape(/* arglist */) {
System.out.println("here is the shape you ordered");
return (new Shape());
}

public static void main(String args[]) {
Shape.makeShape();
}
}
首先从语言角度分析，我们可以知道， 任何类的使用者都无法使用构造函数来生成一个图形, 因为构造函数是私有的，无法被类以外的函数使用。而只能通过调用makeShape来实现。

也许你会问，为什么不直接使用构造函数来生成图形，而需要使用一个看上去多余的makeShape方法呢？

这样做有以下几个好处：

1。你可以返回任何的Shape类型，包括Shape的子类。比如你可以把makeShape写成这样：

public static Shape makeShape(/* arglist */) {
System.out.println("here is the shape you ordered");
if (retangle)
return (new Retangle(/* arglist*/));
if (Circle)
return (new Circle(/* arglist */));
/* you can return as many shapes as you like */
}

这里假设Retangle 和 Circle 都是shape的子类，并且和Shape类在同一个包內，Shape类可以访问子类的构造函数。这样shape就提供了一个图形工厂。 用户通过一个接口就可以生成不同的图形。事实上，这种用法被称为“工厂模式”。

2。可以实现一个类只有一个对象。请看下面的代码

//Handler.java
public class Handler {

private Handler handler = null;
private Handler() {
/* set something here */
}

public static getHandler(/* arglist */) {
if (!handler)
handler = new Handler();
return handler;
}

public static void main(String args[]) {
Handler.getHandler();
}
}

当handlerw为空时，那么重新构造一个handler，然后返回；如果已经构造过了，那么就直接返回已经存在的handler。这种用法被称为“Singleton pattern". 如果直接使用构造函数来构造对象，那么你就无法控制生成的数量。在实际应用中，往往会做一些改变。比如使用一个具有一定容量的池，当需要构造一个对象而池的容量仍未满时，就构造一个新的对象，并放入池中，并把对象的状态设为“占用”状态；当需要构造一个对象而池的容量已满，则从池中选一个“空闲”状态的对象返回，并把对象的状态设为“占用”。当对象使用完后再回收到池中并把状态设为“空闲“。

这种模式的一个典型应用场景是：

在一个具有很多用户的web站点里，需要一个对象来单独处理一个连接，而每一个连接的时间比较短。如果每次连接都创建一个对象然后又很快销毁，那么创建和销毁对象的系统开销是很大的。这种时候可以使用对象池，这样就免去了创建和销毁对象的开销。

3。可以方便的拋出异常。请看下列代码：

public class Test {
public Test() {
double x = 1.0/0.0;
}
public static void main(String args[]) {
try {
Test test = new Test();
}catch (Exception e){
System.out.println(e.toString());
}
}
}

编译，执行，你会发现这个异常不会被捕捉，没有任何输出；即使尝试在构造函数中捕捉异常也不行。看下列代码：

public class Test {
public Test() {
try {
System.out.println("trying to throw an exception");
double x = 1.0/0.0;
} catch(Exception e) {
System.out.println("Exception captured");
}finally {
System.out.println("inside finally");
}
}
public static void main(String args[]) {
Test test = new Test();
}
}
编译，运行，结果为：
trying to throw an exception
inside finally

原因是JVM把构造函数产生的异常丢弃了。试想你正在使用一个第三方的类库提供的类，那个类提供一个共有的构造函数，它允许你通过参数构造一个类的对象，可是如果你的参数不合法，导致在构造函数中产生一个异常，那么你永远不知道具体发生了什么。当然如可以在每次构造对象时进行参数合法性检查，可是假设你要构造好多这样的对象？？那将是一场灾难。这时可以通过把构造函数的访问级别设为私有，强迫类的使用者使用一个工厂函数来生成需要的对象，那么就可以在这个函数中统一的进行参数检查了。具体的代码就不写了，留给读者去实践吧！

从上面的分析我们可以知道私有构造函数的威力。需要注意的一点是，即使你的构造函数什么都不做，比如：
private Shape() {}
你仍然要显示的定义，因为如果你不定义，那么Java会自动为你生成一个空构造函数，而这个空构造函数是共有的。