【设计模式】学习笔记（二）——创建型设计模式

步骤如下：
1）构造器私有化（防止 new）
2）类的内部创建对象
3）向外暴露一个静态的公共方法。getInstance

class Singleton{
    //1.构造器私有化，外部不能new
    private Singleton(){

    }

    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3.提供一个公有的静态方法，放回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）在静态代码块中，创建单例对象
4）提供一个公有的静态方法，放回实例对象

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    static {// 在静态代码块中，创建单例对象
        instance = new Singleton();
    }

    public static Singleton getInstance(){
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）提供一个静态的公有方法，当使用到该方法时，才去创建 instance

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
    //即懒汉式
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）

class Singleton{

    private static Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）提供一个静态的公有方法，在代码块中加入同步处理的代码（synchronized）

class Singleton{
    private static Singleton singleton;

    private Singleton(){

    }

    //提供一个静态的公有方法，在代码块中加入同步处理的代码（synchronized）
    //即懒汉式
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized(Singleton.class){
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象并用volatile（用来确保将变量的更新操作通知到其他线程）关键字修饰
3）提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题

class Singleton{
    private static volatile Singleton instance;

    private Singleton(){

    }

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
    public static synchronized Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){//当第一个线程执行完对象实例化操作后
               if(instance == null) {//后面的线程来到这里时判断
                   instance = new Singleton();
               }
               //else 到下面返回 instance
            }
        }
        //而当再后面的线程来时在最上方的判断语句中就直接来到这里返回instance
        return instance;
    }
}

实现步骤
1）构造器私有化（防止 new）
2）类的内部声名静态对象
3）写一个静态内部类，该类中有一个静态属性外部类的静态常量
4）提供一个静态的公有方法，直接返回静态内部类常量属性

class Singleton{
    private static Singleton instance;

    private Singleton(){

    }

    //写一个静态内部类，该类中有一个静态属性 Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance(){

        return SingletonInstance.INSTANCE;
    }
}

//使用枚举，可以实现单例，推荐
enum Singleton{
    INSTANCE;//属性
    public void sayOK(){
        System.out.println("ok~");
    }
}

实现步骤：

// 1.需要克隆的类实现 Cloneable 接口
// 2.重新Clone方法
public class Realizetype implements Cloneable{

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    //测试一下
    public static void main(String[] arge) throws CloneNotSupportedException {
        Realizetype realizetyp = new Realizetype();
        Realizetype clone = (Realizetype) realizetyp.clone();
    }
}

实现深克隆的方法有很多种，这里我们使用的是序列化+反序列化来实现深克隆

import java.io.*;

public class Realizetype implements Cloneable{

    public static void main(String[] arge) throws Exception {
        //创建原型对象
        Student student = new Student();
        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:/xxx.txt"));
        //写对象
        oos.writeObject(student);
        //释放资源
        oos.close();


        //创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:/xxx.txt"));
        //读取对象
        Student student1 = (Student) ois.readObject();
        //释放资源
        oos.close();

    }
}

//实现序列号接口
class Student implements Serializable {

}

/**
 * 汉堡类
 */
public class Hamburger {
    // 配料部件，这里使用字符串作为部件，真正使用是传入对象作为部件
    private String meat;//肉
    private String dosing;//配料

    public Hamburger(String meat, String dosing) {
        this.meat = meat;
        this.dosing = dosing;
    }

    public Hamburger() {

    }

    public String getMeat() {
        return meat;
    }

    public void setMeat(String meat) {
        this.meat = meat;
    }

    public String getDosing() {
        return dosing;
    }

    public void setDosing(String dosing) {
        this.dosing = dosing;
    }

    @Override
    public String toString() {
        return "Hamburger{" +
                "meat='" + meat + '\'' +
                ", dosing='" + dosing + '\'' +
                '}';
    }

    public static class Beefburger {
    }
}

/**
 * 抽象创建者
 */
public abstract class Builder {
    // 将hamburger对象创建在抽象创建者中，实现类就可以对这个类进行创建部件
    Hamburger hamburger = new Hamburger();
    abstract void setmeat();
    abstract void setdosing();
    abstract Hamburger createHamburger();
}

/**
 * 牛肉堡创造者类
 */
public class Beefburger extends Builder{
    @Override
    void setbeef() {
        hamburger.setMeat("牛肉");
    }

    @Override
    void setdosing() {
        hamburger.setDosing("烧烤酱");
    }

    @Override
    Hamburger createHamburger() {
        return hamburger;
    }
}

/**
 * 鸡腿堡创造者类
 */
public class Chickenburger extends Builder{

    @Override
    void setbeef() {
        hamburger.setMeat("鸡肉");
    }

    @Override
    void setdosing() {
        hamburger.setDosing("沙拉酱");
    }

    @Override
    Hamburger createHamburger() {
        return hamburger;
    }
}

/**
 * 指挥者类
 */
public class Director {
    private Builder builder;

    // 初始化创建者
    public Director(Builder builder){
        this.builder = builder;
    }

    // 构建方法，装配部件
    public Hamburger construct(){
        builder.setbeef();
        builder.setdosing();
        Hamburger hamburger = builder.createHamburger();
        return hamburger;
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        // 鸡腿堡创建
        Chickenburger chickenburger = new Chickenburger();
        Director director = new Director(chickenburger);
        Hamburger hamburger = director.construct();

        // 牛肉堡创建
        Beefburger beefburger = new Beefburger();
        Director director1 = new Director(beefburger);
        Hamburger hamburger1 = director1.construct();

        System.out.println(hamburger);
        System.out.println(hamburger1);
    }
}

/*测试结果
Hamburger{meat='鸡肉', dosing='沙拉酱'}
Hamburger{meat='牛肉', dosing='烧烤酱'}*/

可以看出，指挥者类对于产品的创建有着至关重要的作用，Builder只是提供了部件的创建，而真正决定怎么创建的，需要由指挥者类(Director)来决定