设计模式一（创建型模式）

问题解决+经验复用
设计模式原则：对扩展开放，对修改关闭，使用继承、抽象类、接口、低耦合

创建型模式:单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

• 1.单例

  确保一个类只有一个实例，并提供该实例的全局访问。

public class Singleton {
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

//双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
uniqueInstance = new Singleton(); 
1,分配内存空间
2,初始化对象
3,将 uniqueInstance 指向分配的内存地址
//由于 JVM 具有指令重排的特性，有可能执行顺序变为了 1>3>2.使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

• 2.工厂模式--类的创建依赖工厂类

• 2.1简单工厂方法

  在创建一个对象时不向客户暴露内部细节，并提供一个实现的通用接口。

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

public class SendFactory {
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmSender();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produce("mail");
        sender.send();
    }
}

在main方法中通过指定参数调用工厂方法生成与参数对应的对象

• 2.2多个工厂方法

  在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象

public class SendFactory {
    public Sender produceMail(){
        return new MailSender();
    }
    public Sender produceSms(){
        return new SmsSender();
    }
}    

public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
        sender.Send();
    }
}

• 2.3静态工厂方法--方便

  不需要创建实例，直接调用即可

public class SendFactory {
    
    public static Sender produceMail(){
        return new MailSender();
    }
    
    public static Sender produceSms(){
        return new SmsSender();
    }
}

public class FactoryTest {
    public static void main(String[] args) {    
        Sender sender = SendFactory.produceMail();
        sender.Send();
    }
}

• 2.4抽象工厂

  避免对工厂类的直接修改,抽象工厂增加新的功能只需增加一个新的工厂类,而不需要修改原来的代码

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

程序只有一个发送的功能，SmsSender、MailSender两个端为功能的实现；现在需要再加一个新建对象的功能

public interface Provider {
    public Sender produce();
}
public class SendMailFactory implements Provider  implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
    @Override
    public Sender produce(){
        return new MailSender();
    }
}
public class SendSmsFactory implements Provider  implements Sender{
 
    @Override
    public Sender produce() {
        return new SmsSender();
    }
        @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

• 3.建造者模式

  建造者模式就是前面抽象工厂模式和最后的Test结合起来，将很多功能集成到一个类里，这个类可以创造出比较复杂的东西

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

public class Builder {
    private List<Sender> list = new ArrayList<Sender>();
    public void produceMailSender(int count){
        for(int i=0; i<count; i++){
            list.add(new MailSender());
        }
    }
    public void produceSmsSender(int count){
        for(int i=0; i<count; i++){
            list.add(new SmsSender());
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.produceMailSender(10);
    }
}

• 4.原型模式

  将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象

public class Prototype implements Cloneable {
    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }
}

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

public class Prototype implements Cloneable, Serializable {
    private static final long serialVersionUID = 1L;
    private String string;
    private SerializableObject obj;
    /* 浅复制 */
    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }
    /* 深复制 */
    public Object deepClone() throws IOException, ClassNotFoundException {
        /* 写入当前对象的二进制流 */
        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();
    }
    public String getString() {
        return string;
    }
    public void setString(String string) {
        this.string = string;
    }
    public SerializableObject getObj() {
        return obj;
    }
    public void setObj(SerializableObject obj) {
        this.obj = obj;
    }
}
class SerializableObject implements Serializable {
    private static final long serialVersionUID = 1L;
}