设计模式精讲-优快云博客

文章目录

观察者模式
单例模式
适配器模式

观察者模式

别名：发布-订阅（Publish/Subscribe）模式。
概念：观察者模式用于建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应作出反应。在观察者模式中，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间可以没有任何相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展。

对于观察者模式，其实Java已经为我们提供了已有的接口和类。

1、Observer（观察者）
只定义了一个 update() 方法，当被观察者对象的状态发生变化时，被观察者对象的 notifyObservers() 方法就会调用这一方法。

public interface Observer {
    void update(Observable o, Object arg);
}

2、Observable类（观察目标）
存储了一个或多个观察者对象。每个观察者对象都是实现 Observer接口的对象。在被观察者发生变化时，会调用 Observable的 notifyObservers()方法，此方法调用所有的具体观察者的update()方法，从而使所有的观察者都被通知更新自己。

setChanged() 设置一个内部标记变量，代表被观察者对象的状态发生了变化。
notifyObservers()调用所有登记过的观察者对象的update()方法，使这些观察者对象可以更新自己。

3、案例
1）定义一个实现了java.util.Observer接口的观察者

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

public class SubscribeDemo implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("start demo:" + ((Publish)o).getMessage());
    }
}

2）创建继承 java.util.Observable的通知者

import java.util.Observable;

public class Publish extends Observable {

    private String message;

    public String getMessage(){
        return message;
    }

    public void setMessage(String message){
        this.message = message;
        // 改变通知者的状态
        super.setChanged();
        // 调用父类Observable方法，通知所有观察者
        super.notifyObservers();
    }
}

3）客户端

public class Client {

    public static void main(String[] args) {
        Publish publish = new Publish();
        publish.addObserver(new SubscribeDemo());
        publish.setMessage("hello");
        publish.setMessage("180123");
    }
}

4）输出

start demo:hello
start demo:180123

单例模式

概念：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

1、饿汉方式
指全局的单例实例在类装载时构建。

public class Singleton {

    private final static Singleton singleton = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return singleton;
    }
}

2、懒汉方式
指全局的单例实例在第一次被使用时构建。

public class Singleton {

    private volatile static Singleton singleton = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if(singleton == null){
            synchronized(Singleton.class){
                // 当两个以上的线程同时进入第一次空检查时，为避免实例多次，需要再次检查。
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

适配器模式

引入适配器模式

首先，先来先讲讲适配器。适配就是由源到目标的适配，而当中链接两者的关系就是适配器。它负责把源过度到目标。
举个例子：比如有一个源是一个对象人，他拥有2种技能分别是说日语和说英语，而某个岗位（目标）需要你同时回说日语、英语、和法语，现在我们的任务就是要将这个源适配到这个岗位中，如何适配呢？最简单的办法是为源添加一个说法语的方法，就满足目标的需要。
但是上面为了实现某种目的而为一个源类暂时性的加上某种方法，已经破坏原类的结构。同时不这么做也符合Java的高内聚，低耦合的原理。所以可以使用适配器模式。

适配器模式思想

把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
适配器模式包括3种形式：类适配器模式、对象适配器模式、接口适配器模式（或又称作缺省适配器模式）。

适配器模式的3个角色

源（Adaptee）：需要被适配的对象或类型。
适配器（Adapter）：连接目标和源的中间对象，适配器同时继承源和实现目标。
目标（Target）：期待得到的目标。

类适配器模式

一个员工会说日语和英语，然后某岗位需要会说法语。
在这里插入图片描述
定义员工，即源。

public class Source {
    public void speakJapanese(){
        System.out.println("我会说日语");
    }
    public void speakEnglish(){
        System.out.println("我会说英语");
    }
}

定义岗位，即目标。

public interface Target {
    public abstract void speakJapanese();
    public abstract void speakEnglish();
    public abstract void speakFrench();
}

定义适配器，适配器同时继承源和实现目标。

public class Adapter extends Source implements Target {
    @Override
    public void speakFrench() {
        System.out.println("我会说法语");
    }
}

客户端使用。

public class App {

    public static void main(String[] args) {
        Adapter adapter = new Adapter();
        adapter.speakJapanese();
        adapter.speakEnglish();
        adapter.speakFrench();
    }
}

运行结果。
在这里插入图片描述

对象适配器模式

对象适配器模式是把源作为一个对象聚合到适配器类中，然后执行接口所要求的方法。这种适配模式可以为多个源进行适配。弥补了类适配模式的不足。
在这里插入图片描述
下面修改适配器。

public class Adapter implements Target {
    private Source source;

    public Adapter(Source source){
        this.source = source;
    }

    @Override
    public void speakJapanese() {
        this.source.speakJapanese();
    }

    @Override
    public void speakEnglish() {
        this.source.speakEnglish();
    }

    @Override
    public void speakFrench() {
        System.out.println("我会说法语");
    }
}

接口适配器模式

也是默认适配器模式，这种模式的核心归结如下：当你想实现一个接口但又不想实现所有接口方法，只想去实现一部分方法时，就用中默认的适配器模式，他的方法是在接口和具体实现类中添加一个抽象类，而用抽象类去空实现目标接口的所有方法。而具体的实现类只需要覆盖其需要完成的方法即可。

抽象类去空实现目标接口的所有方法。

public abstract  class AdapterAbstract implements Target {
    @Override
    public void speakJapanese() {

    }

    @Override
    public void speakEnglish() {

    }

    @Override
    public void speakFrench() {

    }
}

具体的适配器实现类。

public class AdapterImpl extends AdapterAbstract {

    @Override
    public void speakChinese() {
        System.out.println("I can speak Chinese!");
    }
}