设计模式程序参考

设计软件的几个原则，这个也是设计模式的精髓所在：
1.开－闭原则
1).客户的需求是不稳定的，通过扩展已有的软件系统而不是通过修改软件系统来满足客户的需求，这样的软件系统就满足开－闭原则，即软件系统要有一定的灵活性和适应性。
2).已有的模块，特别是抽象层的模块不能修改，保证软件系统的稳定性和延续性。
解决问题的关键是抽象化，把它与具体实现分离开来。接口（interface），抽象类的应用
对可变性封装：将可变性封装到一个对象里。

2.抽象类
抽象类不会有实例，一般作为父类为子类继承，一般包含这个系的共同属性和方法。
注意：好的继承关系中，只有叶节点是具体类，其他节点应该都是抽象类，也就是说具体类
是不被继承的。将尽可能多的共同代码放到抽象类中。

3.里氏代换原则
在有基类出现的地方，子类均可以替代。
当两个具体类关系违反里氏代换原则时，一种办法是抽象出一个基类，作为这两个类的父类，
一种是应用组合聚合关系建立关系。
不要为了使用某些类的方法（功能）而滥用继承。

4 依赖倒转原则
抽象不应该依赖与细节，细节应当依赖与抽象。
要针对接口编程，而不是针对实现编程。
传递参数，或者在组合聚合关系中，尽量引用层次高的类。
主要是在构造对象时可以动态的创建各种具体对象，当然如果一些具体类比较稳定，就不必在弄一个抽象类做它的父类，这样有画舌添足的感觉

5 接口隔离原则
定制服务的例子，每一个接口应该是一种角色，不多不少，不干不该干的事，该干的事都要干

6 合成/聚合原则
尽量使用合成聚合原则，少用慎用继承。
合成：一荣俱荣，一损俱损，整体和部分的生命周期是一样的
聚合：部分可以是整体的一部分，也可以脱离整体而存在。
区分Has a和Is a的问题

7 迪米特法则
最少知识原则。不要和陌生人说话。

简单工厂模式

1. abstract class Fruit{   
2. }   
3.   
4.   
5. class Apple extends Fruit{   
6. }   
7.   
8.   
9. class Orange extends Fruit{   
10. }   
11.   
12.   
13. class FruitFactory{   
14.    pulic static Fruit getFruit(String fruitType){   
15.       if (“apple” == fruitType){   
16.          return new Apple();   
17.       } else if (“orange” == fruitType) {   
18.          return new Orange();   
19.       }   
20.    }   
21. }  

工厂方法模式

1. interface IFruitFactory{   
2.    puhlic Fruit getFruit();   
3. }   
4. class AppleFactory implements IFruitFactory{   
5.    public Fruit getFruit(){   
6.       //生产苹果   
7.       return new Apple();   
8.    }   
9. }  

单例模式

1. class Singleton{   
2.    private static Singleton singleton = null;   
3.    public static Singleton getInstance(){   
4.       if(null == singleton){   
5.          singleton = new Singleton();   
6.       }   
7.       return singleton;   
8.    }   
9.    public String otherOperation(){   
10.       //方法实现   
11.    }   
12. }  

适配器模式

1. interface Powerable{   
2.    110v provide();   
3. }   
4. class 110v {   
5. }   
6. class 220v {   
7. }   
8. class 110vPower implements Powerable{   
9.    public 110v provide(){   
10.       //提供 110v 电压   
11.    }   
12. }   
13. class 220vPower {   
14.    public 220v provide(){   
15.       //提供 220v 电压   
16.    }   
17. }   
18. class 220vAdapter implements Powerable{   
19.    public 110v provide(){   
20.       110v voltage = null;   
21.       220vPower power = new 220vPower();   
22.     //转换过程,@!@#$%^   
23.     return voltage;   
24.   }   
25. }  

组合模式

1. abstract class Hardware{   
2. }   
3.   
4. class Mainboard extends Hardware{   
5. }   
6.   
7. class Memory extends Hardware{   
8. }   
9.   
10. class Display extends Hardware(   
11. }   
12.   
13. class NetworkAdapter extends Hardware{   
14. }   
15. class Computer extends Hardware[   
16.    private List parts = new Arraylist();   
17.    public List add(Hardware hardware){   
18.       parts.add(hardware);   
19.       return parts;   
20.    }   
21. }  

abstract class Hardware{
}

class Mainboard extends Hardware{
}

class Memory extends Hardware{
}

class Display extends Hardware(
}

class NetworkAdapter extends Hardware{
}
class Computer extends Hardware[
   private List parts = new Arraylist();
   public List add(Hardware hardware){
      parts.add(hardware);
      return parts;
   }
}

Client：

1. Computer computer = new Computer();   
2. Mainboard mainboard = new Mainboard();   
3. NetworkAdapter networkAdapter = new NetworkAdapter();   
4. Display display = new Display();   
5. Memory memory = new Memory();   
6. computer .add(mainboad)   
7.          .add(networkAdapter)   
8.          .add(display)   
9.          .add(memory); 

外观模式

为一组类提供简单的外部接口,使外部调用者不需要和所有内部干系人打交道,就能让调用者满意。

查看 复制到剪切板 打印

1. class CallCenter{   
2.    public void solve(Customer customer){   
3.       //接受客户提出的问题   
4.       operator.acceptProblem(customer.getProblem());   
5.       boolean canSolved = operator.solve();   
6.       if (!canSolved) {   
7.          //如果不能解决,则请求其它人帮助。   
8.          operator.askHelp();   
9.       }   
10.    }   
11. }   
12.   
13. class Customer{   
14.    public void call(CallCenter callCenter){   
15.       callCenter.solve(this);   
16.    }   
17. }   
18.   
19. class Operator{   
20. }  

class CallCenter{
   public void solve(Customer customer){
      //接受客户提出的问题
      operator.acceptProblem(customer.getProblem());
      boolean canSolved = operator.solve();
      if (!canSolved) {
         //如果不能解决,则请求其它人帮助。
         operator.askHelp();
      }
   }
}

class Customer{
   public void call(CallCenter callCenter){
      callCenter.solve(this);
   }
}

class Operator{
}

Client:

查看 复制到剪切板 打印

1. CallCenter callCenter = new CallCenter();   
2. Custom aCustomer = new Customer();   
3. aCustomer.call(callCenter);  

CallCenter callCenter = new CallCenter();
Custom aCustomer = new Customer();
aCustomer.call(callCenter);

这里对客户来讲,与他接触的只有一个接口,就是接线员,最后的结果是解决他的问题。接线员可以直接解决,如果他不能解决,它可以选择请求其它人的帮助去解决这个问题。客户是不关心接线员在内部做了什么。
代理模式

1. class FileDownloader(   
2.    public download(File file);   
3. }   
4.   
5. class File{   
6. }   
7.   
8. //一般代理类使用 Proxy 后缀   
9. class FileDownloaderProxy{   
10.    FileDownloaderProxy(FileDownloader downloader){   
11.       this.downloader = downloader;   
12.    }   
13.    private FileDownloader downloader;   
14.    public download(File file){   
15.       //这里可以添加通知,通知用户开始下载文件   
16.       notifyDownloadWillStart();   
17.       //调用代理目标类的方法,进行下载文件   
18.       this.downloader.download(file);   
19.       //这里可以添加通知,通知用户文件下载完成   
20.       notifyDownloadIsComplete();   
21.    }   
22.    private void notifyDownloadWillStart(){   
23.       System.out.println(“下载开始...”);   
24.    }   
25.    private void notifyDownloadIsComplete(){   
26.       System.out.println(“下载完成!”);   
27.    }   
28. }  

class FileDownloader(
   public download(File file);
}

class File{
}

//一般代理类使用 Proxy 后缀
class FileDownloaderProxy{
   FileDownloaderProxy(FileDownloader downloader){
      this.downloader = downloader;
   }
   private FileDownloader downloader;
   public download(File file){
      //这里可以添加通知,通知用户开始下载文件
      notifyDownloadWillStart();
      //调用代理目标类的方法,进行下载文件
      this.downloader.download(file);
      //这里可以添加通知,通知用户文件下载完成
      notifyDownloadIsComplete();
   }
   private void notifyDownloadWillStart(){
      System.out.println(“下载开始...”);
   }
   private void notifyDownloadIsComplete(){
      System.out.println(“下载完成!”);
   }
}

Client: 

 

1. FileDownloaderProxy proxy =  new FileDownloaderProxy( new FileDownloader());   
2. proxy.downlaod(file);  

FileDownloaderProxy proxy =  new FileDownloaderProxy( new FileDownloader());
proxy.downlaod(file);

代理模式提供了一种间接性,可以做一些附加工作,比如记录日志,触发一些事件等,Spring 框架中大量使用了这个模式来进行 AOP 编程。