java 模式

现给出一简单用例，模拟一火腿（Ham）生产工厂，工厂可以生产数种类型的Ham，那么在创建了一个工厂实例后，只需要告诉它请你生产何种Ham，它就会给你生产出来：
package test;

interface Ham { //定义接口，用于辅助实现工厂模式
     void show();//由Ham工厂生产出的各种Ham将有show()的能力
}
public class FatoryModule {//工厂类，用于产品多种不同种类的Ham
     public Ham getHam(String HamType) throws Exception{//工厂类对象生产Ham的动作
         if (HamType.equals("HamA")) {
             return new HamA();
         }
         else if (HamType.equals("HamB")) {
             return new HamB();
         }
         else if (HamType.equals("HamC")) {
             return new HamC();
         }
         else
             throw new Exception();//如果该工厂收到生产某种Ham的指令但暂不支持，则抛出异常
       
     }

     public static void main(String[] args) {//测试代码
         FatoryModule fatorymodule = new FatoryModule();
     try {
         Ham myHam = fatorymodule.getHam("HamB");//可以方便地创建各种类型的Ham，而程序结构和代码的修改量达到最小
         myHam.show();
     } catch (Exception ex) {
         ex.printStackTrace();//应进一步处理异常
     }
     }
}

class HamA implements Ham { //工厂中生产的一种产品HamA
     public void show() {
         System.out.println("You got a HamA.");
     }
}

class HamB implements Ham { //工厂生产的另一种产品HamB
     public void show() {
         System.out.println("You got a HamB.");
     }
}

class HamC implements Ham { //工厂生产的第三种产品HamC
     public void show() {
         System.out.println("You got a HamC.");
     }
}
         通过程序的演示我得到了以下结论：

         由于应用了工厂模式，我只需要告诉工厂对象给我生产一种什么样的Ham（即getHam()方法中的参数），便可以得到此类Ham，而不用写HamX   hamX=new HamX(); 要是有数十种不同的Ham对象需要在程序的不同地方被创建，那么使用工厂模式代码将显得简单而统一，每个需要不同Ham的地方仅是getHam()的参数不同。否则程序一旦需要扩展和维护，数十处的new语句将让人头痛。而如果需要添加新的Ham类型，只需要在工厂类中添加即可。
单例模式--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
饿汉式
class Singleton {
  private static Singleton instance=new Singleton();
  private Singleton(){}
  static Singleton getInstance() {
      return instance;
  }
}
懒汉式
class Singleton {
  private static Singleton instance=null;
  private Singleton(){}
  static Singleton getInstance() {
      if(instance==null)
      instance=new Singleton();
      return instance;
  }
}
外观模式--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Java设计模式---外观模式(Facede)


package ding.study.designpatterns.facade;
/**
*
* @author daniel
* 子系统1
*/
public class SystemOne {

/**
  * 子系统方法
  */
public void methodOne(){
  System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
/**
*
* @author daniel
* 子系统1
*/
public class SystemTwo {
/**
  * 子系统方法
  */
public void methodTwo(){
  System.out.println("子系统方法1");
}
}


package ding.study.designpatterns.facade;

public class SystemThree {
/**
  * 子系统方法
  */
public void methodThree(){
  System.out.println("子系统方法1");
}
}


package ding.study.designpatterns.facade;

public class SystemFour {
/**
  * 子系统方法
  */
public void methodFour(){
  System.out.println("子系统方法1");
}
}


package ding.study.designpatterns.facade;
/**
* 外观类
* @author daniel
*
*/
public class Facade {
private SystemOne one;
private SystemTwo two;
private SystemThree three;
private SystemFour four;
/**
  * 构造函数初始化属性
  */
public Facade(){
  one =new SystemOne();
  two =new SystemTwo();
  three=new SystemThree();
  four=new SystemFour();
}

/**
  * 1 2 4类的方法调用
  */
public void methodA(){
  one.methodOne();
  two.methodTwo();
  four.methodFour();
}
/**
  * 123类的方法调用
  */
public void methodB(){
  one.methodOne();
  two.methodTwo();
  three.methodThree();
}
}


package ding.study.designpatterns.facade;

public class TestMain {

/**复杂的逻辑封装为一个简单的接口
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Facade facade=new Facade();
  facade.methodA();
  facade.methodB();
}

}
1. 代理模式
代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到三个角色：
抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

以下以《Java与模式》中的示例为例：

抽象角色：


  abstract   public   class  Subject   {
    abstract   public   void  request();
}   



真实角色：实现了Subject的request()方法。


  public   class  RealSubject  extends  Subject   {
     public  RealSubject()   { }  
   
     public   void  request()   {
        System.out.println( " From real subject. " );
    }  
}  



代理角色：


  public   class  ProxySubject  extends  Subject   {
     private  RealSubject realSubject;  // 以真实角色作为代理角色的属性 
 
      public  ProxySubject()   { }  


     public   void  request()   {  // 该方法封装了真实对象的request方法 
          preRequest();

         if ( realSubject  ==   null  )   {

            realSubject  =   new  RealSubject();
        }  

        realSubject.request();  // 此处执行真实对象的request方法 
 
        postRequest();
    } 

  


  客户端调用：


Subject sub = new  ProxySubject();
Sub.request();


由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，同样达到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。

另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个 代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。
----------------------------------------------------------------
单例模式:
//懒汉式单例类.在第一次调用的时候实例化
2 public class Singleton2 {
3     //私有的默认构造子
4     private Singleton2() {}
5     //注意，这里没有final   
6     private static Singleton2 single=null;
7     //静态工厂方法
8     public synchronized  static Singleton2 getInstance() {
9          if (single == null) { 
10              single = new Singleton2();
11          } 
12         return single;
13     }
14 }

//饿汉式单例类.在类初始化时，已经自行实例化
2 public class Singleton1 {
3     //私有的默认构造子
4     private Singleton1() {}
5     //已经自行实例化
6     private static final Singleton1 single = new Singleton1();
7     //静态工厂方法
8     public static Singleton1 getInstance() {
9         return single;
10     }
11 }