行为型模式-策略模式 （1）概述该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变换不会影响客户的使用；它属于对象行为模式，通过对算法进行封装，把使用算法的责任和算法的实现分开，并委派给不同的对象对这些算法进行管理（2）结构抽象策略类：该角色给出所有的策略类所需的接口具体策略类：实现抽象策略定义的接口，提供具体的算法实现或行为环境类：持有一个策略类的引用，供客户端调用（3）案例以促销活动为例抽象策略类public interface Strategy { /** * 展示促销活动 */ void show(); }具体策略类public class StrategyA implements Strategy { @Override public void show() { System.out.println("促销活动A"); } } public class StrategyB implements Strategy { @Override public void show() { System.out.println("促销活动B"); } } public class StrategyC implements Strategy { @Override public void show() { System.out.println("促销活动C"); } }环境类public class SalesMan { private Strategy strategy; public SalesMan(Strategy strategy) { this.strategy = strategy; } public Strategy getStrategy() { return strategy; } public void setStrategy(Strategy strategy) { this.strategy = strategy; } /** * 促销员展示促销活动 */ public void salesManShow() { strategy.show(); } }Clientpublic class Client { public static void main(String[] args) { //促销活动A SalesMan salesMan = new SalesMan(new StrategyA()); salesMan.salesManShow(); System.out.println("======================="); //促销活动B salesMan.setStrategy(new StrategyB()); salesMan.salesManShow(); System.out.println("======================="); //促销活动C salesMan.setStrategy(new StrategyC()); salesMan.salesManShow(); } }（4）优缺点策略类之间可以自由切换新增策略时增加对应的具体策略类即可，复合开闭原则在一定程度上减少了条件选择语句的使用客户端必须知道所有的策略类，并自行决定使用哪一个可能产生很多的具体策略类（5）使用场景系统中需要动态的在几种算法中选择一种时一个类定义了多种行为，且这些行为在这个类的操作中以多个条件语句的形式出现时，可将每个分支条件移入各自对应的策略类中系统中的算法各自独立，且要求对客户隐藏实现的细节时多个类只区别在表现型为不同，可选择策略模式，在运行时动态选择具体要执行的行为

行为型模式-模板方法 行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务，涉及算法和对象间职责的分配分为：模板方法、策略模式、命令模式、责任链模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式、解释器模式；其中模板方法、解释器模式属于类行为模式，其他属于对象行为模式模板方法（1）概述定义一个操作中的算法骨架，并将其中的一些步骤延迟到子类中执行，使得子类可以在不改变主干步骤的情况下重定义该算法的某些特定步骤（2）结构抽象类：负责给出一个算法的轮廓和骨架，由一个模板方法和若干个基本方法构成模板方法：定义算法的骨架，按指定的顺序调用其包含的基本方法基本方法：实现算法的各个步骤（模板方法的组成部分）抽象方法：由抽象类声明，由其具体子类实现具体方法：由抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承钩子方法：在抽象类中已实现，包括用于判断的逻辑方法和需要子类重写的空方法两个部分具体子类：实现抽象类中定义的抽象方法和钩子方法钩子方法一般是用于做判断的逻辑方法，类名为 isXXX，返回值类型为 boolean（3）案例以炒菜为例抽象类public abstract class AbstractClass { /** * 模板方法 */ public final void cookProcess() { pourOil(); heatOil(); pourVegetable(); pourSauce(); fry(); } public void pourOil() { System.out.println("倒油"); } public void heatOil() { System.out.println("热油"); } /** * 倒蔬菜 */ public abstract void pourVegetable(); /** * 放调料 */ public abstract void pourSauce(); public void fry() { System.out.println("准备完毕，开始炒菜"); } }具体类public class ConcreteClass_BaoCai extends AbstractClass { @Override public void pourVegetable() { System.out.println("放入包菜"); } @Override public void pourSauce() { System.out.println("放入辣椒"); } } public class ConcreteClass_CaiXin extends AbstractClass { @Override public void pourVegetable() { System.out.println("放入菜心"); } @Override public void pourSauce() { System.out.println("放入蒜瓣"); } }Clientpublic class Client { public static void main(String[] args) { //炒包菜 ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai(); baoCai.cookProcess(); } }（4）优缺点代码复用，相同的代码可以放到抽象父类中，不同的代码放在对应的子类中实现了反向控制，通过父类调用其子类的操作，并通过子类的不同实现扩展不同的行为，复合开闭原则对每个不同的实现都需要定义一个子类，导致类的个数及系统设计难度的增加反向控制降低了代码的易读性（5）使用场景算法的整体步骤固定，但其中的个别部分易变时，使用模板方法可将易变的部分抽象出来，由其子类实现需要通过子类决定父类中的某个步骤是否执行，实现子类对父类的反向控制

结构型模式-享元模式 （1）概述运用共享技术来有效支持大量细粒度对象的复用，通过共享已经存在的对象来大幅度减少需要创建对象的数量、避免大量相似对象的开销，从而提高系统资源的利用率（2）结构享元模式存在两种状态：内部状态，即不会随着环境的改变而改变的可共享部分外部状态，内部状态反之享元模式实现的要领就是区分应用中的这两种状态，并将外部状态外部化包含的角色：抽象享元角色：通常是一个接口或抽象类，声明具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）具体享元角色：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间（可以结合单例模式来设计具体享元类）非享元角色：并不是所有抽象享元类的子类都需要被共享不能被共享的子类可以设计为非共享具体享元类，当需要它时，可以直接通过实例化创建享元工厂角色：负责创建和管理享元角色，当客户对象请求一个享元对象时，享元工厂检查系统中是否存在该对象，有则直接提供，反之则创建一个对应的新的享元对象（3）案例以俄罗斯方块为例：抽象享元角色public abstract class AbstractBox { /** * 获取图像 * * @return */ public abstract String getShape(); public void display(String color) { System.out.println("方块形状：" + getShape() + "，颜色：" + color); } }具体享元角色public class IBox extends AbstractBox { @Override public String getShape() { return "I"; } } public class LBox extends AbstractBox { @Override public String getShape() { return "L"; } } public class OBox extends AbstractBox { @Override public String getShape() { return "O"; } }享元工厂public class BoxFactory { private HashMap<String, AbstractBox> map; private BoxFactory() { map = new HashMap<>(); map.put("I", new IBox()); map.put("L", new LBox()); map.put("O", new OBox()); } /** * 饿汉式 * * @return */ public static BoxFactory getInstance() { return factory; } private static BoxFactory factory = new BoxFactory(); /** * 根据名称获取图形 * * @param key * @return */ public AbstractBox getShape(String key) { return map.get(key); } }Clientpublic class Client { public static void main(String[] args) { //获取I型盒子 AbstractBox boxI = BoxFactory.getInstance().getShape("I"); boxI.display("灰色"); //获取L型盒子 AbstractBox boxL = BoxFactory.getInstance().getShape("L"); boxL.display("蓝色"); //获取O型盒子 AbstractBox boxO1 = BoxFactory.getInstance().getShape("O"); boxO1.display("绿色"); //获取O图形 AbstractBox boxO2 = BoxFactory.getInstance().getShape("O"); boxO2.display("红色"); //验证两个O型盒子是否为同一对象 System.out.println("两个O型盒子是否为同一对象:" + (boxO1 == boxO2)); } }（4）优缺点极大地减少了内存中相同或相似对象的数量，节约了资源享元模式中的外部状态相对独立，且不影响内部状态为了使对象可以共享，需要装享元对象的部分状态外部化，增加了系统的复杂度（5）使用场景系统中有大量相同或相似的对象对象的大部分状态都可以外部化，可以将这些外部状态传入对象中在使用该模式时需要维护对应的享元对象存储池，需要耗费一定的资源，因此，须在多次重复使用享元对象且必要的情况下才使用该模式

结构型模式-组合模式 （1）概述组合模式又称为部分整体模式，是用于把一组相似的对象当作一个单一的对象，该模式依据树形结构来组合对象，用来表示部分以及整体层次（2）结构抽象根节点：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性树枝节点：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成树结构叶子节点：其下再无分支，是系统层次遍历的最小单位（3）案例以树形菜单为例：抽象根节点public abstract class MenuComponent { protected String name; protected int level; /** * 添加菜单 * * @param menuComponent */ public void add(MenuComponent menuComponent) { throw new UnsupportedOperationException(); } /** * 移除菜单 * * @param menuComponent */ public void remove(MenuComponent menuComponent) { throw new UnsupportedOperationException(); } /** * 查询子菜单 * * @param index * @return */ public MenuComponent getChild(int index) { throw new UnsupportedOperationException(); } /** * 查询菜单或菜单项的名称 * * @return */ public String getName() { return name; } /** * 打印菜单（包含子菜单和子菜单项） */ public abstract void print(); }树枝节点public class Menu extends MenuComponent { private List<MenuComponent> menuComponentList = new ArrayList<>(); public Menu(String name, int level) { this.name = name; this.level = level; } @Override public void add(MenuComponent menuComponent) { menuComponentList.add(menuComponent); } @Override public void remove(MenuComponent menuComponent) { menuComponentList.remove(menuComponent); } @Override public MenuComponent getChild(int index) { return menuComponentList.get(index); } @Override public void print() { for (int i = 0; i < level; i++) { System.out.print(" "); } //打印菜单名称 System.out.println(name); //打印子菜单/子菜单项名称 for (MenuComponent menuComponent : menuComponentList) { menuComponent.print(); } } } public class MenuItem extends MenuComponent { public MenuItem(String name, int level) { this.name = name; this.level = level; } @Override public void print() { for (int i = 0; i < level; i++) { System.out.print(" "); } //打印菜单项名称 System.out.println(name); } }测试public class Client { public static void main(String[] args) { //创建菜单 MenuComponent menue1 = new Menu("菜单一", 2); menue1.add(new MenuItem("1", 3)); menue1.add(new MenuItem("2", 3)); menue1.add(new MenuItem("3", 3)); MenuComponent menue2 = new Menu("菜单二", 2); menue2.add(new MenuItem("1", 3)); menue2.add(new MenuItem("2", 3)); menue2.add(new MenuItem("3", 3)); MenuComponent menue3 = new Menu("菜单三", 2); menue3.add(new MenuItem("1", 3)); menue3.add(new MenuItem("2", 3)); menue3.add(new MenuItem("3", 3)); MenuComponent menue4 = new Menu("菜单四", 2); menue4.add(new MenuItem("1", 3)); menue4.add(new MenuItem("2", 3)); menue4.add(new MenuItem("3", 3)); //将二级菜单添加到一级菜单中 MenuComponent component = new Menu("根菜单", 1); component.add(menue1); component.add(menue2); component.add(menue3); component.add(menue4); //打印菜单 component.print(); } }（4）分类透明组合模式在该模式中，抽象根节点角色声明了所有用于管理成员对象的方法，以此确保所有的构建类都有相同的接口，即标准组合模式该模式不够安全，因为叶子对象和容器对象有着本质上的区别，叶子对象不可能有下级节点（即不包含成员对象）因此提供的 add()、remove()方法是没有意义的，在运行时调用由于未提供相应的错误处理代码而出错安全组合模式该模式中的抽象根节点角色未提供任何管理成员对象的方法，而是在树枝节点类中声明并实现这些方法，它的缺点是不够透明，因为叶子对象和容器对象具有不同的方法，容器对象中用于管理成员对象的方法没有在抽象根节点中定义，客户端不能实现相应的抽象编程，必须区别对待叶子对象和容器对象（5）优缺点可以清楚定义分层次的复杂对象，表示对象的全部或部分层次，让客户端忽略了层次的差异，便于对整个层次结构的管理客户端可以一致的使用一个组合结构或其中的单个对象，无需关心处理的是单个对象还是整个组合结构新增/删除节点符合开闭原则通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但整个管理的过程并不复杂（6）使用场景多用于需要使用树形结构的场景

结构型模式-外观模式 （1）概述外观模式又称门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更容易被访问，外部应用程序无需关心内部子系统的具体细节，它是“迪米特法则”的典型应用（2）结构外观角色：为多个子系统对外提供一个共同的接口子系统角色：实现系统的部分功能，客户可以通过外观角色访问它（3）案例以智能音箱控制家电为例外观角色public class SmartApplicationFacade { private Light light; private TV tv; private AirCondition airCondition; public SmartApplicationFacade() { light = new Light(); tv = new TV(); airCondition = new AirCondition(); } public void say(String message) { if (message.contains("开")) { on(); } else if (message.contains("关")) { off(); } else { System.out.println("主人，你在说什么？"); } } private void on() { //一键打开 light.on(); tv.on(); airCondition.on(); } private void off() { light.off(); tv.off(); airCondition.off(); } }子系统角色public class TV { public void on() { System.out.println("开电视"); } public void off() { System.out.println("关电视"); } } public class Light { public void on() { System.out.println("开灯"); } public void off() { System.out.println("关灯"); } } public class AirCondition { public void on() { System.out.println("开空调"); } public void off() { System.out.println("关空调"); } }测试public class Client { public static void main(String[] args) { SmartApplicationFacade smartApplicationFacade = new SmartApplicationFacade(); smartApplicationFacade.say("开灯"); System.out.println("=========================="); smartApplicationFacade.say("关电视"); } }（4）优缺点降低了子系统与客户端之间的耦合度对客户屏蔽了子系统组件不符合开闭原则（5）使用场景对分层系统构建时，使用外观模式定义每层的入口点可以简化子系统之间的依赖关系当一个复杂系统的子系统很多时，外观模式可以提供简单的接口供外界访问当客户端与多个子系统之间存在很大的联系时，引入外观模式可将他们分离从而提高子系统的独立性和可移植性

结构型模式-桥接模式 （1）概述将抽象与实现分离，使它们可以独立变化，用组合关系代替继承关系来实现，从而降低抽象和实现这两个可变维度的耦合度（2）结构抽象化角色：定义抽象类，并包含一个对实现化角色的引用扩展抽象化角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法实现化角色：定义实现化角色的接口（也可以是抽象类），供扩展抽象化角色调用具体实现化角色：给出实现化角色接口的具体实现（3）案例以视频播放器为例（可以在不同操作系统上播放多种格式的视频文件）实现化角色public interface VideoFile { /** * 视频解码 * * @param fileName */ void decode(String fileName); }具体实现化角色public class MkvFile implements VideoFile { @Override public void decode(String fileName) { System.out.println("播放mkv视频文件：" + fileName); } } public class Mp4File implements VideoFile { @Override public void decode(String fileName) { System.out.println("播放mp4视频文件：" + fileName); } }抽象化角色public abstract class OperationSystem { //声明VideoFile变量 protected VideoFile videoFile; public OperationSystem(VideoFile videoFile) { this.videoFile = videoFile; } /** * 播放视频 * * @param fileName */ public abstract void play(String fileName); }扩展抽象化角色public class Windows extends OperationSystem { public Windows(VideoFile videoFile) { super(videoFile); } @Override public void play(String fileName) { videoFile.decode(fileName); } } public class Mac extends OperationSystem { public Mac(VideoFile videoFile) { super(videoFile); } @Override public void play(String fileName) { videoFile.decode(fileName); } }（4）优缺点提高了系统的可扩展性，在两个变化的维度中任意扩展一个维度，都不需要修改原有系统实现细节对客户透明（5）使用场景当一个类存在两个独立变化的维度，且这两个维度都需要扩展时当一个系统不希望使用继承或因多层次继承导致类爆炸时当一个系统需要在构建的抽象化角色和具体化角色之间增加更多的灵活性时（避免在两个层次之间建立静态的继承联系，可通过桥接模式（聚合引用方式）使它们在抽象层建立一个关联关系）

结构型模式-装饰者模式 （1）概述在不改变现有对象结构的情况下，动态的给该对象增加额外的职责或功能（2）结构抽象构建角色：定义一个抽象接口以规范准备接收附加责任的对象具体构建角色：实现抽象构建，通过装饰角色为其添加一些职责抽象装饰角色：继承或实现抽象构建，并包含具体构建的实例，可以通过其子类扩展具体构建的功能具体装饰角色：实现抽象装饰的相关方法，并给具体构建对象添加附加的职责或功能（3）案例以快餐店为例：抽象构建角色public abstract class FastFood { private float price; private String desc; public FastFood() { } public FastFood(float price, String desc) { this.price = price; this.desc = desc; } public float getPrice() { return price; } public void setPrice(float price) { this.price = price; } public String getDesc() { return desc; } public void setDesc(String desc) { this.desc = desc; } /** * 计算价格 * * @return */ public abstract float cost(); }具体构建角色public class FriedNoodles extends FastFood { public FriedNoodles() { super(8, "炒面"); } @Override public float cost() { return super.getPrice(); } } public class FriedRice extends FastFood { public FriedRice() { super(10, "炒饭"); } @Override public float cost() { return super.getPrice(); } }抽象装饰角色public abstract class Garnish extends FastFood { private FastFood fastFood; public Garnish(FastFood fastFood, float price, String desc) { super(price, desc); this.fastFood = fastFood; } public FastFood getFastFood() { return fastFood; } public void setFastFood(FastFood fastFood) { this.fastFood = fastFood; } }具体装饰角色public class Egg extends Garnish { public Egg(FastFood fastFood) { super(fastFood, 1, "鸡蛋"); } @Override public float cost() { //价格：鸡蛋 + 快餐的价格 return super.getPrice() + super.getFastFood().cost(); } @Override public String getDesc() { //描述：鸡蛋 + 具体的快餐 return super.getDesc() + super.getFastFood().getDesc(); } } public class Bacon extends Garnish { public Bacon(FastFood fastFood) { super(fastFood, 2, "培根"); } @Override public float cost() { //价格：培根 + 快餐的价格 return super.getPrice() + super.getFastFood().cost(); } @Override public String getDesc() { //描述：培根 + 具体的快餐 return super.getDesc() + super.getFastFood().getDesc(); } }测试public class Client { public static void main(String[] args) { //炒饭 FastFood food = new FriedRice(); System.out.println(food.getDesc() + " " + food.cost() + "元"); //再加一个鸡蛋 food = new Egg(food); //System.out.println(food.getDesc() + " " + food.cost() + "元"); //加培根 food = new Bacon(food); System.out.println(food.getDesc() + " " + food.cost() + "元"); } }（4）优缺点装饰者模式可以带来比继承更加灵活的扩展功能，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任装饰类和被装饰类可以各自独立发展，不会产生耦合，装饰者模式是继承的一个替代模式，可以动态扩展一个实现类的功能（5）使用场景当不能采用继承的方式对系统进行扩充或采用继承不利于系统扩展和维护时类中存在大量独立的扩展，使用继承可能会造成类爆炸时被 final 修饰的类在不影响其他对象的情况下，以动态、透明的方式给单个对象添加功能或职责当对象的功能要求动态添加，动态移除时（6）静态代理与装饰者模式的区别相同点：都要实现与目标类相同的业务接口在两个类中都要声明目标对象都可以在不修改目标对象的前提下进行功能增强不同点：目的不同：装饰者增强目标对象静态代理保护和隐藏目标对象获取目标对象构建的地方不同装饰者中的目标对象由外界传递（通过构造方法或set赋值）静态代理的目标对象在代理类内部创建，以此来完成隐藏和保护

结构型模式-适配器模式 （1）概述将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类能一起工作，分为类适配器模式（耦合度高）和对象适配器模式（2）结构目标接口：当前系统业务所期待的接口（抽象类或接口）适配者类：它是被访问和适配的现存组件库中的组件接口适配器类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者（3）类适配器模式实现方式：定义一个适配器类来实现当前系统的业务接口（即目标接口），同时又继承现有组件库中已经存在的组件（即适配者类）以读卡器为例：目标接口public interface SDCard { /** * 读数据 * * @return */ String readSD(); /** * 写数据 * * @param msg */ void writeSD(String msg); }具体的SD卡类public class SDCardImpl implements SDCard { @Override public String readSD() { return "Read data from SDCard: Hello World"; } @Override public void writeSD(String msg) { System.out.println("Write data to SDCard:" + msg); } }public class Computer { public String readSD(SDCard sdCard) { if (sdCard == null) { throw new NullPointerException("SDCard can not be null"); } return sdCard.readSD(); } }适配者类接口public interface TFCard { /** * 读数据 * * @return */ String readTF(); /** * 写数据 * * @param msg */ void writeTF(String msg); }适配者类public class TFCardImpl implements TFCard { @Override public String readTF() { return "Read data from TFCard: Hello World"; } @Override public void writeTF(String msg) { System.out.println("Write data to TFCard:" + msg); } }适配器类public class SDAdapterTF extends TFCardImpl implements SDCard { @Override public String readSD() { System.out.println("Adapter read from TFCard"); return super.readTF(); } @Override public void writeSD(String msg) { System.out.println("Adapter write to TFCard"); super.writeTF(msg); } }测试public class Client { public static void main(String[] args) { //计算机 Computer computer = new Computer(); //读取SDCard中的数据 String msg = computer.readSD(new SDCardImpl()); System.out.println(msg); System.out.println("===================================="); //使用该电脑读取TFCard中的数据 //定义适配器类 String msg1 = computer.readSD(new SDAdapterTF()); System.out.println(msg1); } }类适配器模式违背了合成复用原则，在客户类有一个明确的接口规范的情况下可用，反之不可用（4）对象适配器模式实现方式：采用将现有组件库中已实现的组件引入适配器类中，该类同时实现当前系统的业务接口读卡器案例改进：目标接口public interface SDCard { /** * 读数据 * * @return */ String readSD(); /** * 写数据 * * @param msg */ void writeSD(String msg); }具体的SD卡类public class SDCardImpl implements SDCard { @Override public String readSD() { return "Read data from SDCard: Hello World"; } @Override public void writeSD(String msg) { System.out.println("Write data to SDCard:" + msg); } }public class Computer { public String readSD(SDCard sdCard) { if (sdCard == null) { throw new NullPointerException("SDCard can not be null"); } return sdCard.readSD(); } }适配者类接口public interface TFCard { /** * 读数据 * * @return */ String readTF(); /** * 写数据 * * @param msg */ void writeTF(String msg); }适配者类public class TFCardImpl implements TFCard { @Override public String readTF() { return "Read data from TFCard: Hello World"; } @Override public void writeTF(String msg) { System.out.println("Write data to TFCard:" + msg); } }适配器类public class SDAdapterTF implements SDCard { //适配者类 private TFCard tfCard; public SDAdapterTF(TFCard tfCard) { this.tfCard = tfCard; } @Override public String readSD() { System.out.println("Adapter read from TFCard"); return tfCard.readTF(); } @Override public void writeSD(String msg) { System.out.println("Adapter write to TFCard"); tfCard.writeTF(msg); } }测试public class Client { public static void main(String[] args) { //计算机 Computer computer = new Computer(); //读取SDCard中的数据 String msg = computer.readSD(new SDCardImpl()); System.out.println(msg); System.out.println("===================================="); //使用该电脑读取TFCard中的数据 String msg1 = computer.readSD(new SDAdapterTF(new TFCardImpl())); System.out.println(msg1); } }对象适配器模式解决了类适配器模式中存在的问题；同时还有接口适配器模式，当不希望实现一个接口中的所有方法时，可以定义一个 Adapter 抽象类，实现目标接口中的所有方法，适配器类再继承该抽象类，根据需要选择所需的方法（5）应用场景原系统存在满足新系统功能需求的类，但存在接口不一致的问题时使用第三方提供的组件，但所需组件接口与自己接口定义不同的时候