java设计模式（单例设计模式）

单例设计模式：所谓的单例设计模式指的是一个类只允许产生一个实例化对象。
简单例子程序：

class Text {
    public void print() {
        System.out.println("Hello World");
    }
}

public class TextDemo1 {
    public static void main(String[] args) {
        Text text = new Text();//产生实例化对象
        text.print();
    }
}

以上程序在进行对象实例化的时候调用了Text的无参构造。
使用private声明构造方法：

class Text {
    private Text(){//private声明构造方法
        
    }
    public void print() {
        System.out.println("Hello World");
    }
}

此时类中明确提供了一个私有的构造方法，那么默认生成的无参构造方法将不再产生，此时进行对象实例化会出错。
一旦构造方法被私有化，表示外部无法调用构造，即外部不能产生新的实例化对象，此时的类是一个相对而言的封闭状态。
如果想调用Text类的print()方法，那么必须提供实例化对象，考虑到封装的特点，可以在类的内部产生一个实例化对象。

class Text {
    //在类的内部访问私有结构，必须在类的内部产生实例化对象
    Text text = new Text();
    private Text(){//private声明构造方法

    }
    public void print() {
        System.out.println("Hello World");
    }
}

现在Text内部的text对象（属性）是一个普通属性，所有的普通属性必须在有实例化对象的时候才能进行内存空间的分配，而现在外部无法产生实例化对象，所以必须想个个办法，可以在Text没有实例化对象产生的时候，也可以将text进行使用。此时，使用static关键字。
使用static产生实例化对象：

class Text {
    //在类的内部访问私有结构，必须在类的内部产生实例化对象
    static Text text = new Text();

    private Text() {//private声明构造方法

    }

    public void print() {
        System.out.println("Hello World");
    }
}

public class TextDemo1 {
    public static void main(String[] args) {
        Text text = Text.text;//产生实例化对象
        text.print();
    }
}

对于类中属性应该使用private进行封装，要想取得private属性，应该提供getter()方法。由于此时访问的是static属性，并且这个类无法在外部提供实例化对象，因此应该提供一个static的getter()方法，因为static方法也不受对象实例化控制。

class Text {
    //在类的内部访问私有结构，必须在类的内部产生实例化对象
    private static Text text = new Text();

    private Text() {//private声明构造方法
    }

    public static Text getText() {
        return text;
    }

    public void print() {
        System.out.println("Hello World");
    }
}

public class TextDemo1 {
    public static void main(String[] args) {
        Text text = Text.getText();//产生实例化对象
        text.print();
    }
}

以上程序为了类中中产生一个实例化对象。

单例设计模式有用两种形式：
1，懒汉式
2，饿汉式
上面的程序就是饿汉式单例模式的应用：
不管你是否使用Text类的对象，只要该类加载了，那么一定会自动创建好一个公共的text对象。既然是饿汉式，就希望整体的操作之中只能够有一个实例化对象，所以一般还会在前面追加一个final关键字

class Text {
    //在类的内部访问私有结构，必须在类的内部产生实例化对象
    private final static Text text = new Text();

    private Text() {//private声明构造方法
    }

    public static Text getText() {
        return text;
    }

    public void print() {
        System.out.println("Hello World");
    }
}

public class TextDemo1 {
    public static void main(String[] args) {
        Text text = Text.getText();//产生实例化对象
        text.print();
    }
}

特点：特点：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象。

懒汉式单例模式：

class Text1 {
    private static Text1 text;

    private Text1() { // private声明构造
    }

    public static Text1 getText1() {
        if (text == null) { // 表示此时还没有实例化
            text = new Text1();
        }
        return text;
    }

    public void print() {
        System.out.println("Hello World");
    }
}

public class TexrDemo2 {
    public static void main(String[] args) {
        Text1 text = Text1.getText1();//声明对象
        text.print();
    }

}

特点：当第一次去使用Text1对象的时候才会为其产生实例化对象的操作。

懒汉式存在多线程安全问题，而饿汉式不会。