欢迎使用CSDN-markdown编辑器

1.简单工厂模式：就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建

2.工厂方法模式：创建一个工厂接口和创建多个工厂实现类，增加新功能，直接增加新工厂类就ok
3.单例模式：该对象只有一个实例存在
public class Singleton {
/* 私有构造方法*/
private Singleton(){
}
/* 内部类维护单例*/
private static class T{
private static Singleton t=new Singleton();
}
/* 获取实例*/
public static Singleton getInstance(){
return T.t;
}
/* 对象被用于序列化，保证对象系列化前后保持一致*/
public Object readResolve(){
return getInstance();
}
}
4.适配器模式：将某个类的接口转换成客户端希望的另一个接口表示
分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式
应用实例：InputStreamReader(inputStream)
OutputStreamWriter(OutputStream)
A:类的适配器模式：有一个source类,拥有一个方法，带适配，目标接口是Targetable，通过Adapter类，将Soource功能扩展到Targetable
public class Source {
public void method1(){
System.out.println(“method1…..”);
}
}
public interface Targetable {

public void method1();

public void method2();  

}

public class Adapter extends Source implements Targetable{

@Override
public void method2() {
    // TODO Auto-generated method stub
    System.err.println("targetable method1");
}

}
B:对象的适配器模式：将adapter修改，持有Source类实例
C:接口的适配器模式：借助一个抽象类，该抽象类实现了该接口所有方法，我们只需要继承该抽象类，重写我们需要的方法就行
5.装饰模式：动态给对象增加新功能，要求装饰对象和被装饰对象实现同一接口，装饰对象持有被装饰对象的实例
应用实例：BufferedInputStream(InputStream)
BufferedOutputStream(OutputStream)
public interface Sourceable {
public void method();
}
public class Source2 implements Sourceable{

@Override
public void method() {
    // TODO Auto-generated method stub
    System.out.println(" the origin method");
}

public class Decorator implements Sourceable{
private Sourceable source;

public Decorator(Sourceable source) {
super();
this.source = source;
}

@Override
public void method() {
    // TODO Auto-generated method stub
    System.out.println("before....");
    source.method();
    System.out.println("after....");
}

}
应用场景：A：需要扩展一个类的功能
B:动态为对象增加功能，而且能动态撤销
缺点：产生过多相似对象
6.代理模式：同装饰模式做比较
应用实例：java.lang.reflect.Proxy
public class Proxy implements Sourceable{
private Source source;

public Proxy(Source source) {
    super();
    this.source = source;
}

@Override
public void method() {
    // TODO Auto-generated method stub
    before();
    source.method1();
    after();
}

private void before(){
System.out.println(” before proxy”);
}
private void after(){
System.out.println(“after proxy”);
}
}
应用场景：对已有方法的改进
7.模板方法模式：一个抽象类，有一个主方法，再定义1.。。N个方法，可以抽象，可以实际，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用

8.责任链模式
应用实例：java.util.logging.Logger#log()
Javax.servlet.Filter#doFilter

9.观察者模式
应用实例：java.util.Observer/java.util.Observable