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

1.单例设计模式

       所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：
      (1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。
      (2) 在其内部产生该类的实例化对象，并将其封装成private static类型。
      (3) 定义一个静态方法返回该类的实例。
         示例代码如下：
 Java代码  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 plain copy1. 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. }  
 一、单例模式的介绍 
     Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点 

二、单例模式的实现 

实现的方式有如下四种： Java代码  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 plain copy1. /** 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代码  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 plain copy1. /** 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代码  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 plain copy1. /** 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代码  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代码  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. }  [java] view plain copy1. 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代码  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. }  [java] view plain copy1. 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代码  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. }  [java] view plain copy1. 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代码  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. }  [java] view plain copy1. 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. }