组合模式（Composite pattern）
组合模式看起来就像对象组的树形结构，一个对象里面包含一个或一组其他的对象。它是属于结构型模式。 例如，一个公司包括很多个部门，每个部门又包括很多人，这个用数据结构来表示就是树形结构，实际上也是用到来组合模式，多个人组成一个部门，多个部门组成一个公司。
例如，我们用下面这个公司、部门、员工的例子来更好的理解组合模式。
class Company { private String name; private List depts;}class Dept { private String name; private List users;}class User { private String name;}复制代码 装饰模式（Decorator pattern）
装饰器设计模式允许我们动态地向对象添加功能和行为，而不会影响同一类中其他现有对象的行为。并且可以根据我们的要求和选择将此自定义功能应用于单个对象。 假如使用继承来扩展类的行为，这发生在编译期，该类的所有实例都获得扩展行为。
装饰器设计模式的特点： 它允许我们在运行时向对象（而不是类）添加功能。 它是一种结构模式，它为现有类提供了一个包装器。 它使用抽象类或接口与组合来实现包装器。 它创建装饰器类，它包装原始类并通过保持类方法的签名不变来提供其他功能。 它最常用于应用单一责任原则，因为我们将功能划分为具有独特关注区域的类。
例如，我们用下面这个画图形的例子来更好的理解装饰模式。
//定义一个形状的接口public interface Shape { void draw(); void resize();}//一个画圆的实现public class Circle implements Shape { @Override public void draw() { System.out.println("Drawing Circle"); } @Override public void resize() { System.out.println("Resizing Circle"); }}//一个画矩形的实现public class Rectangle implements Shape { @Override public void draw() { System.out.println("Drawing Rectangle"); } @Override public void resize() { System.out.println("Resizing Rectangle"); }}//定义一个形状的装饰器抽象类，并用组合模式定义一个形状的属性public abstract class ShapeDecorator implements Shape { protected Shape decoratedShape; public ShapeDecorator(Shape decoratedShape) { super(); this.decoratedShape = decoratedShape; }}//颜色的枚举public enum Color { RED, GREEN, BLUE}//线条样式的枚举public enum LineStyle { SOLID, DASH, DOT}//定义一个填充颜色的实现类实现装饰器，并重写 draw() 方法，resize() 方法我们可以保持不变，也可以自定义，看使用场景public class FillColorDecorator extends ShapeDecorator { protected Color color; public FillColorDecorator(Shape decoratedShape, Color color) { super(decoratedShape); this.color = color; } @Override public void draw() { decoratedShape.draw(); System.out.println("Fill Color: " + color); } @Override public void resize() { decoratedShape.resize(); }}//定义一个线条样式的实现类实现装饰器，并重写 draw() 方法，resize() 方法我们可以保持不变，也可以自定义，看使用场景public class LineStyleDecorator extends ShapeDecorator { protected LineStyle style; public LineStyleDecorator(Shape decoratedShape, LineStyle style) { super(decoratedShape); this.style = style; } @Override public void draw() { decoratedShape.draw(); System.out.println("Line Style: " + style); } // @Override public void resize() { decoratedShape.resize(); }}//使用装饰器模式public class Client { public static void main(String[] args) { //在使用时可以任意组装，提升代码灵活性和扩展性。 Shape circle = new FillColorDecorator(new LineStyleDecorator(new Circle(), LineStyle.DASH), Color.RED); circle.draw(); }}复制代码 外观模式（Facade Pattern）
它提供了一个可以访问系统的接口，这个接口里面的实现可能很复杂，调用了其他多个接口，我们并不知道它里面的具体实现，隐藏了系统的复杂性。它属于结构型模式。
它的优点：
1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。它的缺点：
不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。以旅行社网站为例，它可以预订酒店和航班，我们来更好的理解下这个模式。
//提供酒店相关的接口public class HotelBooker{ public ArrayList getHotelNamesFor(Date from, Date to) { //返回该时间段有效的酒店 }}//提供航班相关的接口public class FlightBooker{ public ArrayList getFlightsFor(Date from, Date to) { //返回该时间段有效的航班 }}//提供一个旅行对外的接口，一次返回酒店和航班信息public class TravelFacade{ private HotelBooker hotelBooker; private FlightBooker flightBooker; public void getFlightsAndHotels(Date from, Data to) { ArrayList flights = flightBooker.getFlightsFor(from, to); ArrayList hotels = hotelBooker.getHotelsFor(from, to); }}//调用旅行外观模式public class Client{ public static void main(String[] args) { TravelFacade facade = new TravelFacade(); facade.getFlightsAndHotels(from, to); }}复制代码 享元模式（Flyweight Pattern）
享元模式主要用于减少创建对象的数量，以减少内存占用和提高性能。使许多细粒度对象的重用，使得大量对象的利用更加有效。它属于结构型模式。
它的优点：
大大减少对象的创建，降低系统的内存，使效率提高。它的缺点：
因为一个对象大家共享，最好就不要有状态区分，假如有状态的话， 需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。例如，我们用一个画线条的例子来更好的理解这个模式。
//定义一个画线条的接口public interface LineFlyweight{ public Color getColor(); public void draw(Point location);}//定义一个画线条的实现public class Line implements LineFlyweight{ private Color color; public Line(Color c){ color = c; } public Color getColor(){ return color; } public void draw(Point location){ //实现 }}//定一个画线条的工厂类，根据颜色来获取线条，并且把不同颜色的线存储在一个 pool 中，方便下次直接使用public class LineFlyweightFactory{ private List pool; public LineFlyweightFactory(){ pool = new ArrayList (); } public LineFlyweight getLine(Color c){ //循环检查这个颜色的线是否存在，存在直接返回 for(LineFlyweight line: pool){ if(line.getColor().equals(c)){ return line; } } //假如不存在，就创建一个放入这个 pool 中，方便下次直接使用 LineFlyweight line = new Line(c); pool.add(line); return line; }}//调用享元模式public class Client{ public static void main(String[] args) { //调用 LineFlyweightFactory factory = new LineFlyweightFactory(); LineFlyweight line = factory.getLine(Color.RED); LineFlyweight line2 = factory.getLine(Color.RED); line.draw(new Point(100, 100)); line2.draw(new Point(200, 100)); }}复制代码 代理模式（Proxy Pattern）
它通过一个代理类对外提供访问，代理类在真正调用实现类。对外部来说，并不知道真正实现类的详情，提高类系统的安全性。我们可以在代理类里做一系列拦截，把异常的请求都提前处理掉，扩展性很高。它属于结构型模式。
它的优点：
1、职责清晰。 2、高扩展性。 3、更安全。它的缺点：
1、由于在客户端和真实主题之间增加了代理对象，因此可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。例如，我们用下面这个代理显示图片的例子来更好的理解代理模式。
//定义的图片接口public interface Image{ public void displayImage();}//真正的实现类public class RealImage implements Image{ public RealImage(URL url) { //加载这个图片 loadImage(url); } public void displayImage() { //显示这个图片 } private void loadImage(URL url) { }}//代理类public class ProxyImage implements Image{ private URL url; public ProxyImage(URL url) { this.url = url; } //this method delegates to the real image public void displayImage() { RealImage real = new RealImage(url); real.displayImage(); }}//使用代理模式public class Client { public static void main(String[] args) { Image image = new ProxyImage("test.png"); image.display(); }}复制代码 代理模式分为静态代理和动态代理，静态代理的真正实现类是提前写好并且编译好的，动态代理的真正实现类是运行是生成并且编译的，上面的例子使用的是静态代理。
动态代理又分为 JDK动态代理 和 CGLIB动态代理，JDK动态代理是基于接口的动态代理，CGLIB动态代理是基于类的代理。有兴趣的可以找下相关资料。责任链模式（Chain of Responsibility Pattern）
责任链模式用于管理对象之间的算法，关系和责任，通过将多个不同处理对象链接在一起处理请求，降低耦合度，提高系统灵活性。它属于行为型模式。
它的优点：
1、降低耦合度。 2、简化了对象。 3、增强给对象指派职责的灵活性。 4、增加新的请求处理类很方便。它的缺点：
1、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 2、可能不容易观察运行时的特征，不方便排错。例如，我们用下面这个记录日志的例子来更好的理解责任链模式。
//定义一个抽象的日志接口，并且提供一个可以设置下一个处理日志对象的方法public abstract class AbstractLogger { public static int INFO = 1; public static int DEBUG = 2; public static int ERROR = 3; protected int level; //责任链中的下一个元素 protected AbstractLogger nextLogger; public void setNextLogger(AbstractLogger nextLogger){ this.nextLogger = nextLogger; } public void logMessage(int level, String message){ if(this.level <= level){ write(message); } if(nextLogger !=null){ nextLogger.logMessage(level, message); } } //抽象方法 abstract protected void write(String message);}//定义一个标准日志的实现类public class ConsoleLogger extends AbstractLogger { public ConsoleLogger(int level){ this.level = level; } @Override protected void write(String message) { System.out.println("Standard Console::Logger: " + message); }}//定义一个错误日志的实现类public class ErrorLogger extends AbstractLogger { public ErrorLogger(int level){ this.level = level; } @Override protected void write(String message) { System.out.println("Error Console::Logger: " + message); }}//定义一个文件日志的实现类public class FileLogger extends AbstractLogger { public FileLogger(int level){ this.level = level; } @Override protected void write(String message) { System.out.println("File::Logger: " + message); }}//使用责任链模式public class Client { //设置责任链的调用顺序 private static AbstractLogger getChainOfLoggers(){ AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR); AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG); AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO); errorLogger.setNextLogger(fileLogger); fileLogger.setNextLogger(consoleLogger); return errorLogger; } public static void main(String[] args) { AbstractLogger loggerChain = getChainOfLoggers(); loggerChain.logMessage(AbstractLogger.INFO, "info level information."); loggerChain.logMessage(AbstractLogger.DEBUG, "debug level information."); loggerChain.logMessage(AbstractLogger.ERROR, "error information."); }}复制代码 命令模式（Command Pattern）
命令模式是请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。它属于行为型模式。
它的优点：
1、降低了系统耦合度。 2、新的命令可以很容易添加到系统中去。它的缺点：
使用命令模式可能会导致某些系统有过多的具体命令类。例如，我们用下面这个开关灯的例子来更好的理解命令模式。
// 定义执行命令接口public interface Command{ public void execute();}//开灯命令实现类public class LightOnCommand implements Command{ Light light; public LightOnCommand(Light light){ this.light = light; } public void execute(){ light.switchOn(); }}//关灯命令实现类public class LightOffCommand implements Command{ Light light; public LightOffCommand(Light light){ this.light = light; } public void execute(){ light.switchOff(); }}//真正开关灯的类public class Light{ private boolean on; public void switchOn(){ on = true; } public void switchOff(){ on = false; }}//根据不同命令执行开关灯public class RemoteControl{ private Command command; public void setCommand(Command command){ this.command = command; } public void pressButton(){ command.execute(); }}//调用命令模式public class Client{ public static void main(String[] args){ RemoteControl control = new RemoteControl(); Light light = new Light(); Command lightsOn = new LightsOnCommand(light); Command lightsOff = new LightsOffCommand(light); //设置开灯命令来开灯 control.setCommand(lightsOn); control.pressButton(); //设置关灯命令来关灯 control.setCommand(lightsOff); control.pressButton(); }}复制代码 解释器模式（Interpreter Pattern）
解释器模式是给定一种语言，定义其语法以及使用该语法来表示语言中句子的解释器。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。它属于行为型模式。
它的优点：
1、可扩展性比较好，灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单语法。它的缺点：
1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。 4、解释器模式采用递归调用方法。例如，我们用下面这个简单规则表达式的例子来更好的理解解释器模式。
//定义一个表达式接口public interface Expression { public boolean interpret(String context);}//定义一个基本规则的实现，输入的内容包含初始化的内容时，返回 truepublic class TerminalExpression implements Expression { private String data; public TerminalExpression(String data){ this.data = data; } @Override public boolean interpret(String context) { if(context.contains(data)){ return true; } return false; }}//定义一个或者规则的实现，输入的内容包含初始化时任意一个内容时，返回 true，否则 falsepublic class OrExpression implements Expression { private Expression expr1 = null; private Expression expr2 = null; public OrExpression(Expression expr1, Expression expr2) { this.expr1 = expr1; this.expr2 = expr2; } @Override public boolean interpret(String context) { return expr1.interpret(context) || expr2.interpret(context); }}//定义一个并且规则的实现，输入的内容同时包含初始化时两个内容时，返回 true，否则 falsepublic class AndExpression implements Expression { private Expression expr1 = null; private Expression expr2 = null; public AndExpression(Expression expr1, Expression expr2) { this.expr1 = expr1; this.expr2 = expr2; } @Override public boolean interpret(String context) { return expr1.interpret(context) && expr2.interpret(context); }}//调用规则表达式public class Client { //规则：Robert 和 John 是男性，输入只要满足其中一个规则就行 public static Expression getMaleExpression(){ Expression robert = new TerminalExpression("Robert"); Expression john = new TerminalExpression("John"); return new OrExpression(robert, john); } //规则：Julie 是一个已婚的女性，输入只要满足两个规则 public static Expression getMarriedWomanExpression(){ Expression julie = new TerminalExpression("Julie"); Expression married = new TerminalExpression("Married"); return new AndExpression(julie, married); } public static void main(String[] args) { Expression isMale = getMaleExpression(); Expression isMarriedWoman = getMarriedWomanExpression(); System.out.println("John is male? " + isMale.interpret("John")); System.out.println("Julie is a married women? " + isMarriedWoman.interpret("Married Julie")); }}复制代码 最后，还是那句话，每种设计模式有它自己的好处，也有它的坏处。在写代码时，多思考，想好在写，免得返工，先从思维方式上改变。使用单一原则，一个类，一个方法只做一件事情，这样方便维护，耦合低，可扩展。
PS:
清山绿水始于尘，博学多识贵于勤。 微信公众号：「清尘闲聊」。 欢迎一起谈天说地，聊代码。