一.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;
}
这样时似乎解决了问题，