黑马程序员技术交流社区

标题: 来谈谈java中几种常见的设计模式 [打印本页]
作者: RockLee    时间: 2015-7-2 08:04
标题: 来谈谈java中几种常见的设计模式
设计模式，往往比较重要。它是我们解决问题的好帮手。
我在这里稍微总结一下Java中常见的一些设计模式。
1，单例设计模式
单例设计是Java中最常见的模式之一,，它就是要保证程序里边只有一个对象实例。就好比班上都叫他为班长，是因为得保证班上只有一个班长。
单例设计模式的程序设计思想反应的是Java面向对象思想的封装特性。就是为了保证只有一个对象实例，我们私有化它的构造函数，对外只提供一些相关的
公共方法来获得对象实例。
单例设计模式的实现主要分为饿汉式和懒汉式
饿汉式是先对类的对象实例化，随着类的加载对象也加载进来缺点是会造成性能的损耗好处是实现简单。
eg:
  1. class SingleDemo1{
  2.         static SingleDemo1 sd1 = new SingleDemo1();
  3.         private SingleDemo1 () {
  4.                 System.out.println("haha");
  5.         }
  6.         public static SingleDemo1 getSingleDemo1(){
  7.                 return sd1;
  8.                
  9.         }
  10.        
  11. }
复制代码

懒汉式是只给出变量但是没有对其进行初始化，而把初始化的动作放进了对外提供的公共函数里，其优点是安全性能好但是第一次加载会比较麻烦。
  1. class SingleClassDemo2{
  2.          static SingleClassDemo2 sd;
  3.          private SingleClassDemo2(){
  4.                
  5.         }
  6.         public static SingleClassDemo2 getSingleClassDemo2 (){
  7.                 if(sd == null){
  8.                         sd = new SingleClassDemo2();
  9.                 }
  10.                 return sd;
  11.                
  12.         }
  13. }
复制代码

2，模板设计模式


模板设计模式的思路是来源于抽象类的一些特点而它的设计思想是：
1，父类只需定义需要使用的方法，其余留个子类来实现。
2，父类提供的方法只定义了一个通用算法，让子类协助。

eg:
  1. public class 设计模式之模板设计 {
  2.         public static void main(String[] args) {
  3.                 正方形 a =new 正方形(9);
  4.                 a.show();
  5.                 长方形 b =new 长方形(1.1,8.1);
  6.                 b.show();
  7.                 圆形 c = new 圆形(3);
  8.                 c.show();
  9.                
  10.         }

  12. }

  14. abstract class Method{
  15.         abstract double zhouchang();
  16.         abstract  double mianji();
  17.          void show(){
  18.                 System.out.println("周长是"+zhouchang());
  19.                 System.out.println("面积是"+mianji());
  20.         }
  21. }

  23. class 正方形 extends Method{
  24.         double d;
  25.         正方形(double d){
  26.                 super();
  27.                 this.d =d;
  28.                
  29.         }
  30.          double zhouchang() { return  4 *d;}
  31.         double mianji() {return  d*d;}
  32. }

  34. class 长方形 extends Method{
  35.         double a;
  36.         double b;
  37.         长方形(double a,double b){
  38.                 super();
  39.                 this.a =a;
  40.                 this.b =b;               
  41.                                
  42.         }
  43.         double zhouchang() { return  2 *(a+b);}
  44.         double mianji() {return a*b;
  45. }
  46. }
  47. class 圆形 extends Method{
  48.         final double PI = 3.14;
  49.         double r;
  50.         圆形(double r){
  51.                 super();
  52.                 this.r =r;
  53.         }
  54.        
  55.         double zhouchang() { return 2 *PI*r;}
  56.         double mianji() {return PI*r*r;}


  59. }
复制代码

3,简单工厂设计模式主要是采用了Java语言中的接口的实现和多态的思想方法。
通过接口来定义类里面的具体规则而不关心类内部数据和其方法的实现屏蔽了不同子类实现的差异，提高了代码的扩展性和可维护性。
eg
  1. package 一些重点;
  2. /*
  3. * 简单工厂设计模式屏蔽了不同子类实现的差异，提高了代码的扩展性和可维护性。
  4. */

  6. public class 设计模式之简单工厂设计模式 {
  7.         public static void main(String[] args) {
  8.                 Factory  fac = new Factory();
  9.                 Phone a = new Iphone();
  10.                 Phone b = new Huawei();
  11.                 Phone c = new Xiaomi();
  12.                 fac.product(c);
  13.                
  14.         }

  16. }

  18. interface  Phone{
  19.         abstract public void show();
  20. }

  22. class Iphone implements Phone{

  24.         @Override
  25.         public void show() {
  26. System.out.println("iphone");               
  27.         }
  28.        
  29. }
  30. class Xiaomi implements Phone{

  32.         @Override
  33.         public void show() {
  34.                 System.out.println("Xiaomi");       
  35.         }
  36.        
  37. }

  39. class Huawei implements Phone{

  41.         @Override
  42.         public void show() {
  43.                 System.out.println("Huawei");       
  44.         }
  45.        
  46. }

  48. class Factory {
  49.         public static void  product(Phone p){
  50.                 if(p instanceof Iphone){
  51.                         p.show();
  52.                 }
  53.                 else if(p instanceof Xiaomi){
  54.                         p.show();
  55.                 }
  56.                 else if(p instanceof Huawei){
  57.                         p.show();
  58.                 }
  59.                 else
  60.                         System.out.println("没有此型号的手机");
  61.         }
复制代码

4,适配器模式：使用一个现成的类但是它的接口又不完全符合你的要求，可以考虑采用适配器模式
* 比如以下问题：假设一个窗口接口有变大，变小，关闭功能但是我们只想用关闭功能该怎么用？
我们可以考虑这样解决
  1. public class 设计模式之适配器模式 {
  2.         public static void main(String[] args) {
  3.                 myWindows mywindows = new myWindows();
  4.                 mywindows.close();
  5.                

  7.         }

  9. }
  10. interface Windows{
  11.          abstract public void max();
  12.          abstract public void min();
  13.          abstract public void close();
  14. }

  16. class interaptWindows implements Windows{

  18.         @Override
  19.         public void max() {
  20.                
  21.         }

  23.         @Override
  24.         public void min() {
  25.                
  26.         }

  28.         @Override
  29.         public void close() {
  30.                
  31.         }
  32.          
  33. }

  35. class myWindows extends interaptWindows{
  36.          public  void close(){
  37.                  System.out.println("窗口关闭");
  38.          }
复制代码



作者: micro_hx    时间: 2015-7-2 08:57
我觉得最难就是动态代理了。。。。。
作者: xuhao3622603    时间: 2015-7-2 09:02
装饰设计模式呀，多重要的东西



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2