码迷，mamicode.com
首页 > 编程语言 > 详细

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

时间：2014-10-30 00:03:03      阅读：234      评论：0      收藏：0      [点我收藏+]

标签：blog   http   io   os   ar   使用   java   sp   strong   

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几种常用设计模式简单示例

标签：blog   http   io   os   ar   使用   java   sp   strong   

原文地址：http://www.cnblogs.com/wikiki/p/4060889.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！