为了账号安全,请及时绑定邮箱和手机立即绑定

java几种常用设计模式

标签:
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. }  

 

 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. }  

 

 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. }  

 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. }  

 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. }  



详解请参见:http://blog.csdn.net/haoxingfeng/article/details/9191619

原文链接:http://www.apkbus.com/blog-664680-59468.html

点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消