首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >常见的设计模式详解

常见的设计模式详解

原创
作者头像
派大星在吗
发布2022-01-21 12:18:56
3020
发布2022-01-21 12:18:56
举报
文章被收录于专栏:我的技术专刊我的技术专刊

创建型模式

简单工厂

选择不一样的参数,生成不一样的产品 可用switch()来做参数选择

public class FoodFactory {
    public static Food makeFood(String name) {
        if (name.equals("noodle")) {
            Food noodle = new LanZhouNoodle();
            noodle.addSpicy("more");
            return noodle;
        } else if (name.equals("chicken")) {
            Food chicken = new HuangMenChicken();
            chicken.addCondiment("potato");
            return chicken;
        } else {
            return null;
       }
    }
}

工厂模式

(需要两个或者两个以上的工厂) 客户端根据不同的参数生成对应的工厂实例 , 该工厂再生成不用的产品

public interface FoodFactory {
    Food makeFood(String name);
}
public class ChineseFoodFactory implements FoodFactory {
    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new ChineseFoodA();
        } else if (name.equals("B")) {
            return new ChineseFoodB();
        } else {
            return null;
        }
    }
}
public class AmericanFoodFactory implements FoodFactory {
    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new AmericanFoodA();
        } else if (name.equals("B")) {
            return new AmericanFoodB();
        } else {
            return null;
        }
    }
}
public class APP {
    public static void main(String[] args) {
        // 先选择一个具体的工厂
        FoodFactory factory = new ChineseFoodFactory();
        // 由第一步的工厂产生具体的对象,不同的工厂造出不一样的对象
        Food food = factory.makeFood("A");
    }
}

抽象工厂

当涉及到 产品族 的时候,就需要引入抽象工厂模式了。

一个经典的例子是造一台电脑。我们先不引入抽象工厂模式,看看怎么实现。

因为电脑是由许多的构件组成的,我们将 CPU 和主板进行抽象,然后 CPU 由 CPUFactory 生产,主板由 MainBoardFactory

生产,然后,我们再将 CPU 和主板搭配起来组合在一起,如下图:

factory-1

这个时候的客户端调用是这样的:

// 得到 Intel 的 CPU
CPUFactory cpuFactory = new IntelCPUFactory();
CPU cpu = intelCPUFactory.makeCPU();
// 得到 AMD 的主板
MainBoardFactory mainBoardFactory = new AmdMainBoardFactory();
MainBoard mainBoard = mainBoardFactory.make();
// 组装 CPU 和主板
Computer computer = new Computer(cpu, mainBoard);

单独看 CPU 工厂和主板工厂,它们分别是前面我们说的 工厂模式 。这种方式也容易扩展,因为要给电脑加硬盘的话,只需要加一个

HardDiskFactory 和相应的实现即可,不需要修改现有的工厂。

但是,这种方式有一个问题,那就是如果 Intel 家产的 CPU 和 AMD 产的主板不能兼容使用

,那么这代码就容易出错,因为客户端并不知道它们不兼容,也就会错误地出现随意组合。

下面就是我们要说的 产品族 的概念,它代表了组成某个产品的一系列附件的集合:

abstract-factory-2

当涉及到这种产品族的问题的时候,就需要抽象工厂模式来支持了。我们不再定义 CPU

工厂、主板工厂、硬盘工厂、显示屏工厂等等,我们直接定义电脑工厂,每个电脑工厂负责生产所有的设备,这样能保证肯定不存在兼容问题。

abstract-factory-3

这个时候,对于客户端来说,不再需要单独挑选

CPU厂商、主板厂商、硬盘厂商等,直接选择一家品牌工厂,品牌工厂会负责生产所有的东西,而且能保证肯定是兼容可用的。

public static void main(String[] args) {
    // 第一步就要选定一个“大厂”
    ComputerFactory cf = new AmdFactory();
    // 从这个大厂造 CPU
    CPU cpu = cf.makeCPU();
    // 从这个大厂造主板
    MainBoard board = cf.makeMainBoard();
      // 从这个大厂造硬盘
      HardDisk hardDisk = cf.makeHardDisk();
    // 将同一个厂子出来的 CPU、主板、硬盘组装在一起
    Computer result = new Computer(cpu, board, hardDisk);
}

当然,抽象工厂的问题也是显而易见的,比如我们要加个显示器,就需要修改所有的工厂,给所有的工厂都加上制造显示器的方法。这有点违反了

对修改关闭,对扩展开放 这个设计原则。

单例模式

饿汉模式最简单:

public class Singleton {
    // 首先,将 new Singleton() 堵死
    private Singleton() {};
    // 创建私有静态实例,意味着这个类第一次使用的时候就会进行创建
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }
    // 瞎写一个静态方法。这里想说的是,如果我们只是要调用 Singleton.getDate(...),
    // 本来是不想要生成 Singleton 实例的,不过没办法,已经生成了
    public static Date getDate(String mode) {return new Date();}
}

很多人都能说出饿汉模式的缺点,可是我觉得生产过程中,很少碰到这种情况:你定义了一个单例的类,不需要其实例,可是你却把一个或几个你会用到的静态方法塞到这个类中。

饱汉模式最容易出错:

public class Singleton {
    // 首先,也是先堵死 new Singleton() 这条路
    private Singleton() {}
    // 和饿汉模式相比,这边不需要先实例化出来,注意这里的 volatile,它是必须的
    private static volatile Singleton instance = null;
    public static Singleton getInstance() {
        if (instance == null) {
            // 加锁
            synchronized (Singleton.class) {
                // 这一次判断也是必须的,不然会有并发问题
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查,指的是两次检查 instance 是否为 null。

volatile 在这里是需要的,希望能引起读者的关注。

很多人不知道怎么写,直接就在 getInstance() 方法签名上加上 synchronized,这就不多说了,性能太差。

嵌套类最经典,以后大家就用它吧:

public class Singleton3 {
    private Singleton3() {}
    // 主要是使用了 嵌套类可以访问外部类的静态属性和静态方法 的特性
    private static class Holder {
        private static Singleton3 instance = new Singleton3();
    }
    public static Singleton3 getInstance() {
        return Holder.instance;
    }
}

注意,很多人都会把这个 嵌套类 说成是 静态内部类 ,严格地说,内部类和嵌套类是不一样的,它们能访问的外部类权限也是不一样的。

最后,我们说一下枚举,枚举很特殊,它在类加载的时候会初始化里面的所有的实例,而且 JVM 保证了它们不会再被实例化,所以它天生就是单例的。

虽然我们平时很少看到用枚举来实现单例,但是在 RxJava 的源码中,有很多地方都用了枚举来实现单例。

建造者模式

经常碰见的 XxxBuilder 的类,通常都是建造者模式的产物。建造者模式其实有很多的变种,但是对于客户端来说,我们的使用通常都是一个模式的:

Food food = new FoodBuilder().a().b().c().build();
Food food = Food.builder().a().b().c().build();

套路就是先 new 一个 Builder,然后可以链式地调用一堆方法,最后再调用一次 build() 方法,我们需要的对象就有了。

package com.wxx.pattern;
class User {
    // 下面是“一堆”的属性
    private String name;
    private String password;
    private String nickName;
    private int age;
    private User(String name, String password, String nickName, int age) {
        this.name = name;
        this.password = password;
        this.nickName = nickName;
        this.age = age;
    }
    public  static  UserBuilder build(){
        return new UserBuilder();
    }
  public  static   class UserBuilder{
      // 下面是和 User 一模一样的一堆属性
      private String name;
      private String password;
      private String nickName;
      private int age;
      private UserBuilder() {
      }
      // 链式调用设置各个属性值,返回 this,即 UserBuilder
      public UserBuilder name(String name) {
          this.name = name;
          return this;
      }
      public UserBuilder password(String password) {
          this.password = password;
          return this;
      }
      public UserBuilder nickName(String nickName) {
          this.nickName = nickName;
          return this;
      }
      public UserBuilder age(int age) {
          this.age = age;
          return this;
      }
      // build() 方法负责将 UserBuilder 中设置好的属性“复制”到 User 中
      // 当然,可以在 “复制” 之前做点检验
      public User build(){
          if(name == null || password == null){
              throw new RuntimeException("用户名和密码不能为空");
          }
          if (age <= 0 || age >= 150) {
              throw new RuntimeException("年龄不合法");
          }
          // 还可以做赋予”默认值“的功能
          if (nickName == null) {
              nickName = name;
          }
          return new User(name, password, nickName, age);
      }
  }
}
//客户端中的调用
 public static void main(String[] args) {
        User d =  User.build().name("foo").password("1244").age(25).build();
    }

原型模式

原型模式很简单:有一个原型 实例 ,基于这个原型实例产生新的实例,也就是“克隆”了。

Object 类中有一个 clone() 方法,它用于生成一个新的对象,当然,如果我们要调用这个方法,java 要求我们的类必须先 **实现

Cloneable 接口** ,此接口没有定义任何方法,但是不这么做的话,在 clone() 的时候,会抛出

CloneNotSupportedException 异常。

protected native Object clone() throws CloneNotSupportedException;

java 的克隆是浅克隆,碰到对象引用的时候,克隆出来的对象和原对象中的引用将指向同一个对象。通常实现深克隆的方法是将对象进行序列化,然后再进行反序列化。

创建型模式总结

  • 简单工厂模式最简单;
  • 工厂模式在简单工厂模式的基础上增加了选择工厂的维度,需要第一步选择合适的工厂;
  • 抽象工厂模式有产品族的概念,如果各个产品是存在兼容性问题的,就要用抽象工厂模式。
  • 单例模式就不说了,为了保证全局使用的是同一对象,一方面是安全性考虑,一方面是为了节省资源;
  • 建造者模式专门对付 属性很多 的那种类,为了让代码更优美;
  • 原型模式用得最少,了解和 Object 类中的 clone() 方法相关的知识即可。

结构型模式

创建型模式用于创建一个对象,而结构型模式旨在通过改变代码结构来达到解耦的目的,使得我们的代码更容易扩展和解耦。

代理模式

既然说是 代理

,那就要对客户端隐藏真实实现,由代理来负责客户端的所有请求。当然,代理只是个代理,它不会完成实际的业务逻辑,而是一层皮而已,但是对于客户端来说,它必须表现得就是客户端需要的真实实现。

public interface FoodService {
 Food makeChicken();
 Food makeNoodle();
}
public class FoodServiceImpl implements FoodService {
 public Food makeChicken() {
 Food f = new Chicken()
 f.setChicken("1kg");
 f.setSpicy("1g");
 f.setSalt("3g");
 return f;
 }
 public Food makeNoodle() {
 Food f = new Noodle();
 f.setNoodle("500g");
 f.setSalt("5g");
 return f;
 }
}
// 代理要表现得“就像是”真实实现类,所以需要实现 FoodService
public class FoodServiceProxy implements FoodService {
 // 内部一定要有一个真实的实现类,当然也可以通过构造方法注入
 private FoodService foodService = new FoodServiceImpl();
 public Food makeChicken() {
 System.out.println("我们马上要开始制作鸡肉了");
 // 如果我们定义这句为核心代码的话,那么,核心代码是真实实现类做的,
 // 代理只是在核心代码前后做些“无足轻重”的事情
 Food food = foodService.makeChicken();
 System.out.println("鸡肉制作完成啦,加点胡椒粉"); // 增强
 food.addCondiment("pepper");
 return food;
 }
 public Food makeNoodle() {
 System.out.println("准备制作拉面~");
 Food food = foodService.makeNoodle();
 System.out.println("制作完成啦")
 return food;
 }
}

客户端调用,注意,我们要用代理来实例化接口:

// 这里用代理类来实例化
FoodService foodService = new FoodServiceProxy();
foodService.makeChicken();

proxy

代理模式说白了就是做 “方法包装” 或做 “方法增强” 。在面向切面编程中,其实就是动态代理的过程。比如 Spring

中,我们自己不定义代理类,但是 Spring 会帮我们动态来定义代理,然后把我们定义在 @Before、@After、@Around

中的代码逻辑动态添加到代理中。

说到动态代理,又可以展开说,Spring 中实现动态代理有两种,一种是如果我们的类定义了接口,如 UserService 接口和

UserServiceImpl 实现,那么采用 JDK 的动态代理,感兴趣的读者可以去看看 java.lang.reflect.Proxy

类的源码;另一种是我们自己没有定义接口的,Spring 会采用 CGLIB 进行动态代理,它是一个 jar 包,性能还不错。

适配器模式

适配器模式总体来说分三种:默认适配器模式、对象适配器模式、类适配器模式。先不急着分清楚这几个,先看看例子再说。

默认适配器模式

首先,我们先看看最简单的适配器模式 默认适配器模式(Default Adapter) 是怎么样的。

我们用 Appache commons-io 包中的 FileAlterationListener

做例子,此接口定义了很多的方法,用于对文件或文件夹进行监控,一旦发生了对应的操作,就会触发相应的方法。

public interface FileAlterationListener {
    void onStart(final FileAlterationObserver observer);
    void onDirectoryCreate(final File directory);
    void onDirectoryChange(final File directory);
    void onDirectoryDelete(final File directory);
    void onFileCreate(final File file);
    void onFileChange(final File file);
    void onFileDelete(final File file);
    void onStop(final FileAlterationObserver observer);
}

此接口的一大问题是抽象方法太多了,如果我们要用这个接口,意味着我们要实现每一个抽象方法,如果我们只是想要监控文件夹中的 文件创建

文件删除 事件,可是我们还是不得不实现所有的方法,很明显,这不是我们想要的。

所以,我们需要下面的一个 适配器 ,它用于实现上面的接口,但是 所有的方法都是空方法

,这样,我们就可以转而定义自己的类来继承下面这个类即可。

public class FileAlterationListenerAdaptor implements FileAlterationListener {
    public void onStart(final FileAlterationObserver observer) {
    }
    public void onDirectoryCreate(final File directory) {
    }
    public void onDirectoryChange(final File directory) {
    }
    public void onDirectoryDelete(final File directory) {
    }
    public void onFileCreate(final File file) {
    }
    public void onFileChange(final File file) {
    }
    public void onFileDelete(final File file) {
    }
    public void onStop(final FileAlterationObserver observer) {
    }
}

比如我们可以定义以下类,我们仅仅需要实现我们想实现的方法就可以了:

public class FileMonitor extends FileAlterationListenerAdaptor {
    public void onFileCreate(final File file) {
        // 文件创建
        doSomething();
    }
    public void onFileDelete(final File file) {
        // 文件删除
        doSomething();
    }
}

当然,上面说的只是适配器模式的其中一种,也是最简单的一种,无需多言。下面,再介绍 “正统的” 适配器模式。

对象适配器模式

来看一个《Head First

设计模式》中的一个例子,我稍微修改了一下,看看怎么将鸡适配成鸭,这样鸡也能当鸭来用。因为,现在鸭这个接口,我们没有合适的实现类可以用,所以需要适配器。

public interface Duck {
 public void quack(); // 鸭的呱呱叫
 public void fly(); // 飞
}
public interface Cock {
 public void gobble(); // 鸡的咕咕叫
 public void fly(); // 飞
}
public class WildCock implements Cock {
 public void gobble() {
 System.out.println("咕咕叫");
 }
 public void fly() {
 System.out.println("鸡也会飞哦");
 }
}

鸭接口有 fly() 和 quare() 两个方法,鸡 Cock 如果要冒充鸭,fly() 方法是现成的,但是鸡不会鸭的呱呱叫,没有 quack()

方法。这个时候就需要适配了:

// 毫无疑问,首先,这个适配器肯定需要 implements Duck,这样才能当做鸭来用
public class CockAdapter implements Duck {
 Cock cock;
 // 构造方法中需要一个鸡的实例,此类就是将这只鸡适配成鸭来用
 public CockAdapter(Cock cock) {
 this.cock = cock;
 }
 // 实现鸭的呱呱叫方法
 @Override
 public void quack() {
 // 内部其实是一只鸡的咕咕叫
 cock.gobble();
 }
 @Override
 public void fly() {
 cock.fly();
 }
}

客户端调用很简单了:

public static void main(String[] args) {
 // 有一只野鸡
 Cock wildCock = new WildCock();
 // 成功将野鸡适配成鸭
 Duck duck = new CockAdapter(wildCock);
 ...
}

到这里,大家也就知道了适配器模式是怎么回事了。无非是我们需要一只鸭,但是我们只有一只鸡,这个时候就需要定义一个适配器,由这个适配器来充当鸭,但是适配器里面的方法还是由鸡来实现的。

adapter-1

释义:我现在手中只有SomeThing 但是我想用Target对象 我该如何是好?

  1. 在适配器中注入我拥有的对象SomeThing ,即被适配对象;
  2. 在适配器中实现用自己的方法来目标方法,即可达到目的;

类适配器模式

废话少说,直接上图:

adapter-1

看到这个图,大家应该很容易理解的吧,通过继承的方法,适配器自动获得了所需要的大部分方法。这个时候,客户端使用更加简单,直接 `Target t = new

SomeAdapter();` 就可以了。

适配器模式总结

  1. 类适配和对象适配的异同

一个采用继承,一个采用组合;

类适配属于静态实现,对象适配属于组合的动态实现,对象适配需要多实例化一个对象。

总体来说,对象适配用得比较多。

  1. 适配器模式和代理模式的异同

比较这两种模式,其实是比较对象适配器模式和代理模式,在代码结构上,它们很相似,都需要一个具体的实现类的实例。但是它们的目的不一样,代理模式做的是增强原方法的活;适配器做的是适配的活,为的是提供“把鸡包装成鸭,然后当做鸭来使用”,而鸡和鸭它们之间原本没有继承关系。

adapter-5

装饰模式

首先,我们先看一个简单的图,看这个图的时候,了解下层次结构就可以了:

decorator-1

我们来说说装饰模式的出发点,从图中可以看到,接口 Component 其实已经有了 ConcreteComponentA

ConcreteComponentB 两个实现类了,但是,如果我们要 增强 这两个实现类的话,我们就可以采用装饰模式,用具体的装饰器来

装饰 实现类,以达到增强的目的。

最近大街上流行起来了“快乐柠檬”,我们把快乐柠檬的饮料分为三类:红茶、绿茶、咖啡,在这三大类的基础上,又增加了许多的口味,什么金桔柠檬红茶、金桔柠檬珍珠绿茶、芒果红茶、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等,每家店都有很长的菜单,但是仔细看下,其实原料也没几样,但是可以搭配出很多组合,如果顾客需要,很多没出现在菜单中的饮料他们也是可以做的。

在这个例子中,红茶、绿茶、咖啡是最基础的饮料,其他的像金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的。当然,在开发中,我们确实可以像门店一样,开发这些类:LemonBlackTea、LemonGreenTea、MangoBlackTea、MangoLemonGreenTea......但是,很快我们就发现,这样子干肯定是不行的,这会导致我们需要组合出所有的可能,而且如果客人需要在红茶中加双份柠檬怎么办?三份柠檬怎么办?

不说废话了,上代码。

首先,定义饮料抽象基类:

public abstract class Beverage {
 // 返回描述
 public abstract String getDescription();
 // 返回价格
 public abstract double cost();
}

然后是三个基础饮料实现类,红茶、绿茶和咖啡:

public class BlackTea extends Beverage {
 public String getDescription() {
 return "红茶";
 }
 public double cost() {
 return 10;
 }
}
public class GreenTea extends Beverage {
 public String getDescription() {
 return "绿茶";
 }
 public double cost() {
 return 11;
 }
}
...// 咖啡省略

定义调料,也就是装饰者的基类,此类必须继承自 Beverage:

// 调料
public abstract class Condiment extends Beverage {
}

然后我们来定义柠檬、芒果等具体的调料,它们属于装饰者,毫无疑问,这些调料肯定都需要继承调料 Condiment 类:

public class Lemon extends Condiment {
 private Beverage bevarage;
 // 这里很关键,需要传入具体的饮料,如需要传入没有被装饰的红茶或绿茶,
 // 当然也可以传入已经装饰好的芒果绿茶,这样可以做芒果柠檬绿茶
 public Lemon(Beverage bevarage) {
 this.bevarage = bevarage;
 }
 public String getDescription() {
 // 装饰
 return bevarage.getDescription() + ", 加柠檬";
 }
 public double cost() {
 // 装饰
 return beverage.cost() + 2; // 加柠檬需要 2 元
 }
}
public class Mango extends Condiment {
 private Beverage bevarage;
 public Mango(Beverage bevarage) {
 this.bevarage = bevarage;
 }
 public String getDescription() {
 return bevarage.getDescription() + ", 加芒果";
 }
 public double cost() {
 return beverage.cost() + 3; // 加芒果需要 3 元
 }
}
...// 给每一种调料都加一个类

看客户端调用:

public static void main(String[] args) {
 // 首先,我们需要一个基础饮料,红茶、绿茶或咖啡
 Beverage beverage = new GreenTea();
 // 开始装饰
 beverage = new Lemon(beverage); // 先加一份柠檬
 beverage = new Mongo(beverage); // 再加一份芒果
 System.out.println(beverage.getDescription() + " 价格:¥" + beverage.cost());
 //"绿茶, 加柠檬, 加芒果 价格:¥16"
}

如果我们需要 芒果-珍珠-双份柠檬-红茶

Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea()))));

是不是很变态?

看看下图可能会清晰一些:

decorator-2

到这里,大家应该已经清楚装饰模式了吧。

门面模式

门面模式(也叫外观模式,Facade Pattern)在许多源码中有使用,比如 slf4j

就可以理解为是门面模式的应用。这是一个简单的设计模式,我们直接上代码再说吧。

首先,我们定义一个接口:

public interface Shape {
   void draw();
}

定义几个实现类:

public class Circle implements Shape {
    @Override
    public void draw() {
       System.out.println("Circle::draw()");
    }
}
public class Rectangle implements Shape {
    @Override
    public void draw() {
       System.out.println("Rectangle::draw()");
    }
}

客户端调用:

public static void main(String[] args) {
    // 画一个圆形
      Shape circle = new Circle();
      circle.draw();
      // 画一个长方形
      Shape rectangle = new Rectangle();
      rectangle.draw();
}

我们先定义一个门面:

public class ShapeMaker {
   private Shape circle;
   private Shape rectangle;
   private Shape square;
   public ShapeMaker() {
      circle = new Circle();
      rectangle = new Rectangle();
      square = new Square();
   }
  /**
   * 下面定义一堆方法,具体应该调用什么方法,由这个门面来决定
   */
   public void drawCircle(){
      circle.draw();
   }
   public void drawRectangle(){
      rectangle.draw();
   }
   public void drawSquare(){
      square.draw();
   }
}

看看现在客户端怎么调用:

public static void main(String[] args) {
  ShapeMaker shapeMaker = new ShapeMaker();
  // 客户端调用现在更加清晰了
  shapeMaker.drawCircle();
  shapeMaker.drawRectangle();
  shapeMaker.drawSquare();        
}

门面模式的优点显而易见,客户端不再需要关注实例化时应该使用哪个实现类,直接调用门面提供的方法就可以了,因为门面类提供的方法的方法名对于客户端来说已经很友好了。

总结

  • 代理模式是做方法增强的
  • 适配器模式是把鸡包装成鸭这种用来适配接口的
  • 装饰模式从名字上就看得出来,适合于装饰类或者说是增强类的场景
  • 门面模式的优点是客户端不需要关心实例化过程,只要调用需要的方法即可

行为型模式

行为型模式关注的是各个类之间的相互作用,将职责划分清楚,使得我们的代码更加地清晰。

策略模式

策略模式太常用了,所以把它放到最前面进行介绍。它比较简单,我就不废话,直接用代码说事吧。

下面设计的场景是,我们需要画一个图形,可选的策略就是用红色笔来画,还是绿色笔来画,或者蓝色笔来画。

首先,先定义一个策略接口:

public interface Strategy {
   public void draw(int radius, int x, int y);
}

然后我们定义具体的几个策略:

public class RedPen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用红色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
   }
}
public class GreenPen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用绿色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
   }
}
public class BluePen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用蓝色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
   }
}

使用策略的类:

public class Context {
 private Strategy strategy;
 public Context(Strategy strategy){
 this.strategy = strategy;
 }
 public int executeDraw(int radius, int x, int y){
 return strategy.draw(radius, x, y);
 }
}

放到一张图上,让大家看得清晰些:

strategy-1

观察者模式

观察者模式对于我们来说,真是再简单不过了。无外乎两个操作,观察者订阅自己关心的主题和主题有数据变化后通知观察者们。

首先,需要定义主题,每个主题需要持有观察者列表的引用,用于在数据变更的时候通知各个观察者:

public class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private int state;
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
        // 数据已变更,通知观察者们
        notifyAllObservers();
    }
    // 注册观察者
    public void attach(Observer observer) {
        observers.add(observer);
    }
    // 通知观察者们
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

定义观察者接口:

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

其实如果只有一个观察者类的话,接口都不用定义了,不过,通常场景下,既然用到了观察者模式,我们就是希望一个事件出来了,会有多个不同的类需要处理相应的信息。比如,订单修改成功事件,我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。

我们来定义具体的几个观察者类:

public class BinaryObserver extends Observer {
    // 在构造方法中进行订阅主题
    public BinaryObserver(Subject subject) {
        this.subject = subject;
        // 通常在构造方法中将 this 发布出去的操作一定要小心
        this.subject.attach(this);
    }
    // 该方法由主题类在数据变更的时候进行调用
    @Override
    public void update() {
        String result = Integer.toBinaryString(subject.getState());
        System.out.println("订阅的数据发生变化,新的数据处理为二进制值为:" + result);
    }
}
public class HexaObserver extends Observer {
    public HexaObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        String result = Integer.toHexString(subject.getState()).toUpperCase();
        System.out.println("订阅的数据发生变化,新的数据处理为十六进制值为:" + result);
    }
}

客户端使用也非常简单:

public static void main(String[] args) {
    // 先定义一个主题
    Subject subject1 = new Subject();
    // 定义观察者
    new BinaryObserver(subject1);
    new HexaObserver(subject1);
    // 模拟数据变更,这个时候,观察者们的 update 方法将会被调用
    subject.setState(11);
}

output:

订阅的数据发生变化,新的数据处理为二进制值为:1011
订阅的数据发生变化,新的数据处理为十六进制值为:B

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 创建型模式
    • 简单工厂
      • 工厂模式
        • 抽象工厂
          • 单例模式
            • 建造者模式
              • 原型模式
                • 创建型模式总结
                • 结构型模式
                  • 代理模式
                    • 适配器模式
                      • 默认适配器模式
                      • 对象适配器模式
                      • 类适配器模式
                      • 适配器模式总结
                    • 装饰模式
                      • 门面模式
                        • 总结
                        • 行为型模式
                          • 策略模式
                            • 观察者模式
                            相关产品与服务
                            短信
                            腾讯云短信(Short Message Service,SMS)可为广大企业级用户提供稳定可靠,安全合规的短信触达服务。用户可快速接入,调用 API / SDK 或者通过控制台即可发送,支持发送验证码、通知类短信和营销短信。国内验证短信秒级触达,99%到达率;国际/港澳台短信覆盖全球200+国家/地区,全球多服务站点,稳定可靠。
                            领券
                            问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档