【设计模式】创建型

1，单例模式

（1）饿汉式单例模式：

还没使用便先初始化，不存在线程安全问题；

package _设计模式._创建型._单例模式._饿汉;

public class HungrySingleton {
    private final static HungrySingleton LAZY_SINGLETON;
    static {
        LAZY_SINGLETON = new HungrySingleton();
    }

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return LAZY_SINGLETON;
    }


}

（2）懒汉式单例模式：

使用才进行初始化，存在线程安全问题：

在《Effect Java》一书中，更加推荐的是枚举式实现，依靠内部枚举单例性直接实现单例模式；

package _设计模式._创建型._单例模式._懒汉;

import java.io.Serializable;
import java.lang.reflect.Constructor;

public class LazySingleton implements Serializable {
    private volatile static LazySingleton instance = null;

    private LazySingleton() {
        if (Lazy_load.LAZY_SINGLETON != null) {
            throw new RuntimeException("破坏模式");//防止反射破坏单例模式
        }
    }

    //synchronized
    public static LazySingleton getInstance() {

        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();//volatile防止new 对象重排序
                }
            }
        }

        return instance;
    }

    //采用静态内部类线程安全
    public static final LazySingleton getInstance2() {
        return Lazy_load.LAZY_SINGLETON;
    }

    private static class Lazy_load {
        private static final LazySingleton LAZY_SINGLETON = new LazySingleton();
    }

    //防止反序列化破坏单例
    private Object readResolve() {
        return instance;
    }

}

//更加优雅的写法
enum Singleton {
    INSTANCE;

    private Object data;

    public void setData(Object data) {
        this.data = data;
    }

    public Object getData() {
        return data;
    }

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

2，原型模式

package _设计模式._创建型._原型模式;

import java.io.*;
import java.util.ArrayList;
import java.util.List;


@SuppressWarnings("all")
public class ProtoTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        ConcreteProtoTypeA a = new ConcreteProtoTypeA("123");
        //浅克隆
        ConcreteProtoTypeA clone = (ConcreteProtoTypeA) a.clone();
        //深克隆
        ConcreteProtoTypeA deepClone = (ConcreteProtoTypeA) a.deepClone();
        a.add(1);
        a.add(2);
        a.add(3);
        a.showList();
        clone.showList();
        deepClone.showList();
    }

    //抽象原型
    interface ProtoType {
        T clone();
    }

    static class ConcreteProtoTypeB implements ProtoType {
        private String desc;
        private List list;

        public ConcreteProtoTypeB(String desc) {
            this.desc = desc;
            list = new ArrayList<>();
        }

        public void add(int a) {
            list.add(a);
        }

        public void showList() {
            System.out.print(this.getClass().getSimpleName() + ":");
            for (Integer integer : list) {
                System.out.print(integer + " ");
            }
        }

        @Override
        public ConcreteProtoTypeB clone() {
            //这种通过new的方式介入了初始化过程，可以实现Cloneable直接复制class文件，除去加载过程
            return new ConcreteProtoTypeB(this.desc);
        }
    }

    //这里属性是复制引用，即浅克隆
    static class ConcreteProtoTypeA implements Cloneable, Serializable {
        private String desc;
        private List list;

        public ConcreteProtoTypeA(String desc) {
            this.desc = desc;
            list = new ArrayList<>();
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {
            ConcreteProtoTypeA concreteProtoTypeA = null;
            try {
                concreteProtoTypeA = (ConcreteProtoTypeA) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return concreteProtoTypeA;
        }

        //巧用序列化实现深克隆
        protected Object deepClone() {
            try {
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bos);
                oos.writeObject(this);
                ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bis);

                return ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

        public void add(int a) {
            list.add(a);
        }

        public void showList() {
            System.out.print(this.getClass().getSimpleName() + ":");
            for (Integer integer : list) {
                System.out.print(integer + " ");
            }
            System.out.println();
        }

        @Override
        public String toString() {
            return "ConcreteProtoTypeA{" +
                    "desc='" + desc + ''' +
                    '}';
        }
    }

}

3，构造者模式

当构造函数参数过多时，使用构造者模式，让参数意义更加明确；

package _设计模式._创建型._建造者;



public class BuildTest {
    //客户端
    public static void main(String[] args) {
        A.Builder builder = new A.Builder();
        A instance = builder.setA(1).setB(2).setC(3).build();
        System.out.println(instance);
    }
}

class A{
    private int a;
    private int b;
    private int c;
    A(){}

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }

    public static class Builder{
        A instance;

        public Builder() {
            instance = new A();
        }

        public A build(){
            return instance;
        }

        public Builder setA(int a){
            this.instance.a = a;
            return this;
        }

        public Builder setB(int b){
            this.instance.b = b;
            return this;
        }

        public Builder setC(int c){
            this.instance.c = c;
            return this;
        }
    }

    @Override
    public String toString() {
        return "A{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                '}';
    }
}

4，抽象工厂模式

package _设计模式._创建型._抽象工厂;





public class Client{
    public static void main(String[] args) {
        JavaCourseFactory javaCourseFactory = new JavaCourseFactory();
        IVideo iVideo = javaCourseFactory.createIVideo();
        INote note = javaCourseFactory.createNote();
        iVideo.record();
        note.edit();
    }
}

interface IVideo{
    void record();
}

interface INote{
    void edit();
}
interface CourseFactory {
    IVideo createIVideo();
    INote createNote();
}




class JavaIVideo implements IVideo{

    @Override
    public void record() {
        System.out.println("录制JAVA视频");
    }
}


class JavaINote implements INote{

    @Override
    public void edit() {
        System.out.println("编写java笔记");
    }
}



class JavaCourseFactory implements CourseFactory{

    @Override
    public IVideo createIVideo() {
        return new JavaIVideo();
    }

    @Override
    public INote createNote() {
        return new JavaINote();
    }
}

5，方法工厂模式

package _设计模式._创建型._方法工厂;


public class Client {
    public static void main(String[] args) {
        AFactory aFactory = new AFactory();
        BFactory bFactory = new BFactory();
        Product product = aFactory.createProduct();
        Product product1 = bFactory.createProduct();
        product.doSomeThing();
        product1.doSomeThing();
    }
}

//工厂规范
interface Factory {
    Product createProduct();
}

//产品规范
interface Product {
    void doSomeThing();
}

//A产品
class AProduct implements Product {

    @Override
    public void doSomeThing() {
        System.out.println("I am A");
    }
}

//A产品
class BProduct implements Product {

    @Override
    public void doSomeThing() {
        System.out.println("I am B");
    }
}

//A工厂
class AFactory implements Factory {

    @Override
    public Product createProduct() {
        return new AProduct();
    }
}

//B工厂
class BFactory implements Factory {

    @Override
    public Product createProduct() {
        return new BProduct();
    }
}

6，简单工厂模式

package _设计模式._创建型._简单工厂;


public class Client{
    public static void main(String[] args) {
        ICourse python = CourseFactory.Creat(PythonCourse.class);
        ICourse java = CourseFactory.Creat(JavaCourse.class);
        python.record();
        java.record();
    }
}
interface ICourse {
    void record();//不变的部分
}

class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("JAVA");
    }
}

class EmptyCourse implements ICourse{

    @Override
    public void record() {
        System.out.println("");
    }
}

class PythonCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("PYTHON");
    }
}

class CourseFactory {
    public static ICourse Creat(Class clazz){
        try{
            if (clazz != null){
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return new EmptyCourse();
    }

}