设计模式-优快云博客

本文链接：https://blog.youkuaiyun.com/xinnian25/article/details/66969066

MVP模式：

View不直接与Model交互，而是通过与Presenter交互来与Model间接交互
Presenter与View的交互是通过接口来进行的，更有利于添加单元测试
通常View与Presenter是一对一的，但复杂的View可能绑定多个Presenter来处理逻辑

MVC模式：

View可以与Model直接交互
Controller是基于行为的，并且可以被多个View共享
可以负责决定显示哪个View

http://blog.youkuaiyun.com/l664675249/article/details/50542524

1. Singleton（单例模式）
保证在Java应用程序中，一个类Class只有一个实例存在，减少了内存开销。
public class Singleton {

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

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

    /* 懒汉式：第一次调用时初始Singleton，以后就不用再生成了
    静态方法，创建实例 */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
使用synchronized关键字可以同步方法和同步代码块，给getInstance方法加个锁

2. Factory（工厂模式）
普通工厂
interface animal {
    void move();
}

public class Cat implements Animal{

    @Override
    public void move() {
        // TODO Auto-generated method stub
        System.out.println("我是只肥猫，不爱动");
    }
    public void eatFish() {  
        System.out.println("爱吃鱼");
    } 
}
public class Dog implements Animal{

    @Override
    public void move() {
        // TODO Auto-generated method stub
        System.out.println("我是狗，跑的快");
    }
    public void eatBone() {  
        System.out.println("爱吃骨头");
    } 
}
public class Factory {
    //静态工厂方法
    //多处调用，不需要实例工厂类 
     public static Cat produceCat() {  
            return new Cat();  
        } 
     public static Dog produceDog() {  
            return new Dog();  
        }
//当然也可以一个方法，通过传入参数，switch实现
}
使用
Animal cat = Factory.produceCat();
cat.move();
//-----------------------------
Dog dog = Factory.produceDog();
dog.move();
dog.eatBone();

抽象工厂
interface Provider {
    Animal produce(); 
}
每个产品都有自己的工厂 
public class CatFactory implements Provider{

    @Override
    public Animal produce() {
        // TODO Auto-generated method stub
        return new Cat();
    }
}
public class DogFactory implements Provider{

    @Override
    public Animal produce() {
        // TODO Auto-generated method stub
        return new Dog();
    }
}
Provider provider = new CatFactory();
Animal cat =provider.produce();
cat.move();

3. Adapter（适配器模式）
将一个类的接口转换成客户希望的另外一个接口。经常碰到要将两个没有关系的类组合在一起使用
模式中的角色
需要适配的类（Adaptee）：需要适配的类。
适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成目标接口。
目标接口（Target）：客户所期待的接口。可以是具体的或抽象的类，也可以是接口。
// 需要适配的类 
class Adaptee {  
    public void specificRequest() {  
        System.out.println("需要适配的类");  
    }  
}  
// 目标接口  
interface Target {  
    public void request();  
} 
①、对象适配器（采用对象组合方式实现）
// 适配器类实现标准接口，如果Target不是接口而是一个具体的类的情况，这里的Adapter直接继承Target就可以了。
class Adapter implements Target{
    // 直接关联被适配类
    private Adaptee adaptee;

    // 可以通过构造函数传入具体需要适配的被适配类对象
    public Adapter (Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        // 这里是使用委托的方式完成特殊功能
        this.adaptee.specificRequest();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 需要先创建一个被适配类的对象作为参数
        Target adapter = new Adapter(new Adaptee());
        adapter.request();
    }
}
②、类的适配器模式（采用继承实现）
// 适配器类继承了被适配类同时实现标准接口  
class Adapter extends Adaptee implements Target{  
    public void request() {  
        super.specificRequest();  
    }  
}  

// 测试类
    public static void main(String[] args) {              
        // 使用适配类  
        Target adapter = new Adapter();  
        adapter.request();  
    } 

如果不是必要，不要使用适配器，而是直接对系统进行重构。

4. Chain of Responsibility（责任链模式）
if(a<10){
    ...
}
else if (a<20）{
    ...
}
else if(a<30){
    ...
}
else{
    ...
}
程序必须依次扫描每个分支进行判断，找到对应的分支进行处理。

5. Observer（观察者模式）
定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
//抽象观察者
public interface Observer
{
  public void update(String str);

}
//具体观察者
public class ConcreteObserver implements Observer{
    @Override
    public void update(String str) {
        // TODO Auto-generated method stub
        System.out.println(str);
    }
}
//抽象主题
public interface Subject
{
    public void addObserver(Observer observer);
    public void removeObserver(Observer observer);
    public void notifyObservers(String str);
}
//具体主题
public class ConcreteSubject implements Subject{
    // 存放观察者
    private List<Observer> list = new ArrayList<Observer>();
    @Override
    public void addObserver(Observer observer) {
        // TODO Auto-generated method stub
        list.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        // TODO Auto-generated method stub
        list.remove(observer);
    }

    @Override
    public void notifyObservers(String str) {
        // TODO Auto-generated method stub
        for(Observer observer:list){
            observer.update(str);
        }
    }
}
下面是测试类：
public class Test {
     public static void main(String[] args) {
        //一个主题
         ConcreteSubject eatSubject = new ConcreteSubject();
         //两个观察者
         ConcreteObserver personOne = new ConcreteObserver();
         ConcreteObserver personTwo = new ConcreteObserver();
         //观察者订阅主题
         eatSubject.addObserver(personOne);
         eatSubject.addObserver(personTwo);

         //通知开饭了
         eatSubject.notifyObservers("开饭啦");
    }
}

6. Builder（建造者模式）
将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心
Product和产品的部分Part接口：
public interface Product { }
public interface Part { }
Builder：
public interface Builder { 
　　　　void buildPartOne(); 
　　　　void buildPartTwo(); 
　　
　　　　Product getProduct(); 
} 
ConcreteBuilder:
//具体建造工具
　　public class ConcreteBuilder implements Builder { 
　　　　Part partOne, partTwo; 

　　　　public void buildPartOne() {
　　　　　　//具体构建代码
　　　　}; 
　　　　public void buildPartTwo() { 
　　　　　　//具体构建代码
　　　　}; 
　　　　 public Product getProduct() { 
　　　　　　//返回最后组装的产品
　　　　}; 
　　}
Director :
　public class Director {
　　　　private Builder builder; 
　　
　　　　public Director( Builder builder ) { 
　　　　　　this.builder = builder; 
　　　　} 
　　　　public void construct() { 
　　　　　　builder.buildPartOne();
　　　　　　builder.buildPartTwo();
　　　　} 
　　} 
建造：
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director(builder); 
//开始各部分建造　
director.construct(); 
Product product = builder.getResult();

7. Memento（备忘录模式）
备忘录模式又叫做快照模式(Snapshot Pattern)或Token模式，是对象的行为模式。
备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。
备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并外部化，存储起来，
从而可以在将来合适的时候把这个对象还原到存储起来的状态。
备忘录模式常常与命令模式和迭代子模式一同使用。
备忘录模式所涉及的角色有三个：Originator(发起人)、Memento(备忘录)、Caretaker(管理者)

8. Prototype（原型模式）
原型模式，能快速克隆出一个与已经存在对象类似的另外一个我们想要的新对象。
工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
分为深拷贝和浅拷贝。深拷贝就是把对象里面的引用的对象也要拷贝一份新的对象，并将这个新的引用对象作为拷贝的对象引用（多读两遍）。
一般使用原型模式有个明显的特点，就是实现cloneable的clone()方法。

9. Strategy（策略模式）
定义：有一系列的算法，将每个算法封装起来（每个算法可以封装到不同的类中），各个算法之间可以替换，策略模式让算法独立于使用它的客户而独立变化。
举例：一个影碟机，你往里面插什么碟子，就能放出什么电影。
　　属性动画，设置不同的插值器对象，就可以得到不同的变化曲线。
　　返回值解析，传入什么样的解析器，就可以把二进制数据转换成什么格式的数据，比如String、Json、XML。
策略模式其实就是多态的一个淋漓精致的体现。

10. Template（模板模式）
定义：定义一个操作中的算法框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定的步骤。
　　实现流程已经确定，实现细节由子类完成。
　　生命周期对于我们都不陌生，它就是典型的Template模式，在具体流程确定的情况下，
    至于我们要复写生命周期那些方法，实现那些功能由继承activity的子类去具体实现。

11. Proxy（代理模式）
　　定义：为其他对象提供一种代理以控制对这个对象的访问。
　　代理： 在出发点到目的地之间有一道中间层。

12. Interpreter（解释器模式）
　　定义语言的文法，并且建立一个解释器来解释该语言中的句子。

13. State（状态模式）
　　行为是由状态来决定的，不同状态下有不同行为。
　　注意：状态模式的行为是平行的、不可替换的，策略模式的行为是彼此独立可相互替换的。
　　体现：不同的状态执行不同的行为，当WIFI开启时，自动扫描周围的接入点，然后以列表的形式展示；当wifi关闭时则清空。

14. Command（命令模式）
　　我们有很多命令，把它们放在一个下拉菜单中，用户通过先选择菜单再选择具体命令，这就是Command模式

15. Iterator（迭代模式）
　　提供一种方法顺序访问一个容器对象中的各个元素，而不需要暴露该对象的内部表示

16. Composite（组合模式）　　
　　将对象以树形结构组织起来，以达成“部分－整体” 的层次结构，使得客户端对单个对象和组合对象的使用具有一致性。
　　Android中View的结构是树形结构，每个ViewGroup包含一系列的View，而ViewGroup本身又是View。这是Android中非常典型的组合模式。

17. Flyweight（共享模式/享元模式）　
　　定义：避免大量拥有相同内容的小类的开销(如耗费内存)，使大家共享一个类(元类)

18. 参考文章
http://blog.youkuaiyun.com/amazing7/article/details/51719404 源码中的设计模式  
http://blog.youkuaiyun.com/zhao_zepeng/article/category/6200162/2  各种设计模式详细介绍