首页 > 代码库 > java几种常用设计模式简单示例

java几种常用设计模式简单示例

2024-07-30 02:57:05   222人阅读

1.单例设计模式

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

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

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

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

         示例代码如下：

 

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


单例模式的实现 

 

 

[java] view plaincopy
 
  1.  /**   
  2.  *    
  3.  * 单例模式的实现：饿汉式,线程安全 但效率比较低   
  4.  */    
  5. public class SingletonTest {     
  6.     
  7.     private SingletonTest() {     
  8.     }     
  9.     
  10.     private static final SingletonTest instance = new SingletonTest();     
  11.     
  12.     public static SingletonTest getInstancei() {     
  13.         return instance;     
  14.     }     
  15.     
  16. }    

 

[java] view plaincopy
 
  1. /**   
  2.  * 单例模式的实现：懒汉式,非线程安全    
  3.  *    
  4.  */    
  5. public class SingletonTest {     
  6.     private SingletonTest() {     
  7.     }     
  8.     
  9.     private static SingletonTest instance;     
  10.     
  11.     public static SingletonTest getInstance() {     
  12.         if (instance == null)     
  13.             instance = new SingletonTest();     
  14.         return instance;     
  15.     }     
  16. }    

 

[java] view plaincopy
 
  1. /**  
  2.  * 线程安全，但是效率非常低  
  3.  * @author vanceinfo  
  4.  *  
  5.  */    
  6. public class SingletonTest {    
  7.     private SingletonTest() {    
  8.     }    
  9.     
  10.     private static SingletonTest instance;    
  11.     
  12.     public static synchronized SingletonTest getInstance() {    
  13.         if (instance == null)    
  14.             instance = new SingletonTest();    
  15.         return instance;    
  16.     }    
  17. }    

 

[java] view plaincopy
 
  1. /**   
  2.  * 线程安全  并且效率高   
  3.  *   
  4.  */    
  5. public class SingletonTest {     
  6.     private static SingletonTest instance;     
  7.     
  8.     private SingletonTest() {     
  9.     }     
  10.     
  11.     public static SingletonTest getIstance() {     
  12.         if (instance == null) {     
  13.             synchronized (SingletonTest.class) {     
  14.                 if (instance == null) {     
  15.                     instance = new SingletonTest();     
  16.                 }     
  17.             }     
  18.         }     
  19.         return instance;     
  20.     }     
  21. }    

 

 

 2.工厂设计模式

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

      示例代码如下：

 

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

 

 

 3.代理设计模式

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

      示例代码如下：

 

 

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

 

 

4.观察者设计模式

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

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

       示例代码如下：

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

 

 5.适配器模式

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

      示例代码如下：

[java] view plaincopy
 
  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 Window {     
  15.     public void open() {     
  16.     };// 窗口打开     
  17.     
  18.     public void close() {     
  19.     };// 窗口关闭     
  20.     
  21.     public void iconified() {     
  22.     };// 窗口最小化     
  23.     
  24.     public void deiconified() {     
  25.     };// 窗口恢复     
  26.     
  27.     public void activated() {     
  28.     };// 窗口活动     
  29. }     
  30.     
  31. // 子类继承WindowAdapter抽象类，选择性实现需要的方法     
  32. class WindowImpl extends WindowAdapter {     
  33.     public void open() {     
  34.         System.out.println("窗口打开");// 实现open()方法    
  35.     }     
  36.     
  37.     public void close() {     
  38.         System.out.println("窗口关闭");// 实现close()方法    
  39.     }     
  40. }     
  41.     
  42. public class AdapterDemo {     
  43.     public static void main(String args[]) {     
  44.         Window win = new WindowImpl(); // 实现接口对象    
  45.         // 调用方法     
  46.         win.open();     
  47.         win.close();     
  48.     }     
  49. }    


http://blog.csdn.net/haoxingfeng/article/details/9191619

java几种常用设计模式简单示例


联系
我们