常用的设计模式详解。

目录

工厂模式（创建型）

适配器模式（行为模式）

观察者模式（行为模式）

单例模式

---

工厂模式（创建型）

1、简单工厂模式：

        又称静态工厂方法，根据参数的不同返回不同类的实例。简单工厂模式就是专门定义一个类来负责创建其他类的实例。比如说Java中工具类DateFormat,根据传入参数的不同，可以返回不同时间格式的类

2、工厂模式（接口）

        简单工厂模式的那个工厂是需要知道所有类的实现细节的。每当有新产品要加入的时候就要去修改工厂类，在工厂模式中，这个实例化的细节放到了子工厂类中去做，这个工厂变成了接口工厂，原来简单工厂模式中，添加一个新类的时候，需要在工厂类中添加新类的实例化逻辑，而现在只需要新增一个工厂类即可。扩展优于修改。

        在JDK中，最常见的就是集合类Collection,它里面有一个iterator接口方法，Colletcion的实现类中的ArrayList实现iterator方法是创建一个Itr()对象，而实现类LinkedList中的iterator是创建一个ListItr对象。这里面的Collection就是工厂，ArrayList和LinkedList实现iterator接口方法的过程就是实例化对象，这个过程交给了ArrayList和LinkedList这两个类。

3、抽象工厂模式

        上面的简单工厂和工厂模式都是工厂和实例有关系的，而抽象工厂模式就是打破了工厂与产品（大类）一对一的关系。一个工厂类可以生成多个大类的产品。此时的工厂变成了北京工厂，广东工厂。

 

适配器模式（行为模式）

        适配器就是一个桥梁，使两个不兼容的类或者对象兼容到一起工作

        定义：将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够一起工作。

        和装饰者模式的区别：目的不一样，适配器只是因为原有接口不兼容，然后适配器提供一个转换的作用，不会改变原有的接口；而装饰者就是为了对原有接口进行功能扩展，需要修改原来的接口

JDK  JUC中。FutureTask的参数是一个Runnable的时候，底层会RunnableAdapter适配器会把Runnable封装为Callable

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

Executor.callable方法：

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

观察者模式（行为模式）

        定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆可得到通知并被自动更新。

java.util包中提供了Observable类和Observer接口，其中要求，被观察者需要继承Observable类，观察则需要实现Observer接口

手写观察者模式

package ao.com;

import java.util.Observable;

public class HuaweiP30 extends Observable {
    private double money;

    public HuaweiP30(double money){
        this.money = money;
    }
    public  void setMoney(double money){
        if (money != this.money){
            setChanged();//价格改变
        }
        if (money < this.money){
            this.notifyObservers(money);//通知观察者并把改变后的钱带过去
        }
    }
    @Override
    public String toString() {
        return "HuaweiP30{" +
                "money=" + money +
                '}';
    }
}

定义华为粉丝为观察者，并实现Observer接口，并重写update（Observable o, Object arg）方法。

package ao.com;

import java.util.Observable;
import java.util.Observer;

public class Fensi implements Observer {
    private String name;
    public Fensi(String name){
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof HuaweiP30){
            System.out.println("粉丝名为" + name + "发现华为p30降价了，新的价格为：" + arg +"元，开始购买。");
        }
    }
}

public static void main(String[] args) {
        HuaweiP30 huaweiP30 = new HuaweiP30(5000);
        Fensi a = new Fensi("张奥");
        Fensi b = new Fensi("小明");
        huaweiP30.addObserver(a);
        huaweiP30.addObserver(b);
        huaweiP30.setMoney(4000);
    }

 Spring AOP用到的代理模式。

单例模式

        一个类只有一个实例，并且自行实例化并向整个系统提供这个实例。

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