java 设计模块实战 java设计模式实例

1.单例设计模式

       所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：

      (1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

      (2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

      (3) 定义一个静态方法返回该类的实例。

         示例代码如下：

 

1. class
2. private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象
3.   
4. public static Singleton getInstance() { // 通过静态方法返回instance对象
5. return
6.     }  
7.   
8. private Singleton() { // 将构造方法封装为私有化
9.     }  
10.   
11. public void
12. "Hello World!!!");  
13.     }  
14. }  
15.   
16. public class
17. public static void
18. null; // 声明对象
19. null; // 声明对象
20. null; // 声明对象
21. // 取得实例化对象
22. // 取得实例化对象
23. // 取得实例化对象
24. // 调用方法
25. // 调用方法
26. // 调用方法
27.     }  
28. }

 

 2.工厂设计模式

       程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

      示例代码如下：

1. interface Animal { // 定义一个动物的接口
2. public void say(); // 说话方法
3. }  
4.   
5. class Cat implements Animal { // 定义子类Cat
6. @Override
7. public void say() { // 覆写say()方法
8. "我是猫咪，喵呜！");  
9.     }  
10. }  
11.   
12. class Dog implements Animal { // 定义子类Dog
13.   
14. @Override
15. public void say() { // 覆写say()方法
16. "我是小狗，汪汪！");  
17.     }  
18. }  
19.   
20. class Factory { // 定义工厂类
21. public static
22. null; // 定义接口对象
23. if ("Cat".equals(className)) { // 判断是哪个子类的标记
24. new Cat(); // 通过Cat子类实例化接口
25.         }  
26. if ("Dog".equals(className)) { // 判断是哪个子类的标记
27. new Dog(); // 通过Dog子类实例化接口
28.         }  
29. return
30.     }  
31. }  
32.   
33. public class
34.   
35. public static void
36. null; // 定义接口对象
37. 0]); // 通过工厂获取实例
38. if (a != null) { // 判断对象是否为空
39. // 调用方法
40.         }  
41.     }  
42. }

 

 3.代理设计模式

       指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

      示例代码如下：

1. interface Network { // 定义Network接口
2. public void browse(); // 定义浏览的抽象方法
3. }  
4.   
5. class Real implements Network { // 真实的上网操作
6. public void browse() { // 覆写抽象方法
7. "上网浏览信息！");  
8.     }  
9. }  
10.   
11. class Proxy implements Network { // 代理上网
12. private
13.   
14. public Proxy(Network network) {// 设置代理的真实操作
15. this.network = network; // 设置代理的子类
16.     }  
17.   
18. public void check() { // 身份验证操作
19. "检查用户是否合法！");  
20.     }  
21.   
22. public void
23. this.check(); // 调用具体的代理业务操作
24. this.network.browse(); // 调用真实的上网操作
25.     }  
26. }  
27.   
28. public class
29. public static void
30. null; // 定义接口对象
31. new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
32. // 调用代理的上网操作
33.     }  
34. }

 4.观察者设计模式

       所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

       java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

       示例代码如下：

1. import
2. import
3.   
4. class House extends
5. private float
6.   
7. public void setPrice(float
8. this.setChanged();// 设置变化点
9. this.notifyObservers(price);// 通知所有观察者价格改变
10. this.price = price;  
11.     }  
12.   
13. public float
14. return this.price;  
15.     }  
16.   
17. public House(float
18. this.price = price;  
19.     }  
20.   
21. public
22. return "房子价格为: " + this.price;  
23.     }  
24. }  
25.   
26. class HousePriceObserver implements
27. private
28.   
29. public
30. super();  
31. this.name = name;  
32.     }  
33.   
34. @Override
35. public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
36. if (arg instanceof
37. this.name + "观察的价格更改为:"
38.                     + ((Float) arg).floatValue());  
39.         }  
40.   
41.     }  
42.   
43. }  
44.   
45. public class
46. public static void
47. new House(1000000);  
48. new HousePriceObserver("购房者A");  
49. new HousePriceObserver("购房者B");  
50. new HousePriceObserver("购房者C");  
51. // 给房子注册观察者
52. // 给房子注册观察者
53. // 给房子注册观察者
54. // 输出房子价格
55. // 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
56. 2222222);// 
57. // 再次输出房子价格
58.     }  
59. }

 5.适配器模式

        如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。

      示例代码如下：

1. interface Window {// 定义Window窗口接口，表示窗口操作
2. public void open();// 窗口打开
3.   
4. public void close();// 窗口关闭
5.   
6. public void iconified();// 窗口最小化
7.   
8. public void deiconified();// 窗口恢复
9.   
10. public void activated();// 窗口活动
11. }  
12.   
13. // 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
14. abstract class WindowAdapter implements
15. public void
16. // 窗口打开
17.   
18. public void
19. // 窗口关闭
20.   
21. public void
22. // 窗口最小化
23.   
24. public void
25. // 窗口恢复
26.   
27. public void
28. // 窗口活动
29. }  
30.   
31. // 子类继承WindowAdapter抽象类，选择性实现需要的方法
32. class WindowImpl extends
33. public void
34. "窗口打开");// 实现open()方法
35.     }  
36.   
37. public void
38. "窗口关闭");// 实现close()方法
39.     }  
40. }  
41.   
42. public class
43. public static void
44. new WindowImpl(); // 实现接口对象
45. // 调用方法
46.         win.open();  
47.         win.close();  
48.     }  
49. }