（Java）构造方法私有化

不只是可以对属性进行封装，对方法其实也是可以封装的，这其中就包括了对构造方法的封装

class Singleton{
	private Singleton{
	// 此处对构造方法进行封装
	}
	public void print(){
	// 打印信息
		System.out.println("Hello World !!!")
	}
}

我们已知一个类要想使用，就必须有实例化对象的产生，但是此时类的构造方法被私有化了，所以常规的实例化就不可再使用。

class Singleton{
    private Singleton(){
        // 此处将构造方法进行封装
    }
    public void print(){
        System.out.println("Hello World !!!");
    }
}
public class Test{
    public static void main(String[] args) {
        {
            Singleton s1 = null; // 可以声明对象
            s1 = new Singleton; // 错误，无法实例化
            s1.print();
        }
    }
}
10
11
12
13
14
15
16
17

既然封装是指一切都对外部不可见，那么则可以在其内部进行调用

class Singleton{
    Singleton instance = new Singleton();//内部产生本类的实例化对象
    private Singleton(){
        // 此处将构造方法进行封装
    }
    public void print(){
        System.out.println("Hello World !!!");
    }
}

此时又需要考虑外部如何通过 instance 来实例化 Singleton 的对象。

学习 static 时，我们已知 static 类型的属性可以由类名称直接调用，所以此时可以将 instance 声明为 static 类型，然后通过类名称直接调用

class Singleton{
    static Singleton instance = new Singleton();//内部产生本类的实例化对象
    private Singleton(){
        // 此处将构造方法进行封装
    }
    public void print(){
        System.out.println("Hello World !!!");
    }
}
public class Test{
    public static void main(String[] args) {
        {
            Singleton s1 = null; // 可以声明对象
            s1 = Singleton.instance; // 访问类中的静态属性
            s1.print();
        }
    }
}
10
11
12
13
14
15
16
17
18

由于类中的属性必须进行封装，所以此处对 instance 也应进行封装，而封装之后必须通过方法取得，由于instance属性为静态属性，所以此处需要声明一个静态方法，这样才可以被类名称直接调用

class Singleton{
    static Singleton instance = new Singleton();//内部产生本类的实例化对象
    private Singleton(){
        // 此处将构造方法进行封装
    }
    public static Singleton getInstance(){
        return instance; // 通过静态方法取得 Singleton 类的实例
    }
    public void print(){
        System.out.println("Hello World !!!");
    }
}
public class Test{
    public static void main(String[] args) {
        {
            Singleton s1 = Singleton.getInstance();
            Singleton s2 = Singleton.getInstance();
            Singleton s3 = Singleton.getInstance();

            s1.print();
            s2.print();
            s3.print();
        }
    }
}
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这里虽然声明了3个 Singleton 对象，但是实际上所有的对象都只使用 instance 引用，也就是无论外面怎么使用，最终只有一个实例化对象存在。

这称为单例设计模式，也就是无论程序如何进行，Singleton 永远只有一个实例化对象

只要将构造方法私有化，就可以控制实例化对象的产生