五种常用的设计模式

来源：互联网发布：以太坊 json rpc教程编辑：程序博客网时间：2024/05/17 23:39

Java设计模式中有23中模式，下面只对其中五种常用的设计模式进行介绍：

1.单例模式（有的书上说叫单态模式其实都一样）：

该模式主要目的是使内存中保持1个对象。

具体看看下面的例子：

   1. package org.sp.singleton;
   2.
   3. //方法一
   4. public class Singleton {
   5. //将自身的实例对象设置为一个属性,并加上Static和final修饰符
   6. private static final Singleton instance = new Singleton();
   7. //将构造方法设置成私有形式
   8. private Singleton() {
   9. }
10. //通过一个静态方法向外界提供这个类的实例
11. public static Singleton getInstance() {
12.    return instance;
13. }}//方法二
14. class Singleton2 {
15.
16. private static Singleton2 instance2 = null;
17.
18. public static synchronized Singleton2 getInstance() {
19.
20.    if (instance2 == null)
21.     instance2 = new Singleton2();
22.    return instance2;
23. }
24. }

注：这二个Java设计模式实现了一样的功能，但个人推荐采用第一种方法。

2.工厂模式

该Java设计模式主要功能是统一提供实例对象的引用。

具体看看下面的例子：

   1. //*************//
   2. public class Factory{
   3. public ClassesDao getClassesDao(){
   4.    ClassesDao cd = new ClassesDaoImpl();
   5.    return cd;
   6. }
   7. }
   8.   interface ClassesDao{
   9. public String getClassesName();
10.
11. }
12.   class ClassesDaoImpl implements ClassesDao {
13. public String getClassesName(){
14.    System.out.println("A班");
15. }
16. }
17.   class test
18. {
19. public static void main(String[] args){
20.    Factory f = new Factory();
21.    f.getClassesDao().getClassesName();
22. }
23. }

这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用

3.建造模式

该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。

4.门面模式

这个模式个人感觉像是Service层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Service层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。

具体看看这个例子：

   1. view plaincopy to clipboardprint?
   2. interface ClassesDao{
   3. public String getClassesName();
   4.
   5. }
   6.   class ClassesDaoImpl implements ClassesDao {
   7. public String getClassesName(){
   8.    return "A班";
   9. }
10. }
11.   interface ClassesDao2{
12. public String getClassesName();
13.
14. }
15.   class ClassesDaoImpl2 implements ClassesDao {
16. public String getClasses2Name(){
17.    return "B班";
18. }
19. }
20.   class ServiceManager
21. {
22. private ClassesDao cd = new ClassesDaoImpl();
23. private ClassesDao2 cd2 = new ClassesDaoImpl2();
24. public void printOut(){
25.    System.out.println(cd.getClassesName()+"   "+cd2.getClassesName());
26. }
27. }; interface ClassesDao{
28. public String getClassesName();
29.
30. }class ClassesDaoImpl implements ClassesDao {
31. public String getClassesName(){
32.    return "A班";
33. }
34. }interface ClassesDao2{
35. public String getClassesName();
36.
37. }class ClassesDaoImpl2 implements ClassesDao {
38. public String getClasses2Name(){
39.    return "B班";
40. }
41. }class ServiceManager
42. {
43. private ClassesDao cd = new ClassesDaoImpl();
44. private ClassesDao2 cd2 = new ClassesDaoImpl2();
45. public void printOut(){
46.    System.out.println(cd.getClassesName()+"   "+cd2.getClassesName());
47. }
48. };

虽然这个例子不全，但基本意思已经很明显了。

5.策略模式

这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。

具体看这个例子：

   1. view plaincopy to clipboardprint?
   2. package org.sp.strategy;
   3. /**
   4. * 加法具体策略类
   5. * @author 无尽de华尔兹
   6. *
   7. */
   8. public class Addition extends Operation {
   9. @Override
10. public float parameter(float a, float b) {
11.    return a+b;
12. }
13. }
14. package org.sp.strategy;
15. /**
16. * 除法具体策略类
17. * @author 无尽de华尔兹
18. *
19. */
20. public class Division extends Operation {
21. @Override
22. public float parameter(float a, float b) {
23.    return a/b;
24. }
25. }
26. package org.sp.strategy;
27. /**
28. * 乘法具体策略类
29. * @author 无尽de华尔兹
30. *
31. */
32. public class Multiplication extends Operation{
33. @Override
34. public float parameter(float a, float b) {
35.    return a*b;
36. }
37. }
38. package org.sp.strategy;
39.
40. /**
41. * 减法具体策略类
42. * @author 无尽de华尔兹
43. *
44. */
45. public class Subtration extends Operation {
46.
47. @Override
48. public float parameter(float a, float b) {
49.    return a-b;
50. }
51. }
52. package org.sp.strategy;
53. /**
54. * 抽象策略类也可以使用接口来代替
55. * @author 无尽de华尔兹
56. *
57. */
58. public abstract class Operation {
59.
60. public abstract float parameter(float a, float b);
61. }
62. package org.sp.strategy;
63.
64. /**
65. * 策略环境类
66. * @author 无尽de华尔兹
67. *
68. */
69. public class Condition {
70. public static final Addition add = new Addition();
71. public static final Subtration sub = new Subtration();
72. public static final Multiplication mul = new Multiplication();
73. public static final Division div = new Division();
74.
75. }
76. package org.sp.strategy;
77.
78. /**
79. * 测试客户端
80. * @author 无尽de华尔兹
81. *
82. */
83. public class Client {
84.
85. public static void main(String[] args) {
86.    float a = 100;
87.    float b = 25;
88.
89.    System.out.println(Condition.div.parameter(a, b));
90. }
91. }

以上便是对Java设计模式中五种常用的设计模式进行介绍。