设计模式之————创建型设计模式

创建型设计模式

//工厂模式
//1.简单工厂模式
public class FoodFactory {
 
    public static Food makeFood(String name) {
        if (name.equals("noodle")) {
            Food noodle = new LanZhouNoodle();
            noodle.addSpicy("more");
            return noodle;
        } else if (name.equals("chicken")) {
            Food chicken = new HuangMenChicken();
            chicken.addCondiment("potato");
            return chicken;
        } else {
            return null;
        }
    }
}
//总结：简单地说，简单工厂模式通常就是这样，一个工厂类 XxxFactory，里面有一个静态方法，
//根据我们不同的参数，返回不同的派生自同一个父类（或实现同一接口）的实例对象。


//2.工厂模式
public interface FoodFactory {
    Food makeFood(String name);
}
public class ChineseFoodFactory implements FoodFactory {
 
    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new ChineseFoodA();
        } else if (name.equals("B")) {
            return new ChineseFoodB();
        } else {
            return null;
        }
    }
}
public class AmericanFoodFactory implements FoodFactory {
 
    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new AmericanFoodA();
        } else if (name.equals("B")) {
            return new AmericanFoodB();
        } else {
            return null;
        }
    }
}
//客户端调用
public class APP {
    public static void main(String[] args) {
        // 先选择一个具体的工厂
        FoodFactory factory = new ChineseFoodFactory();
        // 由第一步的工厂产生具体的对象，不同的工厂造出不一样的对象
        Food food = factory.makeFood("A");
    }
}

//3.抽象工厂模式
// 得到 Intel 的 CPU
CPUFactory cpuFactory = new IntelCPUFactory();
CPU cpu = intelCPUFactory.makeCPU();
 
// 得到 AMD 的主板
MainBoardFactory mainBoardFactory = new AmdMainBoardFactory();
MainBoard mainBoard = mainBoardFactory.make();
 
// 组装 CPU 和主板
Computer computer = new Computer(cpu, mainBoard);


// 抽象为产品族
public static void main(String[] args) {
    // 第一步就要选定一个“大厂”
    ComputerFactory cf = new AmdFactory();
    // 从这个大厂造 CPU
    CPU cpu = cf.makeCPU();
    // 从这个大厂造主板
    MainBoard board = cf.makeMainBoard();
      // 从这个大厂造硬盘
      HardDisk hardDisk = cf.makeHardDisk();
 
    // 将同一个厂子出来的 CPU、主板、硬盘组装在一起
    Computer result = new Computer(cpu, board, hardDisk);
}



//单例模式 （https://blog.csdn.net/qq_27093465/article/details/50978916）

//1.饿汉式
public class Singleton {
    // 首先，将 new Singleton() 堵死
    private Singleton() {};
    // 创建私有静态实例，意味着这个类第一次使用的时候就会进行创建
    private static Singleton instance = new Singleton();
 
    public static Singleton getInstance() {
        return instance;
    }
    // 瞎写一个静态方法。这里想说的是，如果我们只是要调用 Singleton.getDate(...)，
    // 本来是不想要生成 Singleton 实例的，不过没办法，已经生成了
    public static Date getDate(String mode) {return new Date();}
}
//优点：1.线程安全  2.在类加载的同时已经创建好一个静态对象，调用时反应速度快
//缺点：资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化


//2.懒汉式（饱汉式）
public class Singleton {
    // 首先，也是先堵死 new Singleton() 这条路
    private Singleton() {}
    // 和饿汉模式相比，这边不需要先实例化出来，注意这里的 volatile，它是必须的
    private static volatile Singleton instance = null;
    /**
     * 加上volatile，禁止指令重排，造成的bug。
     * singletonInstance = new SingletonPattern3();
     * 看似一句话，但分三个步骤。
     * 1，memory = allocate(); //1：分配对象的内存空间
     * 2，ctorInstance(memory); //2：初始化对象
     * 3，instance = memory; //3：设置instance指向刚分配的内存地址
     * 但是经过重排序后如下：
     * 1，memory = allocate(); //1：分配对象的内存空间
     * 2，instance = memory; //3：设置instance指向刚分配的内存地址，此时对象还没被初始化，此时，instance已经不为null啦。
     * 3，ctorInstance(memory); //2：初始化对象
     * 在线程A初始化完成这段内存之前，线程B虽然进不去同步代码块，
     * 但是在同步代码块之前的判断就会发现instance不为空，但是在第一个IF判断就不为空了。
     * 此时线程B获得instance对象进行使用就可能发生错误。
     *
     * 

    /*
    在JVM中的及时编译存在指令重排序的优化，也就是说不能保证1,2,3执行的顺序，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是 1-3-2，则在 3 执行完毕、2 未执行之前，被线程二抢占了，
    这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
    通过添加volatile就可以解决这种报错，因为volatile可以保证1、2、3的执行顺序，没执行玩1、2就肯定不会执行3，也就是没有执行完1、2instance一直为空

    */
 
    public static Singleton getInstance() {
        //这个地方可能有多个线程，在这排队，ABCD...
        if (instance == null) {
            // 加锁
            //若多个线程判断instance都为null时，在执行new操作时多线程会出现重复情况
            //简单的操作给方法添加[synchronized],使之成为同步函数。但是就每个线程访问都得判断锁，效率就是问题。所以，才有后面的[双重锁形式]
            synchronized (Singleton.class) {
                // 这一次判断也是必须的，不然会有并发问题


                if (instance == null) {
                    //假设第一次A线程走到这，然后，呈挂起状态。这个时候，单例对象还未创建；
                    // 假设此时，B线程也来了判断单例对象==null成立，但是，因为A线程已经给里层的if判断上锁，所以，B只能在外等着。
                    //假设A线程被唤醒，那么，单例就会下面语句赋值，单例对象就创建啦。然后释放锁。B就可以进来啦。
                    //B线程进来之后，先判断单例对象是否为null，发现已经不是null啦，那么就不需要创建啦。
                    //CD线程同样，
                    //再往后面来的，第一个if就进不来啦，那就不会判断锁了。
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

//懒汉式的嵌套类（静态内部类）
public class Singleton3 {
 
    private Singleton3() {}
    //静态内部类只会被加载一次，线程安全
    // 主要是使用了 嵌套类可以访问外部类的静态属性和静态方法 的特性
    private static class Holder {
        private static Singleton3 instance = new Singleton3();
    }
    public static Singleton3 getInstance() {
        return Holder.instance;
    }
}

//枚举类的单例模式
public enum SingleTonDemo4 {
    INSTANCE; //虽然只有一行
}
public class TestEnum {
    
    //测试枚举单例
    public static void main(String[] args) {
        SingleTonDemo4 instance1 = SingleTonDemo4.INSTANCE;
        SingleTonDemo4 instance2 = SingleTonDemo4.INSTANCE;
        SingleTonDemo4 instance3 = SingleTonDemo4.INSTANCE;
        
        System.out.println(instance1 == instance3);
    }
    
}



//建造者模式


//1.简单例子（套路就是先 new 一个 Builder，然后可以链式地调用一堆方法，最后再调用一次 build() 方法，我们需要的对象就有了。）
Food food = new FoodBuilder().a().b().c().build();
Food food = Food.builder().a().b().c().build();

//2.完整例子（可以使用Lombok注解，@Builder简化书写）
class User {
    // 下面是“一堆”的属性
    private String name;
    private String password;
    private String nickName;
    private int age;
 
    // 构造方法私有化，不然客户端就会直接调用构造方法了
    private User(String name, String password, String nickName, int age) {
        this.name = name;
        this.password = password;
        this.nickName = nickName;
        this.age = age;
    }
    // 静态方法，用于生成一个 Builder，这个不一定要有，不过写这个方法是一个很好的习惯，
    // 有些代码要求别人写 new User.UserBuilder().a()...build() 看上去就没那么好
    public static UserBuilder builder() {
        return new UserBuilder();
    }
 
    public static class UserBuilder {
        // 下面是和 User 一模一样的一堆属性
        private String  name;
        private String password;
        private String nickName;
        private int age;
 
        private UserBuilder() {
        }
 
        // 链式调用设置各个属性值，返回 this，即 UserBuilder
        public UserBuilder name(String name) {
            this.name = name;
            return this;
        }
 
        public UserBuilder password(String password) {
            this.password = password;
            return this;
        }
 
        public UserBuilder nickName(String nickName) {
            this.nickName = nickName;
            return this;
        }
 
        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }
 
        // build() 方法负责将 UserBuilder 中设置好的属性“复制”到 User 中。
        // 当然，可以在 “复制” 之前做点检验
        public User build() {
            if (name == null || password == null) {
                throw new RuntimeException("用户名和密码必填");
            }
            if (age <= 0 || age >= 150) {
                throw new RuntimeException("年龄不合法");
            }
            // 还可以做赋予”默认值“的功能
              if (nickName == null) {
                nickName = name;
            }
            return new User(name, password, nickName, age);
        }
    }
}
//客户端的调用
public class APP {
    public static void main(String[] args) {
        User d = User.builder()
                .name("foo")
                .password("pAss12345")
                .age(25)
                .build();
    }
}



//原型模式
/*
Object 类中有一个 clone() 方法，它用于生成一个新的对象，当然，如果我们要调用这个方法，
java 要求我们的类必须先实现 Cloneable 接口，此接口没有定义任何方法，但是不这么做的话，
在 clone() 的时候，会抛出 CloneNotSupportedException 异常。
*/
/*
 java 的克隆是浅克隆，碰到对象引用的时候，克隆出来的对象和原对象中的引用将指向同一个对象。
 通常实现深克隆的方法是将对象进行序列化，然后再进行反序列化。
*/


//创建型模式总结
/*
创建型模式总体上比较简单，它们的作用就是为了产生实例对象，算是各种工作的第一步了，因为我们写的是面向对象的代码，所以我们第一步当然是需要创建一个对象了。

简单工厂模式最简单；工厂模式在简单工厂模式的基础上增加了选择工厂的维度，需要第一步选择合适的工厂；
抽象工厂模式有产品族的概念，如果各个产品是存在兼容性问题的，就要用抽象工厂模式。单例模式就不说了，为了保证全局使用的是同一对象，一方面是安全性考虑，一方面是为了节省资源；
建造者模式专门对付属性很多的那种类，为了让代码更优美；
原型模式用得最少，了解和 Object 类中的 clone() 方法相关的知识即可。

*/