java（设计模式）

前言

设计模式-1
设计模式-2

5种创建型模式

工厂方法模式

要构建的对象，实现相同的接口

• 普通工厂方法。只有一个工厂方法，根据传进来的参数的不同构建不同的对象
• 多个方法工厂方法，方法没有参数，不同的方法构建不同的对象
• 静态工厂方法，方法变为静态方法

抽象工厂模式

跟工厂方法模式相比，将工厂本身也抽象化了，有一个工厂接口provider，工厂都实现这个接口

单例模式（singleton）

JVM中只存在一个该类的对象，且只实例化一次，使用内部类来实现

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 EagerSingleton {
    //饿汉单例模式
    //在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快
    
    private static EagerSingleton instance = new EagerSingleton();//静态私有成员，已初始化
    
    private EagerSingleton() 
    {
        //私有构造函数
    }
    
    public static EagerSingleton getInstance()    //静态，不用同步（类加载时已初始化，不会有多线程的问题）
    {
        return instance;
    }
    
}

• 懒汉模式

public class LazySingleton {
    //懒汉式单例模式
    //比较懒，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢
    
    
    private static LazySingleton intance = null;//静态私用成员，没有初始化
    
    private LazySingleton()
    {
        //私有构造函数
    }
    
    public static synchronized LazySingleton getInstance()    //静态，同步，公开访问点
    {
        if(intance == null)
        {
            intance = new LazySingleton();
        }
        return intance;
    }
}

构建者模式

原型模式（prototype）

以一个原对象为模板，返回原对象的复制（深拷贝和浅拷贝）

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

7种结构性模式

image.png

适配器模式

• 类的适配器模式
  adapter继承一个类，实现一个接口

  
  image.png

• 对象的适配器模式
  wrapper持有一个类的对象，实现一个接口，在重写接口的方法的时候，调用持有对象的方法

  
  image.png

• 接口的适配器模式
  有时候需要使用一个接口的部分方法，但是实现接口需要实现其全部方法，因此可以先用一个抽象类实现接口的所有方法，然后继承抽象类，并重写需要使用的方法（java8后接口有允许有默认方法和静态方法，解决了这一问题）

装饰器模式

代理模式

外观模式

此三者目前分不太清，感觉都是代理模式

桥接模式

典型的例子是JDBC的实现，java提供统一的数据库接口，具体的实现由数据库厂商完成，厂商提供数据库驱动包

组合模式

典型的例子是树状结构

享元模式

典型的例子是连接池

11种行为型模式

image.png

观察者模式

其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系

访问者模式