Java 之23种设计模式解析

8、代理模式(Proxy)

其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?因为你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因为律师在法律方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图:

根据上文的阐述,代理模式就比较容易的理解了,我们看下代码:

[java] view plaincopy

  1. publicinterface Sourceable {  
  2. public void method();  
  3. }  

[java] view plaincopy

  1. publicclass Source implements Sourceable {  
  2.  
  3. @Override  
  4. public void method() {  
  5. out.println(“the original method!”);  
  6. }  
  7. }  

[java] view plaincopy

  1. publicclass Proxy implements Sourceable {  
  2.  
  3. private Source source;  
  4. public Proxy(){  
  5. super();  
  6. this.source = new Source();  
  7. }  
  8. @Override  
  9. public void method() {  
  10. before();  
  11. method();  
  12. atfer();  
  13. }  
  14. private void atfer() {  
  15. out.println(“after proxy!”);  
  16. }  
  17. private void before() {  
  18. out.println(“before proxy!”);  
  19. }  
  20. }  

测试类:

[java] view plaincopy

  1. publicclass ProxyTest {  
  2.  
  3. public static void main(String[] args) {  
  4. Sourceable source = new Proxy();  
  5. method();  
  6. }  
  7.  
  8. }  

输出:

before proxy!
the original method!
after proxy!

代理模式的应用场景:

如果已有的方法在使用的时候需要对原有的方法进行改进,此时有两种办法:

1、修改原有的方法来适应。这样违反了“对扩展开放,对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法,且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式,可以将功能划分的更加清晰,有助于后期维护!

 

 

9、外观模式(Facade)

外观模式是为了解决类与类之家的依赖关系的,像spring一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,该模式中没有涉及到接口,看下类图:(我们以一个计算机的启动过程为例)

我们先看下实现类:

[java] view plaincopy

  1. publicclass CPU {  
  2.  
  3. public void startup(){  
  4. out.println(“cpu startup!”);  
  5. }  
  6.  
  7. public void shutdown(){  
  8. out.println(“cpu shutdown!”);  
  9. }  
  10. }  

[java] view plaincopy

  1. publicclass Memory {  
  2.  
  3. public void startup(){  
  4. out.println(“memory startup!”);  
  5. }  
  6.  
  7. public void shutdown(){  
  8. out.println(“memory shutdown!”);  
  9. }  
  10. }  

[java] view plaincopy

  1. publicclass Disk {  
  2.  
  3. public void startup(){  
  4. out.println(“disk startup!”);  
  5. }  
  6.  
  7. public void shutdown(){  
  8. out.println(“disk shutdown!”);  
  9. }  
  10. }  

[java] view plaincopy

  1. publicclass Computer {  
  2. private CPU cpu;  
  3. private Memory memory;  
  4. private Disk disk;  
  5.  
  6. public Computer(){  
  7. cpu = new CPU();  
  8. memory = new Memory();  
  9. disk = new Disk();  
  10. }  
  11.  
  12. public void startup(){  
  13. out.println(“start the computer!”);  
  14. startup();  
  15. startup();  
  16. startup();  
  17. out.println(“start computer finished!”);  
  18. }  
  19.  
  20. public void shutdown(){  
  21. out.println(“begin to close the computer!”);  
  22. shutdown();  
  23. shutdown();  
  24. shutdown();  
  25. out.println(“computer closed!”);  
  26. }  
  27. }  

User类如下:

[java] view plaincopy

  1. publicclass User {  
  2.  
  3. public static void main(String[] args) {  
  4. Computer computer = new Computer();  
  5. startup();  
  6. shutdown();  
  7. }  
  8. }  

输出:

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提供统一接口,每个数据库提供各自的实现,用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图:

实现代码:

先定义接口:

[java] view plaincopy

  1. publicinterface Sourceable {  
  2. public void method();  
  3. }  

分别定义两个实现类:

[java] view plaincopy

  1. publicclass SourceSub1 implements Sourceable {  
  2.  
  3. @Override  
  4. public void method() {  
  5. out.println(“this is the first sub!”);  
  6. }  
  7. }  

[java] view plaincopy

  1. publicclass SourceSub2 implements Sourceable {  
  2.  
  3. @Override  
  4. public void method() {  
  5. out.println(“this is the second sub!”);  
  6. }  
  7. }  

定义一个桥,持有Sourceable的一个实例:

[java] view plaincopy

  1. publicabstract class Bridge {  
  2. private Sourceable source;  
  3.  
  4. public void method(){  
  5. method();  
  6. }  
  7.  
  8. public Sourceable getSource() {  
  9. return source;  
  10. }  
  11.  
  12. public void setSource(Sourceable source) {  
  13. this.source = source;  
  14. }  
  15. }  

[java] view plaincopy

  1. publicclass MyBridge extends Bridge {  
  2. public void method(){  
  3. getSource().method();  
  4. }  
  5. }  

测试类:

[java] view plaincopy

  1. publicclass BridgeTest {  
  2.  
  3. public static void main(String[] args) {  
  4.  
  5. Bridge bridge = new MyBridge();  
  6.  
  7. /*调用第一个对象*/  
  8. Sourceable source1 = new SourceSub1();  
  9. setSource(source1);  
  10. method();  
  11.  
  12. /*调用第二个对象*/  
  13. Sourceable source2 = new SourceSub2();  
  14. setSource(source2);  
  15. method();  
  16. }  
  17. }  

output:

this is the first sub!
this is the second sub!

这样,就通过对Bridge类的调用,实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用。接下来我再画个图,大家就应该明白了,因为这个图是我们JDBC连接的原理,有数据库学习基础的,一结合就都懂了。

11、组合模式(Composite)

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便,看看关系图:

直接来看代码:

[java] view plaincopy

  1. publicclass TreeNode {  
  2.  
  3. private String name;  
  4. private TreeNode parent;  
  5. private Vector<TreeNode> children = new Vector<TreeNode>();  
  6.  
  7. public TreeNode(String name){  
  8. this.name = name;  
  9. }  
  10.  
  11. public String getName() {  
  12. return name;  
  13. }  
  14.  
  15. public void setName(String name) {  
  16. this.name = name;  
  17. }  
  18.  
  19. public TreeNode getParent() {  
  20. return parent;  
  21. }  
  22.  
  23. public void setParent(TreeNode parent) {  
  24. this.parent = parent;  
  25. }  
  26.  
  27. //添加孩子节点  
  28. public void add(TreeNode node){  
  29. add(node);  
  30. }  
  31.  
  32. //删除孩子节点  
  33. public void remove(TreeNode node){  
  34. remove(node);  
  35. }  
  36.  
  37. //取得孩子节点  
  38. public Enumeration<TreeNode> getChildren(){  
  39. returnelements();  
  40. }  
  41. }  

[java] view plaincopy

  1. publicclass Tree {  
  2.  
  3. TreeNode root = null;  
  4.  
  5. public Tree(String name) {  
  6. root = new TreeNode(name);  
  7. }  
  8.  
  9. public static void main(String[] args) {  
  10. Tree tree = new Tree(“A”);  
  11. TreeNode nodeB = new TreeNode(“B”);  
  12. TreeNode nodeC = new TreeNode(“C”);  
  13.  
  14. add(nodeC);  
  15. root.add(nodeB);  
  16. out.println(“build the tree finished!”);  
  17. }  
  18. }  

使用场景:将多个对象组合在一起进行操作,常用于表示树形结构中,例如二叉树,数等。

 

 

12、享元模式(Flyweight)

享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。

FlyWeightFactory负责创建和管理享元单元,当一个客户端请求时,工厂需要检查当前对象池中是否有符合条件的对象,如果有,就返回已经存在的对象,如果没有,则创建一个新对象,FlyWeight是超类。一提到共享池,我们很容易联想到Java里面的JDBC连接池,想想每个连接的特点,我们不难总结出:适用于作共享的一些个对象,他们有一些共有的属性,就拿数据库连接池来说,url、driverClassName、username、password及dbname,这些属性对于每个连接来说都是一样的,所以就适合用享元模式来处理,建一个工厂类,将上述类似属性作为内部数据,其它的作为外部数据,在方法调用时,当做参数传进来,这样就节省了空间,减少了实例的数量。

看个例子:

看下数据库连接池的代码:

[java] view plaincopy

  1. publicclass ConnectionPool {  
  2.  
  3. private Vector<Connection> pool;  
  4.  
  5. /*公有属性*/  
  6. private String url = “jdbc:mysql://localhost:3306/test”;  
  7. private String username = “root”;  
  8. private String password = “root”;  
  9. private String driverClassName = “com.mysql.jdbc.Driver”;  
  10.  
  11. private int poolSize = 100;  
  12. private static ConnectionPool instance = null;  
  13. Connection conn = null;  
  14.  
  15. /*构造方法,做一些初始化工作*/  
  16. private ConnectionPool() {  
  17. pool = new Vector<Connection>(poolSize);  
  18.  
  19. for (int i = 0; i < poolSize; i++) {  
  20. try {  
  21. forName(driverClassName);  
  22. conn = DriverManager.getConnection(url, username, password);  
  23. add(conn);  
  24. catch (ClassNotFoundException e) {  
  25. printStackTrace();  
  26. catch (SQLException e) {  
  27. printStackTrace();  
  28. }  
  29. }  
  30. }  
  31.  
  32. /* 返回连接到连接池 */  
  33. public synchronized void release() {  
  34. add(conn);  
  35. }  
  36.  
  37. /* 返回连接池中的一个数据库连接 */  
  38. public synchronized Connection getConnection() {  
  39. if (pool.size() > 0) {  
  40. Connection conn = pool.get(0);  
  41. remove(conn);  
  42. return conn;  
  43. else {  
  44. return null;  
  45. }  
  46. }  
  47. }  

 

通过连接池的管理,实现了数据库连接的共享,不需要每一次都重新创建连接,节省了数据库重新创建的开销,提升了系统的性能!

 

 C、关系模式(11种)

先来张图,看看这11中模式的关系:

第一类:通过父类与子类的关系进行实现。

第二类:两个类之间。

第三类:类的状态。

第四类:通过中间类

父类与子类关系

13、策略模式(strategy)

策略模式定义了一系列算法,并将每个算法封装起来,使他们可以相互替换,且算法的变化不会影响到使用算法的客户。需要设计一个接口,为一系列实现类提供统一的方法,多个实现类实现该接口,设计一个抽象类(可有可无,属于辅助类),提供辅助函数,关系图如下:

图中ICalculator提供同意的方法,
AbstractCalculator是辅助类,提供辅助方法,接下来,依次实现下每个类:

首先统一接口:

[java] view plaincopy

  1. publicinterface ICalculator {  
  2. public int calculate(String exp);  
  3. }  

辅助类:

[java] view plaincopy

  1. publicabstract class AbstractCalculator {  
  2.  
  3. public int[] split(String exp,String opt){  
  4. String array[] = exp.split(opt);  
  5. int arrayInt[] = new int[2];  
  6. arrayInt[0] = Integer.parseInt(array[0]);  
  7. arrayInt[1] = Integer.parseInt(array[1]);  
  8. return arrayInt;  
  9. }  
  10. }  

三个实现类:

[java] view plaincopy

  1. publicclass Plus extends AbstractCalculator implements ICalculator {  
  2.  
  3. @Override  
  4. public int calculate(String exp) {  
  5. int arrayInt[] = split(exp,”\\+”);  
  6. return arrayInt[0]+arrayInt[1];  
  7. }  
  8. }  

[java] view plaincopy

  1. publicclass Minus extends AbstractCalculator implements ICalculator {  
  2.  
  3. @Override  
  4. public int calculate(String exp) {  
  5. int arrayInt[] = split(exp,”-“);  
  6. return arrayInt[0]-arrayInt[1];  
  7. }  
  8.  
  9. }  

[java] view plaincopy

  1. publicclass Multiply extends AbstractCalculator implements ICalculator {  
  2.  
  3. @Override  
  4. public int calculate(String exp) {  
  5. int arrayInt[] = split(exp,”\\*”);  
  6. return arrayInt[0]*arrayInt[1];  
  7. }  
  8. }  

简单的测试类:

[java] view plaincopy

  1. publicclass StrategyTest {  
  2.  
  3. public static void main(String[] args) {  
  4. String exp = “2+8”;  
  5. ICalculator cal = new Plus();  
  6. int result = cal.calculate(exp);  
  7. out.println(result);  
  8. }  
  9. }  

输出:10

策略模式的决定权在用户,系统本身提供不同算法的实现,新增或者删除算法,对各种算法做封装。因此,策略模式多用在算法决策系统中,外部用户只需要决定用哪个算法即可。

 

14、模板方法模式(Template Method)

解释一下模板方法模式,就是指:一个抽象类中,有一个主方法,再定义1…n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用,先看个关系图:

就是在AbstractCalculator类中定义一个主方法calculate,calculate()调用spilt()等,Plus和Minus分别继承AbstractCalculator类,通过对AbstractCalculator的调用实现对子类的调用,看下面的例子:

[java] view plaincopy

  1. publicabstract class AbstractCalculator {  
  2.  
  3. /*主方法,实现对本类其它方法的调用*/  
  4. public final int calculate(String exp,String opt){  
  5. int array[] = split(exp,opt);  
  6. return calculate(array[0],array[1]);  
  7. }  
  8.  
  9. /*被子类重写的方法*/  
  10. abstract public int calculate(int num1,int num2);  
  11.  
  12. public int[] split(String exp,String opt){  
  13. String array[] = exp.split(opt);  
  14. int arrayInt[] = new int[2];  
  15. arrayInt[0] = Integer.parseInt(array[0]);  
  16. arrayInt[1] = Integer.parseInt(array[1]);  
  17. return arrayInt;  
  18. }  
  19. }  

[java] view plaincopy

  1. publicclass Plus extends AbstractCalculator {  
  2.  
  3. @Override  
  4. public int calculate(int num1,int num2) {  
  5. return num1 + num2;  
  6. }  
  7. }  

测试类:

[java] view plaincopy

  1. publicclass StrategyTest {  
  2.  
  3. public static void main(String[] args) {  
  4. String exp = “8+8”;  
  5. AbstractCalculator cal = new Plus();  
  6. int result = cal.calculate(exp, “\\+”);  
  7. out.println(result);  
  8. }  
  9. }  

我跟踪下这个小程序的执行过程:首先将exp和”\\+”做参数,调用AbstractCalculator类里的calculate(String,String)方法,在calculate(String,String)里调用同类的split(),之后再调用calculate(int ,int)方法,从这个方法进入到子类中,执行完return num1 + num2后,将值返回到AbstractCalculator类,赋给result,打印出来。正好验证了我们开头的思路。

 

类之间的关系

 

本教程由尚硅谷教育大数据研究院出品,如需转载请注明来源,欢迎大家关注尚硅谷公众号(atguigu)了解更多。


上一篇:
下一篇:
关于尚硅谷
教育理念
名师团队
学员心声
资源下载
视频下载
资料下载
工具下载
加入我们
招聘岗位
岗位介绍
招贤纳师
联系我们
电话:010-56253825
邮箱:info@atguigu.com
地址:北京市昌平区宏福科技园综合楼6层(北京校区)

 深圳市宝安区西部硅谷大厦B座C区一层(深圳校区)

上海市松江区谷阳北路166号大江商厦6层(上海校区)