第五章：面向对象基础——构造方法私有化。

本章目标

• 了解后遭方法私有化的目的
• 掌握单态设计模式（单例设计模式）

1、具体内容

构造方法私有化

类的封装不光体下载对属性的封装上，实际上方法也是可以封装的，当然在方法封装中也包含了对构造方法的封装。例如：以下的代码，就是对构造方法进行了封装

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 SingletonDemo02{
    public static void main(String args[]){
        Singleton s1 = null ;   // 声明对象
        s1 = new Singleton() ;  // 错误，无法实例化对象
    }
};

此时，被私有化构造方法的Singleton类，不能在外部直接实例化，既然在外部不可以使用，那么如果在内部呢？

class Singleton{
    Singleton instance = new Singleton() ;  // 在内部产生本类的实例化对象
    private Singleton(){        // 将构造方法进行了封装，私有化   
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo03{
    public static void main(String args[]){
        Singleton s1 = null ;   // 声明对象
    }
};

一个类的构造方法被私有化之后，则只能从其类的内部取得实例化对象，那么此时要考虑的问题就是如何把内部生成的instance对象拿到外部来，这样外部就可以直接通过此对象进行实例化。

正常情况下，instance属性只能通过Singleton类的实例化对象才可以调用，如果在没有实例化对象的时候依然可以取得instance对象，则就需要将instance声明成static访问类型。因为使用static声明的变量，可以直接使用类名称进行访问。

class Singleton{
    static Singleton instance = new Singleton() ;   // 在内部产生本类的实例化对象
    private Singleton(){        // 将构造方法进行了封装，私有化   
    }
    public void print(){
        System.out.println("Hello World!!!") ;
    }
};
public class SingletonDemo04{
    public static void main(String args[]){
        Singleton s1 = null ;   // 声明对象
        s1 = Singleton.instance ;   // 取得实例化对象
        s1.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 SingletonDemo05{
    public static void main(String args[]){
        Singleton s1 = null ;   // 声明对象
        s1 = Singleton.getInstance() ;  // 取得实例化对象
        s1.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 SingletonDemo05{
    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() ;        // 调用方法
    }
};

运行结果：
Hello World!!!
Hello World!!!
Hello World!!!

不管外部声明了多少个Singleton的对象，但是最终结果都是通过getInstance()方法取得的实例化对象，也就是说，此时s1、s2、s3都是用了一个对象的引用：instance

那么这样的设计在设计模式上来讲，属于 单态设计模式（ 单例设计模式）： Singleton。
如果现在不希望一个类产生过多的对象的话，则就必须时用单态设计模式，而且单态设计模式在一户的Java学习中会经常碰到，因为在Java的支持类库中，大量的采用了此种设计模式。
所谓的单态就是在入口处（构造方法）限制了对象的实例化操作。

这就是单态设计的应用点。

2、总结

单态设计模式的核心及时将类的构造方法私有化，之后在类的内部产生实例化对象，并通过类的静态方法返回实例化对象的引用。