java 23种设计模式学习。

一.3大类设计模式：建立型，结构型，行为型。

    a.5种建立型模式：工厂方法，抽象工厂，单例，建造者，原型。

    b.7种结构型模式：适配器，装饰器，代理，外观，桥接，组合，享元。

    c.11种行为型模式：策略，模板方法，观察者，迭代子，责任链，命令，备忘录，

    状态，访问者，中介者，解释器。

注意：除上述3大类外，还有另2类设计模式：并发型，线程池。

二.设计模式6大原则：开闭，里氏代换，依赖倒转，接口隔离，迪米特（最少知道），合成复用。

    a.开闭：对拓展开发，对修改关闭。程序进行拓展时，不能修改原有的代码，咱们须要使用接口和抽象类。

    b.里氏代换（LSP）：面向对象设计的基本原则之一，对开闭原则的补充。任何基类能够出现的地方，子类必定出现。子类继承基类，不影响基类的前提下，增长新的方法与功能，基类代码就得以被复用。

    c.依赖倒转：开闭原则的基础，针对接口编程，依赖于抽象不依赖于具体。

    d.接口隔离：使用多个隔离接口比使用单个接口好。

    e.迪米特（最少知道）:一个实体应该尽可能少的与其余实体之间发生相互做用，使得系统功能模块相对独立。

    f:合成复用原则：尽可能使用合成/聚合的方式，而不是继承。

三.23种设计模式。

    1.3种工厂方法模式：普通工厂，多个工厂方法。

       a.普通工厂:创建一个工厂类，对实现同一接口的类进行实例建立的过程。      

       父接口:

public interface Sender{
     public void send();
}

       实现类：

public class MailSender implements Sender{
  @Override

   public void send(){

    System.out.println("this is mailSender!");
  }

}

 

public class SmsSender implements Sender(){
          @override
          public void send(){
          System.out.println("this is sms sender");
}
}

     工厂类：

public classs SendFactory{
     public Sender produce(String type){
         if("mail".equals(type)){
           return new MailSender();
       }else if("sms".equals(type)){
             return new SmsSender();      
       }else{
            System.out.println("please input  the correct type!");
            return null;        
       }
    }
    
    public static void main(String[] args){
         SendFactory factory=new SendFactory();
         Sender sender = factory.produce("sms");
         sender.Send();
    }

}

输出：this is sms Sender!

        b.多个工厂方法:对普通工厂进行了改进，在普通工厂方法模式中，若是传递的字符串出错，则不能正确的建立对象，而多个工厂方法 提供多个工厂方法建立对象。

        只需改动下工厂类：

public class SendFactory{
      public Sender produceMail(){
      return new MailSender();      
 
      }
     
      public Sender produceSms(){
      return new SmsSender();  
      }
      

       public void static main(String[] args){
     
         Sender mailSender =new SendFactory().produceMail();
       }
}

       c.静态工厂方法：将上面工厂方法模式里的方法写为静态方法，可经过类名+.直接调用。
    工厂方法模式小结：结合a,b,c三种工厂方法模式，第c种发挥了前两种的优点，摒弃了劣势，最适合大多数状况下使用。

    2.抽象工厂模式：工厂方法模式有一个缺陷，若是想拓展程序，必须对工厂类进行修改，这违背了开闭原则。如何解决？用抽象工厂模式，建立多个工厂类，一旦须要加新功能，直接增长新的工厂类，就不须要修改以前写好的工厂类代码了。

    抽象工厂接口： 

public interface Provider{
    public Sender produce();
}

    原有的工厂类修改成两个工厂类：

public class SendSmsFactory implements Provider{
    @Override
     public Sender produce(){
     return new SmsSender();
   }
}

public class SendMailFactory implements Provider{
   @Override
    public Sender produce(){
    return new MailSender();
  }
}

     相应测试程序：

public class Test{
    public void static main(String[] args){
    Provider provider=new SendMailFactory();
    Sender mailSender=provider.produce();
    mailSender.send();
   }
}

     3.单例模式：单例对象能保证在一jvm，只有一个实例存在。好处：某些类建立比较繁琐，对于一些大型的对象，能够节省开销；省去了new操做符，下降了系统内存的使用频率，减轻GC压力；某些核心类，若是能够建立多个，系统就彻底乱了。

     单例类：

     

public class Singleton{
   //私有静态实例，防止被引用，此处赋值为空，为了实现延迟加载。
   private static Singleton instance=null;
   
   //私有构造函数，防止外部直接new 实例化.
   private Singleton(){
  
   
  }

  //静态工厂方法，建立实例
   public static Singleton getInstance(){
     if(instance==null){
        instance=new Singleton();
     }
    return instance;
   }
   
   //若是该对象被用于序列化，能够保证对象在序列化先后保持一致
   public Object readResolve(){
   return instance;
  }
}

http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

   尽管这样，仍是没法保证安全，在多线程环境下确定会出问题的。咱们首先会想到对getInstance方法加synchronized关键字:

public static synchronized Singleton getInstance(){
        if(instance==null){
        instance=new Singleton();
  }
        return instance;
}

   这样时彷佛解决了问题，