Java学习笔记之构造方法私有化

1、构造方法私有化

类的封装性，不仅体现在对属性的封装，而且可以对方法进行封装，这里的方法当然包括构造方法

class SingleTon{
    private SingleTon(){}  // 构造方法私有化
    public void print(){
        System.out.println("hello world!");
    }
}

public class SingleTonDemo {
    public static void main(String[] args) {
        SingleTon s = null;		// 声明对象
        s = new SingleTon();	// 错误，不能实例化对象
    }
}

SingleTon类的构造方法被私有化，不能在外部进行实例化，只能在内部实例化

class SingleTon{
    SingleTon instance = new SingleTon();  // 在内部产生本类是实例化对象
    private SingleTon(){}  // 构造方法私有化
    public void print(){
        System.out.println("hello world!");
    }
}


public class SingleTonDemo {
    public static void main(String[] args) {
        SingleTon s = null;

    }
}

一个类的构造方法被私有化之后，则只能从其内部获取实例化对象，可以将其声明为static类型，就直接可以用类名去调用。

class SingleTon{
    static SingleTon instance = new SingleTon();  // 在内部产生本类是实例化对象
    private SingleTon(){}  // 构造方法私有化
    public void print(){
        System.out.println("hello world!");
    }
}


public class SingleTonDemo {
    public static void main(String[] args) {
        SingleTon s = null;
        s = SingleTon.instance;	// 获取实例化对象
        s.print();
    }
}

// 运行结果
hello world!

正常情况下，我们还是应该对属性进行封装

class SingleTon{
    private static SingleTon instance = new SingleTon();  // 在内部产生本类是实例化对象
    public static SingleTon getInstance(){ // 通过静态方法获取instance对象
        return instance;
    }
    private SingleTon(){}  // 构造方法私有化
    public void print(){
        System.out.println("hello world!");
    }
}


public class SingleTonDemo {
    public static void main(String[] args) {
        SingleTon s = null;
        s = SingleTon.getInstance();
        s.print();
    }
}

看到这里，我们会有这样的疑问，这个看起来比较麻烦啊，为啥还要这样写呢？为什么不直接实例化对象？
咱们带着这些疑惑再来看这个问题，假如我们产生了三个对象

class SingleTon{
    private static SingleTon instance = new SingleTon();  // 在内部产生本类是实例化对象
    public static SingleTon getInstance(){ // 通过静态方法获取instance对象
        return instance;
    }
    private SingleTon(){}  // 构造方法私有化
    public void print(){
        System.out.println("hello world!");
    }
}


public class SingleTonDemo {
    public static void main(String[] args) {
        SingleTon s1 = null;
        SingleTon s2 = null;
        SingleTon s3 = null;
        s1 = SingleTon.getInstance();
        s2 = SingleTon.getInstance();
        s3 = SingleTon.getInstance();
        s1.print();
        s2.print();
        s3.print();
    }
}

不管外部声明了多少个SingleTon对象，最终结果都是通过getInstance()方法获取到实例化对象，换言之，s1,s2,s3都使用了一个实例化对象的引用：instance

这种方式称为单态（单例）设计模式：SingleTon
如果不希望一个类产生过多的对象，那么就可以考虑这种设计模式。

2、单例设计模式的意义

2.1 实例控制

单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

2.2 灵活性

因为类控制了实例化过程，所以类可以灵活更改实例化过程。

以windows操作系统的回收站程序为例，每个硬盘都有一个回收站，桌面也有一个，但是实际上每个硬盘的回收站和桌面的是同一个，也就是说整个操作系统其实就只有一个回收站实例，其他地方的都是这个实例的引用而已。