[关闭]
@coder-pig 2017-05-06T03:28:22.000000Z 字数 25378 阅读 1748

震惊!小猪的设计模式初涉总结!纯干货~

知识点总结


描述性文字

      今年一月初有了离职的念头后,就盘算着把设计模式给过一遍,索性就
开了一个新的系列:《如何让孩子爱上设计模式》,在编写过程中经历了
旧项目重构,离职交接,写简历,投简历,面试,搬家等阶段,零零星星,
总算是坚持写完,自己也是收获颇多,至少面试的时候别人问你用过了解
什么设计模式,不是绞尽脑汁的憋出那么几个烂大街的,单例,建造者...
当然只是对各种设计模式有了一个初步的了解,灵活运用还得在实践和阅读
优秀源码中去慢慢体会!和《Git大法好》系列一样,《如何让孩子爱上设计模式》
同样是想让初学者更好更快的去理解每种模式,依旧本着通熟易懂的理念去编写,
这也意味着有很多废话,所以总结提取里面的精华,基本套路显得非常重要,
遂有此文。描述文字大概就这些,想到再写,本文会一直更新,如果文字
有描述错误或写得不好的地方欢迎指出,万分感激~

本文在线版(排版更佳,优先更新):https://www.zybuluo.com/coder-pig/note/658810
本文不收取任何费用,欢迎转载,请勿将本文用于商业用途,
想了解更多内容可见:http://blog.csdn.net/coder_pig
如果本文对你学习设计模式有一定帮助,不妨小额打赏下小猪,你的鼓励是我不断写
博客的动力,当然实在囊中羞涩,但又很想支持小猪的话,点个赞,留个言也行,
万分感谢~

微信: 支付宝:

如有什么疑问欢迎加群:421858269 反馈,谢谢~


1.面向对象的三大特性

1)封装(Encapsulation)

隐藏对象的具体实现细节,通过共有方法暴露对象的功能。
内部结构可以自由修改,同时可对成员进行更加精确的控制
(比如在setter方法中加值合法判断)

2)继承(Inheritance)

使用已经存在的类作为基础类(父类),在此基础上建立新类(子类),
子类既可复用父类的功能,也能进行扩展,从而实现代码复用。
另外,Java不能像C++那样同时继承多个父类,只能树形的继承
比如:Man -> Human -> Animal,或通过接口和内部类实现多继承。

另外,关于继承还需注意以下几点:

  • 1.子类拥有父类非private的属性与方法
  • 2.构造方法只能调用,不能实现,子类默认调用父类的无参构造方法,
    如果父类没有无参的构造方法,需要使用super显式调用!
  • 3.慎用继承,要考虑是否需要从子类向父类进行向上转型!

3)多态(Polymorphism)

定义:一个类实例的相同方法在不同的情形下有不同的表现形式

分为以下两种:

运行时多态(动态绑定,new后面什么类型,动态类型就是什么类型)
示例如下:

  1. class Animal() { fun show() { println("动物") }}
  2. class PeopleAnimal() { fun show() { println("人类") }}
  3. //下述代码打印结果:人类
  4. Animal animal = new People()
  5. animal.show()

2.类与类间的关系

口诀鸡湿衣冠剧组(继承,实现,依赖,关联,聚合,组合)

继承和实现就不说了,后面四个只是 语意层次 的区别
两个类的相关程度,依赖 < 关联 < 聚合 < 组合

依次的UML类图标记:


3.面向对象七大原则


23种设计模式


一. 单例模式(Singleton Pattern)

作用:保证 类在内存中对象唯一性

适用场景

套路(三个要点):

饿汉与懒汉的区别

前者在类装载时就实例化,后者只有在第一次被使用时才实例化。
(饿汉的优点是避免线程同步问题,缺点是即使没用到这个实例还是会加载)
(懒汉的优点是实现了懒加载,但需要解决线程安全问题!)

7种单例套路

1)饿汉式,没有实现懒加载~

  1. public class Singleton() {
  2. private static Singleton instance = new Singleton();
  3. private Singleton(){ }
  4. public static Singleton getInstance() {
  5. return instance;
  6. }
  7. }
  8. //获取单例对象
  9. Singleton mSingleton = Singleton.getInstance();

2)懒汉式

虽然达到了懒加载,但是却存在线程安全问题,比如有两个线程都
刚好执行完if(instance == null),接着准备执行instance = new Singleton()
语句,这样的结果会导致我们实例化了两个Singleton对象
为了解决线程不安全问题,可以对getInstance()方法加锁。

  1. public class Singleton {
  2. private static Singleton instance = null;
  3. private Singleton() { }
  4. private static Singleton getInstance() {
  5. if(instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. }

3)懒汉式加锁版

为getInstance方法加锁虽然保证了线程安全,但是每次执行getInstance()
都需要同步,而实例化对象只需要执行一次就够了,后面获取该示例,
应该直接return就好了,方法同步效率太低,一种改进后的写法是:
synchronized (Singleton.class) { instance = new Singleton(); }
但是,这样写依然是线程不安全的,如果你还是想用懒汉式的话,推荐
双重检查锁定(DCL,Double Check Lock)。

  1. public class Singleton {
  2. private static Singleton instance = null;
  3. private Singleton() { }
  4. private static synchronized Singleton getInstance() {
  5. if(instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. }

4)懒汉式双重校验锁(DCL)

代码中进行了两次if检查,这样就可以保证线程安全,初始化一次后,
后面再次访问时,if检查,直接return 实例化对象。volatile是1.5后
引入的,volatile关键字会屏蔽Java虚拟机所做的一些代码优化,会导
致系统运行效率降低,而更好的写法是使用静态内部类来实现单例!

  1. public class Singleton{
  2. private static volatile Singleton instance = null;
  3. private Singleton() { }
  4. public static Singleton getInstance() {
  5. if(instance == null) {
  6. synchronized(Singleton.class) {
  7. if(instance == null) instance = new Singleton();
  8. }
  9. }
  10. return instance;
  11. }
  12. }

5)静态内部类实现单例(推荐)

和饿汉式类似,都是通过类加载机制来保证初始化实例的
时候只有一个线程,从而避免线程安全问题,饿汉式的
Singleton类被加载时,就会实例化,而静态内部类这种,
当Singleton类被加载时,不会立即实例化,调用getInstance()
方法才会装载SingletonHolder类,从而完成Singleton的实例化。

  1. public class Singleton {
  2. private Singleton() { }
  3. private static final Singleton getInstance() {
  4. return SingletonHolder.INSTANCE;
  5. }
  6. private static class SingletonHolder {
  7. private static final Singleton INSTANCE = new Singleton()
  8. }
  9. }

6)枚举实现单例

INSTANCE即为SingletonEnum类型的引用,得到它就可以调用
枚举中的方法。既避免了线程安全问题,还能防止反序列化
重新创建新的对象,但是失去了类的一些特性,而且没有延时加载。

  1. public enum SingletonEnum {
  2. INSTANCE;
  3. private Singleton instance;
  4. SingletonEnum() {
  5. instance = new Singleton();
  6. }
  7. public Singleton getInstance() {
  8. return instance;
  9. }
  10. }
  11. //调用方式
  12. SingletonEnum.INSTANCE.method();

7)容器实现单例

将多种单例类型注入到一个统一的管理类中,在使用时根据key获取对象
对应类型的对象。这种方式使得我们可以管理多种类型的单例,并且在使
用时可以通过统一的接口进行获取操作,降低了用户的使用成本,也对用
户隐藏了具体实现,降低了耦合度。

  1. public class SingletonManager {
  2. private static Map<String,Object> objMap = new HashMap<String,Object>();
  3. private Singleton(){ }
  4. public static void registerService(String key,Object instance) {
  5. if(!objMap.containsKey(key)) {
  6. objMap.put(key,instance);
  7. }
  8. }
  9. public static Object getService(String key) {
  10. return objMap.get(key);
  11. }
  12. }

二. 建造者模式(Builder Pattern)

复杂对象的构建与表示分离 开来,使得同样的构建过程可以
创建不同的表示,缺点是可能产生多余的创建者与构建过程对象
消耗内存,不适用于内部建造顺序不稳定,变化复杂的对象
可能导致需要创建很多具体的建造者来实现这些变化。
例子:玩游戏创建角色时的自定义,不同的搭配生成不同的角色。

四个角色与UML类图

示例代码

  1. //产品类
  2. class Character {
  3. private String sex;
  4. private String face;
  5. private String clothes;
  6. void setSex(String sex) { this.sex = sex;}
  7. void setFace(String face) { this.face = face; }
  8. void setClothes(String clothes) { this.clothes = clothes;}
  9. String showMsg() { return "你创建了一个穿着 " + clothes + " 一副 " + face + " 的" + sex + "ヾ(≧▽≦*)o 戳菊狂笑~"; }
  10. }
  11. //抽象Builder接口
  12. interface Builder {
  13. void setSex(String sex);
  14. void setFace(String face);
  15. void setClothes(String clothes);
  16. Character build();
  17. }
  18. //Builder接口实现类
  19. class ConcreteBuilder implements Builder {
  20. private Character mCharacter = new Character();
  21. @Override public void setSex(String sex) { mCharacter.setSex(sex); }
  22. @Override public void setFace(String face) { mCharacter.setFace(face); }
  23. @Override public void setClothes(String clothes) { mCharacter.setClothes(clothes); }
  24. @Override public Character build() {return mCharacter;}
  25. }
  26. //装配过程类
  27. class Director {
  28. private Builder mBuilder = null;
  29. Director(Builder builder) { this.mBuilder = builder; }
  30. Character createCharacter(String sex, String face, String clothes) {
  31. this.mBuilder.setSex(sex);
  32. this.mBuilder.setFace(face);
  33. this.mBuilder.setClothes(clothes);
  34. return mBuilder.build();
  35. }
  36. }
  37. //客户端调用类
  38. public class Game {
  39. public static void main(String[] args) {
  40. Builder builder = new ConcreteBuilder();
  41. Director director = new Director(builder);
  42. Character character = director.createCharacter("基佬","硬汉脸","死库水");
  43. System.out.println(character.showMsg());
  44. }
  45. }

输出结果


三. 原型模式(Prototype Pattern)

下面两种场景可以考虑使用原型模式:

三个角色与UML类图

Java中 == 与equals的区别

克隆需要满足的三个条件

Java中如何使用

Prototype原型类(想被克隆的类)实现Cloneable接口重写clone()方法。

  1. ConcretePrototype cp1 = new ConcretePrototype();
  2. ConcretePrototype cp2 = (ConcretePrototype)cp1.clone();

需注意

实现深拷贝的两种套路

这种只新建基本类型数据,不新建引用类型数据,称为浅拷贝
如果连引用类型数据也新建的话,则称为深拷贝

两个套路:

1.引用类型也实现Cloneable接口,如果属性的类型也是对象,
那么需要一直递归的克隆下去
2.序列化,属性的类型是引用类型的话,需要实现Serializable接口
然后自己写个方法来在里面完成对象转二进制流与二进制流转
对象
的方法,然后返回克隆后的对象!

具体代码见:3.Prototype Pattern


四.工厂方法模式(Factory Method Pattern)

关于三种工厂模式,其实理解起来非常简单,只是把对象的创建放到一个
特定的类中,相比起我们直接new对象,这种套路会写多几个类,但是
却拥有更好的扩展性,而且当创建的对象发生改变,可以减少一定的修改量。
(想想你在项目中有一个类在多处都new了,现在需要对这个类的构造
方法,或者相关参数做些修改,你需要找到每个new这个类的地方进行
修改,而如果你把工作都丢给一个工厂类,你可能只需要修改这个类)
另外,简介下这几种工厂模式的区别:


简单工厂模式的三个角色

代码示例

  1. abstract class Tea {
  2. public abstract void 加奶茶();
  3. public abstract void 加料();
  4. }
  5. class YeGuoTea extends Tea{
  6. @Override public void 加奶茶() { System.out.println("加了一把奶茶");}
  7. @Override public void 加料() {System.out.println("加了一把椰果");}
  8. }
  9. class ZhenZhuTea extends Tea{
  10. @Override public void 加奶茶() { System.out.println("加了一把奶茶");}
  11. @Override public void 加料() {System.out.println("加了一把珍珠");}
  12. }
  13. public class Me {
  14. public static Tea makeTea(int type) {
  15. System.out.println("==============");
  16. Tea tea = type == 0 ? new ZhenZhuTea() : new YeGuoTea();
  17. tea.加奶茶();
  18. tea.加料();
  19. return tea;
  20. }
  21. }
  22. public class Store {
  23. public static void main(String[] args) {
  24. for (int i = 0;i < 3;i++) {
  25. Tea tea = Me.makeTea(buyTea()); //小猪制作奶茶
  26. }
  27. }
  28. /* 模拟用户下单,0代表要珍珠奶茶,1代表要椰果奶茶 */
  29. private static int buyTea() {
  30. return new Random().nextInt(2);
  31. }
  32. }

输出结果


工厂方法模式(静态工厂)

其实就是在简单工厂模式基础上,把工厂创建不同产品的内部逻辑抽取出来,
生成一个抽象工厂,再创建具体工厂类,生产不同的产品。

UML类图

代码示例

  1. //工厂接口/抽象类
  2. abstract class MakeTea {
  3. abstract Tea 小猪带特效的奶茶制作工艺();
  4. }
  5. //工厂实现类1
  6. class ZhenZhuMakeTea extends MakeTea {
  7. @Override
  8. Tea 小猪带特效的奶茶制作工艺() {
  9. System.out.println("====== 珍珠小弟炮制港式珍珠奶茶 ======");
  10. Tea tea = new ZhenZhuTea();
  11. tea.加奶();
  12. tea.加茶();
  13. tea.加料();
  14. tea.打包();
  15. return tea;
  16. }
  17. }
  18. //工厂实现类2
  19. class YeGuoMakeTea extends MakeTea {
  20. @Override
  21. Tea 小猪带特效的奶茶制作工艺() {
  22. System.out.println("====== 椰果小弟炮制日式椰果奶茶 ======");
  23. Tea tea = new YeGuoTea();
  24. tea.加奶();
  25. tea.加茶();
  26. tea.加料();
  27. tea.打包();
  28. return tea;
  29. }
  30. }
  31. //客户端调用
  32. public class StoreS {
  33. public static void main(String[] args) {
  34. //初始化两个小弟
  35. ZhenZhuMakeTea zhenzhu = new ZhenZhuMakeTea();
  36. YeGuoMakeTea yeguo = new YeGuoMakeTea();
  37. for (int i = 0;i < 3;i++) {
  38. Tea tea = buyTea() == 0 ? zhenzhu.小猪带特效的奶茶制作工艺()
  39. : yeguo.小猪带特效的奶茶制作工艺();
  40. }
  41. }
  42. /* 模拟用户下单,0代表要珍珠奶茶,1代表要椰果奶茶 */
  43. private static int buyTea() {
  44. return new Random().nextInt(2);
  45. }
  46. }

输出结果

另外还可以通过反射简洁生产过程,直接传入产品的类类型
生成对应的产品,示例如下:

  1. abstract class SMakeTea {
  2. public abstract <T extends Tea> T 小猪带特效的奶茶制作工艺(Class<T> clz);
  3. }
  4. class SMe extends SMakeTea {
  5. @Override
  6. public <T extends Tea> T 小猪带特效的奶茶制作工艺(Class<T> clz) {
  7. System.out.println("==============");
  8. Tea tea = null;
  9. try {
  10. tea = (Tea) Class.forName(clz.getName()).newInstance();
  11. tea.加奶();
  12. tea.加茶();
  13. tea.加料();
  14. tea.打包();
  15. } catch (Exception e) {
  16. e.printStackTrace();
  17. }
  18. return (T) tea;
  19. }
  20. }
  21. public class SStore {
  22. public static void main(String[] args) {
  23. SMe me = new SMe();
  24. me.小猪带特效的奶茶制作工艺(ZhenZhuTea.class);
  25. me.小猪带特效的奶茶制作工艺(YeGuoTea.class);
  26. }
  27. }

六. 抽象工厂模式(Abstract Factory Pattern)

代码示例

  1. //抽象产品类1
  2. abstract class Drink {
  3. public abstract void drink();
  4. }
  5. //抽象产品类2
  6. abstract class Snack {
  7. public abstract void snack();
  8. }
  9. //具体产品类们
  10. class MilkTea extends Drink {
  11. @Override public void drink() { System.out.println("一杯奶茶"); }
  12. }
  13. class Juice extends Drink {
  14. @Override public void drink() { System.out.println("一杯果汁"); }
  15. }
  16. class HandGrab extends Snack {
  17. @Override public void snack() { System.out.println("一个手抓饼"); }
  18. }
  19. class FishBall extends Snack {
  20. @Override public void snack() { System.out.println("一碗鱼蛋"); }
  21. }
  22. //抽象工厂类
  23. abstract class MakeFood {
  24. abstract Drink createMakeDrink();
  25. abstract Snack createMakeSnack();
  26. }
  27. //具体工厂类1
  28. class FirstXiaoDi extends MakeFood {
  29. @Override public Drink createMakeDrink() { return new MilkTea(); }
  30. @Override public Snack createMakeSnack() { return new HandGrab(); }
  31. }
  32. //具体工厂类2
  33. class SecondXiaoDi extends MakeFood {
  34. @Override public Drink createMakeDrink() { return new Juice(); }
  35. @Override public Snack createMakeSnack() { return new FishBall(); }
  36. }
  37. //客户端调用
  38. public class Store {
  39. public static void main(String[] args) {
  40. //初始化两个小弟
  41. MakeFood xiaodi1 = new FirstXiaoDi();
  42. MakeFood xiaodi2 = new SecondXiaoDi();
  43. for(int i = 0;i < 4 ;i++) {
  44. System.out.println("====== 根据订单配餐: ======");
  45. Drink drink = buyDrink() == 0 ?
  46. xiaodi1.createMakeDrink() : xiaodi2.createMakeDrink();
  47. Snack snack = buySnack() == 0 ?
  48. xiaodi1.createMakeSnack() : xiaodi2.createMakeSnack();
  49. drink.drink();
  50. snack.snack();
  51. }
  52. }
  53. /* 模拟用户点饮料,0代表要奶茶,1代表要果汁 */
  54. private static int buyDrink() { return new Random().nextInt(2); }
  55. /* 模拟用户点小吃,0代表要手抓饼,1代表要鱼蛋 */
  56. private static int buySnack() { return new Random().nextInt(2); }
  57. }

输出结果

两个名词(产品等级结构产品族)

四个角色与UML类图

抽象工厂模式适用于创建的对象有多个相互关联或依赖的产品族
抽象工厂模式隔离具体类的生成,接口与实现分离,增加新的产品族很方便;
但是扩展新的产品等级结构麻烦,需要修改抽象工厂,具体工厂类也要更改。


七. 适配器模式(Adapter Pattern)

两个彼此间没太大关联的类,想进行交互完成某些事情,不想直接
去修改各自的接口,可以添加一个中间类,让他来协调两个类
间的关系,完成相关业务,这种模式就叫适配器模式。

然后分为:类适配器对象适配器 两种,前者和适配者是继承关系,
后者与适配者则是引用关系。

对象适配器支持传入一个被适配器对象,因此可以做到对多种被适
配接口进行适配。而类适配器直接继承无法动态修改,所以一般情况
下对象适配器使用得更多!(Java不支持多重继承!!!)

对象适配器例子(用得较多)

  1. /* 目标接口 */
  2. interface Chinese {
  3. void speakChinese(String string);
  4. }
  5. /* 需要适配的类 */
  6. class English {
  7. void speakEnglish(String string) { System.out.println("【英语】" + string); }
  8. }
  9. /* 适配器 */
  10. class Translator implements Chinese{
  11. private English english = new English();
  12. Translator(English english) { this.english = english; }
  13. @Override public void speakChinese(String string) { english.speakEnglish(string); }
  14. }
  15. /* 客户端调用 */
  16. public class Client {
  17. public static void main(String[] args) {
  18. Chinese chinese = new Translator(new English());
  19. chinese.speakChinese("那你很棒棒哦!");
  20. }
  21. }

输出结果

类适配器例子

  1. /* 类适配器 */
  2. class ClassTranslator extends English implements Chinese {
  3. @Override public void speakChinese(String string) { speakEnglish(string); }
  4. }
  5. /* 客户端调用 */
  6. public class ClientC {
  7. public static void main(String[] args) {
  8. ClassTranslator translator = new ClassTranslator();
  9. translator.speakChinese("你也很好啊!");
  10. }
  11. }

输出结果

除此之外还有个缺省适配器模式的名词,简单点说就是不需要实现接口中
提供的所有方法时,先写一个抽象类实现这个接口,然后为每个方法提供一个
默认实现(空方法),然后选择性覆盖某些方法实现需求,又称单接口适配器模式。


八.装饰者模式(Decorator Pattern)

动态的给对象添加一些额外的职责,就增加功能来说,装饰者
模式比起生成子类更加灵活!就是想替代多重层继承的模式。
其实就是一层套一层

代码示例

  1. /* 抽象组件 */
  2. abstract class Tea {
  3. private String name = "茶";
  4. public String getName() { return name; }
  5. void setName(String name) { this.name = name; }
  6. public abstract int price();
  7. }
  8. /* 具体组件 */
  9. class MilkTea extends Tea {
  10. MilkTea() { setName("奶茶"); }
  11. @Override public int price() { return 5; }
  12. }
  13. class LemonTea extends Tea{
  14. LemonTea() { setName("柠檬茶"); }
  15. @Override public int price() { return 3; }
  16. }
  17. /* 抽象装饰类 */
  18. abstract class Decorator extends Tea{
  19. public abstract String getName();
  20. }
  21. /* 具体装饰类 */
  22. class ZhenZhu extends Decorator {
  23. Tea tea;
  24. ZhenZhu(Tea tea) { this.tea = tea; }
  25. @Override public String getName() { return "珍珠" + tea.getName(); }
  26. @Override public int price() { return 2 + tea.price(); }
  27. }
  28. class YeGuo extends Decorator{
  29. //...
  30. }
  31. class JinJu extends Decorator{
  32. //...
  33. }
  34. class HongDou extends Decorator{
  35. //...
  36. }
  37. /* 客户端调用 */
  38. public class Store {
  39. public static void main(String[] args) {
  40. Tea tea1 = new MilkTea();
  41. System.out.println("你点的是:" + tea1.getName() + " 价格为:" + tea1.price());
  42. Tea tea2 = new LemonTea();
  43. tea2 = new JinJu(tea2);
  44. System.out.println("你点的是:" + tea2.getName() + " 价格为:" + tea2.price());
  45. Tea tea3 = new MilkTea();
  46. tea3 = new ZhenZhu(tea3);
  47. tea3 = new YeGuo(tea3);
  48. tea3 = new HongDou(tea3);
  49. tea3 = new JinJu(tea3);
  50. System.out.println("你点的是:" + tea3.getName() + " 价格为:" + tea3.price());
  51. }
  52. }

输出结果


九.组合模式(Composite Pattern)

部分-整体模式,把具有 相似的一组对象 当做一个对象处理,
用一种 树状的结构组合对象,再提供统一的方法去访问相似的对象,
以此忽略掉对象与对象容器间的差别。

根节点枝结点叶子结点 三个名词需要理解,
类比上图,根节点是菜单,枝结点是饮料菜单和小吃菜单,
叶子结点是奶茶,果汁,手抓饼和鱼蛋!

代码示例

  1. /* 抽象组件 */
  2. abstract class AbstractMenu {
  3. public abstract void add(AbstractMenu menu);
  4. public abstract AbstractMenu get(int index);
  5. public abstract String getString();
  6. }
  7. /* 容器组件 */
  8. class Menu extends AbstractMenu {
  9. private String name;
  10. private String desc;
  11. private List<AbstractMenu> menus = new ArrayList<>();
  12. Menu(String name, String desc) {
  13. this.name = name;
  14. this.desc = desc;
  15. }
  16. @Override public void add(AbstractMenu menu) { menus.add(menu); }
  17. @Override public AbstractMenu get(int index) { return menus.get(index); }
  18. @Override public String getString() {
  19. StringBuilder sb = new StringBuilder("\n【菜单】:" + name + " 信息:" + desc + "\n");
  20. for (AbstractMenu menu: menus) { sb.append(menu.getString()).append("\n"); }
  21. return sb.toString();
  22. }
  23. }
  24. /* 叶子组件 */
  25. class MilkTea extends AbstractMenu {
  26. private String name;
  27. private String desc;
  28. private int price;
  29. MilkTea(String name, String desc, int price) {
  30. this.name = name;
  31. this.desc = desc;
  32. this.price = price;
  33. }
  34. @Override public void add(AbstractMenu menu) { /*未使用*/ }
  35. @Override public AbstractMenu get(int index) { return null; }
  36. @Override public String getString() {
  37. return " - 【奶茶】* " + name + " 标注:" + desc + " 价格:" + price;
  38. }
  39. }
  40. class MilkTea extends AbstractMenu {
  41. //...
  42. }
  43. class HandCake extends AbstractMenu {
  44. //...
  45. }
  46. class FishBall extends AbstractMenu {
  47. //...
  48. }
  49. /* 客户端调用 */
  50. public class Store {
  51. public static void main(String[] args) {
  52. AbstractMenu mainMenu = new Menu("大菜单", "包含所有子菜单");
  53. AbstractMenu drinkMenu = new Menu("饮品菜单", "都是喝的");
  54. AbstractMenu eatMenu = new Menu("小吃菜单", "都是吃的");
  55. AbstractMenu milkTea = new MilkTea("珍珠奶茶", "奶茶+珍珠", 5);
  56. AbstractMenu juice = new Juice("鲜榨猕猴桃枝", "无添加即榨", 8);
  57. AbstractMenu ball = new FishBall("咖喱鱼蛋", "微辣", 6);
  58. AbstractMenu cake = new HandCake("培根手抓饼", "正宗台湾风味", 8);
  59. drinkMenu.add(milkTea);
  60. drinkMenu.add(juice);
  61. eatMenu.add(ball);
  62. eatMenu.add(cake);
  63. mainMenu.add(drinkMenu);
  64. mainMenu.add(eatMenu);
  65. System.out.println(mainMenu.getString());
  66. }
  67. }

输出结果


十.桥接模式(Bridge Pattern)

基于单一职责原则,如果系统中的类存在多个变化的维度
通过该模式可以将这几个维度分离出来, 然后进行独立扩展。
这些分离开来的维度,通过在抽象层持有其他维度的引用来进行关联,
就好像在两个维度间搭了桥一样,所以叫桥接模式。

代码示例(变化的三个维度:配餐,扒类)

  1. /* 抽象部分 */
  2. abstract class Rations {
  3. abstract String rations();
  4. }
  5. /* 扩展抽象部分 */
  6. class Rice extends Rations {
  7. @Override public String rations() { return "饭"; }
  8. }
  9. class Spaghetti extends Rations {
  10. @Override public String rations() { return "意粉"; }
  11. }
  12. /* 实现部分 */
  13. abstract class Steak {
  14. Rations rations;
  15. Steak(Rations rations) { this.rations = rations; }
  16. abstract String sale();
  17. }
  18. /* 具体实现部分 */
  19. class BeefSteak extends Steak{
  20. BeefSteak(Rations rations) { super(rations); }
  21. @Override public String sale() { return "牛扒"+ (rations == null ? "" : rations.rations()); }
  22. }
  23. class PorkSteak extends Steak {
  24. PorkSteak(Rations rations) { super(rations); }
  25. @Override public String sale() { return "猪扒"+ (rations == null ? "" : rations.rations()); }
  26. }
  27. /* 客户端调用 */
  28. public class Restaurant {
  29. public static void main(String[] args) {
  30. System.out.println("\n" + new Date(System.currentTimeMillis()));
  31. System.out.println("==================");
  32. Steak steak1 = new BeefSteak(new Rice());
  33. System.out.println("卖出了一份:" + steak1.sale());
  34. Steak steak2 = new PorkSteak(new Spaghetti());
  35. System.out.println("卖出了一份:" + steak2.sale());
  36. Steak steak3 = new PorkSteak(null);
  37. System.out.println("卖出了一份:" + steak3.sale());
  38. System.out.println("==================");
  39. }

输出结果


十一.外观模式(Facade Pattern)

要求一个子系统的外部与内部的通信必须通过一个统一的对象进行,
外观模式提供一个高层次的接口,使得子系统更易于使用。
(其实就是封装,用于解决类与类间的依赖关系,比如本来是:
玩家依赖于:Q,A,E,R等键位对象,现在变成只依赖与脚本对象
从而降低了类间的耦合度。)

代码示例

  1. /* 子系统 */
  2. class A {
  3. String a() { return "A"; }
  4. }
  5. class Q { /* ... */ }
  6. class Space { /* ... */ }
  7. class LeftClick { /* ... */ }
  8. /* 外观类 */
  9. class JiaoBen {
  10. A a;
  11. Q q;
  12. LeftClick leftClick;
  13. Space space;
  14. JiaoBen() {
  15. a = new A();
  16. leftClick = new LeftClick();
  17. q = new Q();
  18. space = new Space();
  19. }
  20. String 锐雯() {
  21. StringBuilder sb = new StringBuilder();
  22. sb.append(q.q()).append(" + ");
  23. sb.append(space.space()).append(" + ");
  24. sb.append(a.a()).append(" + ");
  25. sb.append(leftClick.leftClick()).append(" + ");
  26. sb.append(q.q()).append(" + ");
  27. sb.append(space.space()).append(" + ");
  28. sb.append(a.a()).append(" + ");
  29. sb.append(leftClick.leftClick()).append(" + ");
  30. sb.append(q.q()).append(" + ");
  31. sb.append(space.space()).append(" + ");
  32. sb.append(a.a()).append(" + ");
  33. sb.append(leftClick.leftClick()).append("\n");
  34. return sb.toString();
  35. }
  36. }
  37. /* 客户端调用 */
  38. public class XLoLer {
  39. public static void main(String[] args) {
  40. JiaoBen jiaoBen = new JiaoBen();
  41. System.out.println("=== 锐雯一键光速QA ===\n" + jiaoBen.锐雯());
  42. }
  43. }

输出结果


十二. 享元模式(Flyweight Pattern)

当存在多个相同对象时,可以使用享元模式减少相同对象创建引起的内存消耗,
提高程序性能。说到共享,还分内部状态与外部状态

内部状态固定不变可共享的的部分,存储在享元对象内部,比如例子中的花色
外部状态可变不可共享的部分,一般由客户端传入享元对象内部,比如例子里的大小

示例代码

  1. /* 抽象对象的父类 */
  2. abstract class Card {
  3. abstract void showCard(String num); //传入外部状态参数,大小
  4. }
  5. /* 具体享元对象 */
  6. public class SpadeCard extends Card{
  7. public SpadeCard() { super(); }
  8. @Override public void showCard(String num) { System.out.println("黑桃:" + num); }
  9. }
  10. public class HeartCard extends Card { /* ... */ }
  11. public class ClubCard extends Card { /* ... */ }
  12. public class DiamondCard extends Card { /* ... */ }
  13. /* 享元工厂 */
  14. public class PokerFactory {
  15. static final int Spade = 0; //黑桃
  16. static final int Heart = 1; //红桃
  17. static final int Club = 2; //梅花
  18. static final int Diamond = 3; //方块
  19. public static Map<Integer, Card> pokers = new HashMap<>();
  20. public static Card getPoker(int color) {
  21. if (pokers.containsKey(color)) {
  22. System.out.print("对象已存在,对象复用...");
  23. return pokers.get(color);
  24. } else {
  25. System.out.print("对象不存在,新建对象...");
  26. Card card;
  27. switch (color) {
  28. case Spade: card = new SpadeCard(); break;
  29. case Heart: card = new HeartCard(); break;
  30. case Club: card = new ClubCard(); break;
  31. case Diamond: card = new DiamondCard(); break;
  32. default: card = new SpadeCard(); break;
  33. }
  34. pokers.put(color,card);
  35. return card;
  36. }
  37. }
  38. /* 客户端调用 */
  39. public class Player {
  40. public static void main(String[] args) {
  41. for (int k = 0; k < 10; k ++){
  42. Card card = null;
  43. //随机花色
  44. switch ((int)(Math.random()*4)) {
  45. case 0: card = PokerFactory.getPoker(PokerFactory.Spade); break;
  46. case 1: card = PokerFactory.getPoker(PokerFactory.Heart); break;
  47. case 2: card = PokerFactory.getPoker(PokerFactory.Club); break;
  48. case 3: card = PokerFactory.getPoker(PokerFactory.Diamond); break;
  49. }
  50. if(card != null) {
  51. //随机大小
  52. int num = (int)(Math.random()*13 + 1);
  53. switch (num) {
  54. case 11: card.showCard("J"); break;
  55. case 12: card.showCard("Q"); break;
  56. case 13: card.showCard("K"); break;
  57. default: card.showCard(num+""); break;
  58. }
  59. }
  60. }
  61. }
  62. }

输出结果


十三.代理模式(Proxy Pattern)

引用代理对象的方式来访问目标对象,简单点说,就是在调用某个对象
时加了一层,然后你可以在这一层做些手脚,比如权限控制,或者附加操作等。

代码示例

  1. /* 抽象对象 */
  2. public interface FetchGoods {
  3. public void fetchShoes();
  4. }
  5. /* 真实对象 */
  6. public class Custom implements FetchGoods{
  7. @Override public void fetchShoes() { System.out.println("拿货"); }
  8. }
  9. /* 代理对象 */
  10. public class Agent implements FetchGoods{
  11. @Override public void fetchShoes() {
  12. Custom custom = new Custom();
  13. custom.fetchShoes();
  14. this.callCustom();
  15. }
  16. public void callCustom() { System.out.println("通知顾客过来取件!"); }
  17. }
  18. /* 客户端调用 */
  19. public class Client {
  20. public static void main(String[] args) {
  21. Agent agent = new Agent();
  22. agent.fetchShoes();
  23. }
  24. }

输出结果


十四.策略模式(Strategy Pattern)

定义一系列的算法,把每个算法封装起来,并使得他们可以相互替换
让算法独立于使用它的客户而变化。 一般用来替换if-else,个人感觉是
面向过程与面向对象思想的过渡。

代码示例:(面向过程与面向对象的简易计算器)

面向过程简易计算器

  1. public class Calculator {
  2. public static void main(String[] args) {
  3. System.out.println("计算:1 + 1 = " + compute("+", 1, 1));
  4. System.out.println("计算:1 - 1 = " + compute("-", 1, 1));
  5. System.out.println("计算:1 * 1 = " + compute("*", 1, 1));
  6. System.out.println("计算:1 ? 1 = " + compute("/", 1, 1));
  7. }
  8. public static float compute(String operator, int first, int second) {
  9. switch (operator) {
  10. case "+": return first + second;
  11. case "-": return first - second;
  12. case "*": return first * second;
  13. case "/": return first / second;
  14. default: return 0.0f;
  15. }
  16. }
  17. }

面向对象(策略模式)简易计算器

  1. /* 抽象策略类 */
  2. public interface Compute {
  3. String compute(int first, int second);
  4. }
  5. /* 具体策略类 */
  6. public class Add implements Compute{
  7. @Override public String compute(int first, int second) {
  8. return "输出结果:" + first + " + " + second + " = " + (first + second);
  9. }
  10. }
  11. public class Sub implements Compute{ /* ... */ }
  12. public class Mul implements Compute{ /* ... */ }
  13. public class Div implements Compute{ /* ... */ }
  14. /* 上下文环境类 */
  15. public class Context {
  16. private Compute compute;
  17. public Context() { compute = new Add(); }
  18. public void setCompute(Compute compute) { this.compute = compute; }
  19. public void calc(int first, int second) {
  20. System.out.println(compute.compute(first, second));
  21. }
  22. }
  23. /* 客户端调用 */
  24. public class Client {
  25. public static void main(String[] args) {
  26. Context context = new Context();
  27. context.setCompute(new Add());
  28. context.calc(1,2);
  29. context.setCompute(new Sub());
  30. context.calc(3,4);
  31. context.setCompute(new Mul());
  32. context.calc(5,6);
  33. context.setCompute(new Div());
  34. context.calc(7,8);
  35. }
  36. }

输出结果

      


十五.观察者模式(Observer Pattern)

定义对象见的一种一对多依赖关系,当一个对象的状态发生改变时
所有依赖于它的对象都得到通知并且自动更新

当对象间存在一对多关系的时候,使用观察者模式,当一个对象
(被观察者)被修改时,会自动通知它的依赖对象们(观察者)。

这个模式基本都应该用过和听说过,关于概念就不多解释了,有兴趣看原文去~

代码示例

  1. /* 抽象观察者 —— 昆虫类 */
  2. public interface Insect {
  3. void work();
  4. void unWork();
  5. }
  6. /* 具体观察者 —— 蜜蜂类 */
  7. public class Bee implements Insect{
  8. private int bId; //蜜蜂编号
  9. public Bee(int bId) { this.bId = bId; }
  10. @Override public void work() { System.out.println("蜜蜂"+ bId + "采蜜"); }
  11. @Override public void unWork() { System.out.println("蜜蜂"+ bId + "回巢"); }
  12. }
  13. /* 抽象被观察者(注册,移除,通知观察者) —— 植物类 */
  14. public interface Plant {
  15. public void registerInsect(Insect insect);
  16. public void unregisterInsect(Insect insect);
  17. public void notifyInsect(boolean isOpen);
  18. }
  19. /* 具体被观察者(定义一个集合存储观察者,实现相关方法) —— 花朵类 */
  20. public class Flower implements Plant {
  21. private boolean state;
  22. private List<Insect> insects = new ArrayList<>();
  23. public boolean isState() { return state; }
  24. @Override public void registerInsect(Insect insect) { insects.add(insect); }
  25. @Override public void unregisterInsect(Insect insect) { insects.remove(insect); }
  26. @Override public void notifyInsect(boolean isOpen) {
  27. state = isOpen;
  28. if (state) {
  29. System.out.println("花开");
  30. for (Insect insect : insects) { insect.work(); }
  31. } else {
  32. System.out.println("花闭");
  33. for (Insect insect : insects) { insect.unWork(); }
  34. }
  35. }
  36. }
  37. /* 客户端调用 */
  38. public class Client {
  39. public static void main(String[] args) {
  40. //创建被观察者
  41. Plant flower = new Flower();
  42. //创建三个观察者
  43. Insect bee1 = new Bee(1);
  44. Insect bee2 = new Bee(2);
  45. Insect bee3 = new Bee(3);
  46. //注册观察者
  47. flower.registerInsect(bee1);
  48. flower.registerInsect(bee2);
  49. flower.registerInsect(bee3);
  50. //改变被观察者状态,先开后合
  51. flower.notifyInsect(true);
  52. System.out.println("=== 太阳从东边到西边... ===");
  53. flower.notifyInsect(false);
  54. //最后解除注册
  55. flower.unregisterInsect(bee1);
  56. flower.unregisterInsect(bee2);
  57. flower.unregisterInsect(bee3);
  58. }
  59. }

输出结果


观察者模式的推与拉

推方式

被观察者对象向观察者推送主题的详细信息,不管观察者是否需要
推送的信息通常是被观察者对象的全部或部分数据。(上面的例子就是推方式)

拉方式

被观察者对象再通知观察者时,只传递少量信息。如果观察者需要更
详细的信息,可以主动到被观察者中获取,相当于观察者从被观察者
中拉取数据。一般的套路是:把主题对象自身通过update()方法传递
给观察者
,然后观察者在需要获取的时候,通过这个引用来获取

代码示例

微信订阅了某个公众号,当有更新的时候会推送提醒,收到提醒后,
我们需要进入公众号然后点击对应信息查看详细内容。

  1. /* 抽象观察者 —— 用户 */
  2. public interface User {
  3. public void update(OfficialAccount account);
  4. }
  5. /* 具体观察者 —— Android读者 */
  6. public class AndroidDev implements User {
  7. @Override public void update(OfficialAccount account) {
  8. System.out.println("读者查看公众号更新信息:" + ((CoderPig)account).getMsg());
  9. }
  10. }
  11. /* 抽象被观察者 —— 公众号 */
  12. public abstract class OfficialAccount {
  13. private List<User> userList = new ArrayList<>();
  14. public void registerUser(User user) { userList.add(user); }
  15. public void unregisterUser(User user) { userList.remove(user); }
  16. public void notifyUse() {
  17. for (User user: userList) {
  18. user.update(this);
  19. }
  20. }
  21. }
  22. /* 具体被观察者 —— CoderPig公众号 */
  23. public class CoderPig extends OfficialAccount {
  24. private String msg; //更新的文章
  25. public String getMsg() { return msg; }
  26. public void update(String msg) {
  27. this.msg = msg;
  28. System.out.println("公众号更新了文章:" + msg);
  29. this.notifyUse(); //通知用户有更新
  30. }
  31. }
  32. /* 客户端调用 */
  33. public class Client {
  34. public static void main(String[] args) {
  35. OfficialAccount account = new CoderPig();
  36. User user = new AndroidDev();
  37. account.registerUser(user);
  38. ((CoderPig)account).update("《观察者模式》");
  39. account.unregisterUser(user);
  40. }
  41. }

输出结果


Java中对观察者模式的支持(在Java.util中)

口诀被观察者实现继承Observable观察者实现Observer接口
然后有个很关键的地方:当通知变化的时候,需要调用setChange()方法!!!!
不用自己另外去写抽象观察者或抽象被观察者类,直接继承就能玩了,
另外有一点要注意的是:Java内置的观察者模式通知多个观察者的顺序
不是固定的,如果对通知顺序有所依赖的话,还是得自己实现观察者
模式!

代码示例

  1. /* 具体观察者 */
  2. public class AndroidDev implements Observer{
  3. @Override public void update(Observable o, Object object) {
  4. System.out.println("收到公众号更新信息:" + object);
  5. }
  6. }
  7. /* 具体被观察者 */
  8. public class CoderPig extends Observable {
  9. private String msg;
  10. public String getMsg() { return msg; }
  11. public void update(String msg) {
  12. this.msg = msg;
  13. System.out.println("公众号更新了文章:" + msg);
  14. this.setChanged(); //这句话必不可少,通知改变
  15. this.notifyObservers(this.msg); //这里用推的方式
  16. }
  17. }
  18. /* 客户端调用 */
  19. public class Client {
  20. public static void main(String[] args) {
  21. CoderPig coderPig = new CoderPig();
  22. AndroidDev dev = new AndroidDev();
  23. coderPig.addObserver(dev);
  24. coderPig.update("Java中对观察者模式的支持~");
  25. coderPig.deleteObserver(dev);
  26. }
  27. }

输出结果


十六.迭代器模式(Iterator Pattern)

提供一种方法顺序访问一个容器(聚合)对象中各个元素,而又不暴露该对象的内部表示。


添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注