`
sunmiracle
  • 浏览: 14689 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

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会自动为你生成一个空构造函数,而这个空构造函数是共有的。
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics