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设计模式中五种常用的设计模式进行介绍。
五种常用的设计模式
最新推荐文章于 2020-11-25 10:54:11 发布