讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源，我们看下面的图：
6、适配器模式（Adapter）
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题
核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里，看代码：
public class Source { public void method1(){ System.out.println("this is origin method"); } }
目标接口时Targetable
public interface Targettable { /** * 与原类的方法相同 */ void method1(); void method2(); }Adapter
public class Adapter extends Source implements Targettable { @Override public void method2() { System.out.println("this is new class method2"); } } /** * 有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里 */ System.out.println("----------------类适配器-----------------------"); Targettable classAdapter = new Adapter();//类适配器 classAdapter.method1(); classAdapter.method2();这样Targetable接口的实现类就具有了Source类的功能。
对象的适配器模式
基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。（这里常说就是组合）
只需要修改Adapter类的源码即可：
package adapter.objectadapter; import adapter.classadapter.Source; import adapter.classadapter.Targettable; import java.sql.Wrapper; public class ObjectAdapter implements Targettable{ private Source source; public ObjectAdapter(Source source){ super(); this.source = source; } @Override public void method1() { source.method1(); } @Override public void method2() { System.out.println("this is the object new method!"); } }测试类
System.out.println("----------------对象适配器-----------------------"); /** * 有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里 * 这里是通过实例 */ Source source = new Source();//对象适配器 Targettable targettable = new ObjectAdapter(source); targettable.method1(); targettable.method2();第三种适配器模式是接口的适配器模式，接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
package adapter.interfaceadapter; public interface Sourceable { public void method1(); public void method2(); }接口适配
public abstract class InterfaceAdapter implements Sourceable { @Override public void method2() { System.out.println("the sourceable interface's first Su2!"); } @Override public void method1() { System.out.println("the sourceable interface's first Su1!"); } }只实现想要的方法
public class SourceAble1 extends InterfaceAdapter { @Override public void method1() { System.out.println("this is extends new sour1"); } } public class SourceAble2 extends InterfaceAdapter { @Override public void method2() { System.out.println("this is extends new sour2"); } } 测试类 System.out.println("----------------接口适配器-----------------------"); /** * 当不希望实现一个接口中所有的方法时 * ，可以创建一个抽象类Wrapper，实现所有方法 * 我们写别的类的时候，继承抽象类即可。 */ Sourceable sourceable1 = new SourceAble1(); Sourceable sourceable2 = new SourceAble2(); sourceable1.method1(); sourceable1.method2(); sourceable2.method1(); sourceable2.method2();总结一下三种适配器模式的应用场景：
类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。（组合）
接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。
7、装饰模式（Decorator）
顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，关系图如下
Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：
package decorator; public class Source implements Sourceable { @Override public void method() { System.out.println("this is nodecorator method"); } } public interface Sourceable { public void method(); } /** * 装饰器模式的应用场景： 1、需要扩展一个类的功能。 2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。） 缺点：产生过多相似的对象，不易排错！ */ public class Decorator implements Sourceable { private Sourceable source; public Decorator(Sourceable source){ super(); this.source = source; } @Override public void method() { System.out.println("before decorator!"); source.method(); System.out.println("after decorator!"); } } 测试类 public class Test { public static void main(String[] args) { Sourceable source = new Source(); Sourceable obj = new Decorator(source); obj.method(); } }测试结果
8、代理模式（Proxy）
其实每个模式名称就表明了该模式的作用，代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法
这里又分静态代理和动态代理（只是实现的方式不一样）
需要被代理的类和静态代理类
package proxy; public class Source implements SourceAble { @Override public void method() { System.out.println("this is source method"); } } package proxy; /** * 代理模式的应用场景： 如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法： 1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。 2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。 使用代理模式，可以将功能划分的更加清晰，有助于后期维护！ */ public class Proxy implements SourceAble{ private Source source; public Proxy(){ super(); this.source = new Source(); } @Override public void method() { before(); source.method(); atfer(); } private void atfer() { System.out.println("after proxy!"); } private void before() { System.out.println("before proxy!"); } }jdk的动态代理需实现接口
package proxy; public interface SourceAble { void method(); }通过MyInvocationHandler 进行增强
package proxy.dynamic; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class MyInvocationHandler implements InvocationHandler { private Object target; //们既然要做代理，我们必须知道我们是给谁做代理，这里的obj就是被代理者。 MyInvocationHandler() { super(); } public MyInvocationHandler(Object target) { super(); this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object result = method.invoke(target,args); atfer(); return result; } private void atfer() { System.out.println("after proxy!"); } private void before() { System.out.println("before proxy!"); } }测试类 测试结果
package proxy; import proxy.dynamic.MyInvocationHandler; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class Test { public static void main(String[] args) { //静态代理测试 SourceAble sourceAble = new Proxy(); sourceAble.method(); System.out.println("-----------动态代理--------------"); //动态代理测试 SourceAble sourceAble1 = new Source();//被代理的对象 InvocationHandler invocationHandler = new MyInvocationHandler(sourceAble1); //代理对象 SourceAble dynamicProxy = (SourceAble) java.lang.reflect.Proxy.newProxyInstance(sourceAble1.getClass().getClassLoader(),sourceAble1.getClass().getInterfaces(),invocationHandler); dynamicProxy.method(); } }before proxy!this is source methodafter proxy!-----------动态代理--------------before proxy!this is source methodafter proxy!
代理模式跟装饰器模式在这里代码实现基本一样，因为都是从对象的适配器模式演变过来的
https://www.cnblogs.com/zhengbin/p/5618564.html 区别的话这里不细讲 大概找了一个可参考的链接有兴趣可以点开看看
9、外观模式（Facade）
外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度（在Tomcat里就用到了挺多这个模式）
（我们以一个计算机的启动过程为例）
接口
package facade; public interface HardWare { void startup(); void shutdown(); }
实现类
package facade; public class CPU implements HardWare { @Override public void startup() { System.out.println("cpu startup!"); } @Override public void shutdown() { System.out.println("cpu shutdown!"); } } package facade; public class Disk implements HardWare { @Override public void startup() { System.out.println("disk startup!"); } @Override public void shutdown() { System.out.println("disk shutdown!"); } } package facade; public class Memory implements HardWare { @Override public void startup() { System.out.println("memory startup!"); } @Override public void shutdown() { System.out.println("memory shutdown!"); } }外观类
package facade; /** * 外观模式是为了解决类与类之家的依赖关系的， * 像spring一样，可以将类和类之间的关系配置到配置文件中 * 而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度 */ public class Computer { private CPU cpu; private Memory memory; private Disk disk; public Computer(){ cpu = new CPU(); memory = new Memory(); disk = new Disk(); } public void startup(){ System.out.println("start the computer!"); cpu.startup(); memory.startup(); disk.startup(); System.out.println("start computer finished!"); } public void shutdown(){ System.out.println("begin to close the computer!"); cpu.shutdown(); memory.shutdown(); disk.shutdown(); System.out.println("computer closed!"); } }测试类（用户）
package facade; /** * 外观模式是为了解决类与类之家的依赖关系的， * 像spring一样，可以将类和类之间的关系配置到配置文件中 * 而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度 */ public class User{ public static void main(String[] args) { Computer computer = new Computer(); computer.startup(); computer.shutdown(); } } start the computer! cpu startup! memory startup! disk startup! start computer finished! begin to close the computer! cpu shutdown! memory shutdown! disk shutdown!computer closed!
如果我们没有Computer类，那么，CPU、Memory、Disk他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来其他类的修改，这不是我们想要看到的，有了Computer类，他们之间的关系被放在了Computer类里，这样就起到了解耦的作用，这，就是外观模式！
10、桥接模式（Bridge）
桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。
接口
package bridge; public interface Driver { String getConnection(); }实现类：
package bridge; public class MysqlDriver implements Driver { public String url; private String username = "root"; private String password = "root"; private String driverClassName = "com.mysql.jdbc.Driver"; @Override public String getConnection() { return "mysql connection"; } } package bridge; public class OracleDriver implements Driver { @Override public String getConnection() { return "oracle connection"; } } package bridge; public class DB2Driver implements Driver { @Override public String getConnection() { return "db2 connection"; } }定义一个桥，持有Driver的实例
package bridge; public abstract class IDriverManager { private Driver driver; public void setDriver(Driver driver) { this.driver = driver; } public Driver getDriver(){ return this.driver; } public String getConnetion(){ return this.driver.getConnection(); } } package bridge; /** * 桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动， * 原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了 */ public class DriverManager extends IDriverManager{ @Override public String getConnetion() { return getDriver().getConnection(); } }
测试类
package bridge; /** * get set 方法改变类里面的字段 能更换多个实例 如果放在构造函数只能一个对象只持有一种实例 */ public class Test { public static void main(String[] args) { IDriverManager driverManager = new DriverManager(); MysqlDriver mysqlDriver = new MysqlDriver(); driverManager.setDriver(mysqlDriver); System.out.println(driverManager.getConnetion()); OracleDriver oracleDriver = new OracleDriver(); driverManager.setDriver(oracleDriver); System.out.println(driverManager.getConnetion()); } }
结果： mysql connection oracle connection
一个驱动DriverManager，每个数据库提供各自的实现，这样就做到了连接不同的数据库
11、组合模式（Composite）
组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便
package composite; /** * 一颗树 根节点 */ public class Tree { TreeNode root = null; public Tree(String name) { root = new TreeNode(name); } } package composite; import java.util.Enumeration; import java.util.Vector; /** * 叶子节点 */ public class TreeNode { private String name; private TreeNode parent; private Vector<TreeNode> children = new Vector<TreeNode>(); public TreeNode(String name){ this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public TreeNode getParent() { return parent; } public void setParent(TreeNode parent) { this.parent = parent; } //添加孩子节点 public void add(TreeNode node){ children.add(node); node.setParent(this); } //删除孩子节点 public void remove(TreeNode node){ children.remove(node); node.setParent(null); } //取得孩子节点 public Enumeration<TreeNode> getChildren(){ return children.elements(); } }
测试类
package composite; /** * 组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便 */ public class Test { public static void main(String[] args) { Tree tree = new Tree("A");//根节点 TreeNode nodeB = new TreeNode("B"); TreeNode nodeC = new TreeNode("C"); nodeB.add(nodeC); tree.root.add(nodeB); System.out.println("build the tree finished!"); } }输出：build the tree finished! 就是一个根节点A 加入了叶子节点B 叶子节点B又加入了叶子节点C
使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。
12、享元模式（Flyweight）
享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。FlyWeightFactory负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight是超类。一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。
package flyweight.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.Vector; /** * FlyWeightFactory(ConnectionPool)负责创建和管理享元单元，当一个客户端请求时， 工厂需要检查当前对象池中是否有符合条件的对象， * 如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight(Connection)是超类。 * 一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点， * 我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname * 这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理， * 建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据， * 在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。 */ public class ConnectionPool { private Vector<Connection> pool; /*公有属性*/ private String url = "jdbc:mysql://localhost:3306/test"; private String username = "root"; private String password = "root"; private String driverClassName = "com.mysql.jdbc.Driver"; private int poolSize = 100; private static ConnectionPool instance = null; Connection conn = null; /*构造方法，做一些初始化工作*/ private ConnectionPool() { pool = new Vector<Connection>(poolSize); for (int i = 0; i < poolSize; i++) { try { Class.forName(driverClassName); conn = (Connection) DriverManager.getConnection(url, username, password); pool.add(conn); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } } } /* 返回连接到连接池 */ public synchronized void release() { pool.add(conn); } /* 返回连接池中的一个数据库连接 */ public synchronized Connection getConnection() { if (pool.size() > 0) { Connection conn = pool.get(0); pool.remove(conn); return conn; } else { return null; } } }
