java基础---设计模式(1)

出处：https://blog.csdn.net/zhangerqing/article/details/8194653

java的设计模式分为三大类

• 创建型模式： 工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
• 结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
• 行为型模式： 策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
• 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

设计模式的原则

• 开闭原则：对扩展开放，对修改关闭，为了使系统的扩展性更好，便于维护和移植（我们需要使用接口和抽象类）
• 里氏代换原则：任何基类可以出现的地方，子类一定可以出现，多使用多态的方式
• 依赖倒转原则：尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性
• 接口隔离原则：尽量多使用小接口而不是大接口，使用多个隔离的接口，比使用单个接口要好，避免接口的污染，降低类之间耦合度。
• 迪米特原则：一个实体应当尽量少的与其他实体之间发生相互作用，体现高内聚，低耦合
• 合成复用原则：尽量多使用合成/聚合的方式，而不是继承的方式

创建型模式

创建型模式主要包括：

• 单例模式 Singleton：保证一个类只有一个实例，并提供一个访问它的全局访问点
• 抽象工厂模式 Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，无须指定他们的具体类
• 工厂方法 Factory Method：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到了子类
• 建造模式 Builder： 将一个复杂对象的构建和它的表示相分离，使得同样的构建过程可以创建不同的表示
• 原型模式 Prototype：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象

一、工厂方法模式

• 普通工厂模式：建立一个工厂类，对实现了同一接口的一些类进行实例的创建

//创建二者共同接口
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 SmsSender();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}
//测试类
public class FactoryTest {

    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produce("sms");
        sender.Send();
    }
}

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

//创建二者的共同接口：
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 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();
    }

}    

• 静态工厂：将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用

　　　　　

//前面的接口类和实体类不变，将工厂类的实现方法转为静态的，便于直接调用
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();
    }
}

总结：当大量的产品需要创建且他们具有共同的接口时，可以通过工厂模式进行创建，普通工厂模式需要匹配字符，多工厂方式需要实例化工厂，一般选用静态工厂模式

二、抽象工厂模式

创建多个工厂类，一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码

//公共接口
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 SendMailFactory implements Provider {

    @Override
    public Sender produce(){
        return new MailSender();
    }
}
public class SendSmsFactory implements Provider{

    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

//工厂接口
public interface Provider {
    public Sender produce();
}

//测试类：
public class Test {

    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.Send();
    }
}

总结：便于拓展，只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，无需去改动现成的代码

三、单例模式

　　单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。对于创建频繁的对象可以减小开销，省去了new操作符，降低了系统内存的使用频率，减轻了垃圾回收器的压力，隐藏了核心功能。

//简单单例模式
public class Singleton {

    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
    private static Singleton instance = null;

    /* 私有构造方法，防止被实例化 */
    private Singleton() {
    }

    /* 静态工程方法，创建实例 */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
        return instance;
    }
}

　　但是这种简单单例模式不适用于多线程环境

public class Singleton {

    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */
    private static Singleton instance = null;

    /* 私有构造方法，防止被实例化 */
    private Singleton() {
    }

    /* 静态工程方法，创建实例 */
    //不是锁住整个方法，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (instance) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
        return instance;
    }
}

　　但是在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的，JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例

1. A、B线程同时进入了第一个if判断

2. A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();

3. 由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。

4. B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

5. 此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了

　　　而单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。

public class Singleton {

    /* 私有构造方法，防止被实例化 */
    private Singleton() {
    }

    /* 此处使用一个内部类来维护单例 */
    private static class SingletonFactory {
        private static Singleton instance = new Singleton();
    }

    /* 获取实例 */
    public static Singleton getInstance() {
        return SingletonFactory.instance;
    }

    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
        return getInstance();
    }
}

或者

public class SingletonTest {

    private static SingletonTest instance = null;

    private SingletonTest() {
    }

    private static synchronized void syncInit() {
        if (instance == null) {
            instance = new SingletonTest();
        }
    }

    public static SingletonTest getInstance() {
        if (instance == null) {
            syncInit();
        }
        return instance;
    }
}

四、建造模式

　　将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的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);
    }
}

五、原型模式

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

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;
}

　　要实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象