一、单例模式
为了保证某个类只有一个实例对象。两种方法：懒汉式和饿汉式。
饿汉式：缺点：会在一开始就创建对象。优点：线程安全。

class Singleton {//1.私有化构造器private Singleton(){};//2.静态构造实例对象private static Singleton singleton=new Singleton();//3.提供调用方法public static Singleton getInstance(){return singleton;}
}

懒汉式：优点：延迟对象的创建。缺点：如果不加synchronized则线程不安全。

class Singleton {//1.私有化构造器private Singleton(){};//2.静态构造实例对象private static Singleton singleton=null;//3.提供调用方法public static  Singleton getInstance(){if (singleton==null)singleton=new Singleton();return singleton;}
}

效率稍高的改进方法：

class Singleton {//1.私有化构造器private Singleton(){};//2.静态构造实例对象private static Singleton singleton=null;//3.提供调用方法public static  Singleton getInstance(){if (singleton==null){synchronized(Singleton.class){if (singleton==null)singleton=new Singleton();}}return singleton;}
}

二、模板方法设计模式
将一些易变的代码抽象出来，给到具体实现的来实现。
比如

abstruct class Template{public void spendTime(){long start=System.currentTimeMillis();code();long end=System.currentTimeMillis();System.out.println("花费的时间:"+(end-start));}public abstruct code(){//代码}
}

三、代理模式
一个接口定义了一个方法，被代理类和代理类都实现接口(也能是抽象类)实现这个方法，但是代理类中还有其他方法来使用使用接口(被代理类)。代理类能多一些被代理类的其他方法。分为静态代理和动态代理。
静态代理：

//静态代理
interface Network{public void browse();
}
//被代理类
class Server implements Network{@Overridepublic void browse(){//自己的实现}
}
class ProxyServer implements Network{private Network work;//用组合的形式将二者连接public ProxyServer(Network work){this.work=work;}public void check(Network work){//自己的方法}@Overridepublic void browse(){check();work.browse();}
}	
//最终使用：
public class use{public static void main(String args){//原来使用Server ser=new Server():ser.browse();//现在使用ProxyServer pser=new ProxyServer();pser.browse();}
}

动态代理
动态代理取消了去写代理类的步骤，而是使用反射动态生成代理类，免除了一个被代理类就需要一个代理类的冗余。
使用Proxy生成动态代理的实例，使用InvocationHandler调用处理程序返回结果。

public class ProxyInvocationHandler implements InvocationHandler{//被代理的接口private Object target;public void setTarget(Object target){this.target=target;}//生成得到代理类public Object getProxy(){return Proxy.newProxyInstance(this.getClass.getLoader(),target.getClass().getInterfaces(),this);}//处理代理实例 并返回结果public Object invoke(Object proxy,Method method,Object args) throws Throwable{//此处添加自己的方法//核心Object result=method.invoke(target,args);//此处添加自己的方法return result}
}//调用：
Server ser=new Server();//要被代理的实例
ProxyInvocationHandler pih=new ProxyInvocationHandler();
pih.setTarget(ser);//设置要代理的对象
Server proxy=(Server)pih.getProxy();//动态生成代理类
proxy.browse();

四、工厂模式
工厂模式实现了创建者与调用者的分离，即创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式分类：
简单工厂模式：用来生产同一等级结构中的任意产品。(对于增加新的产品，需要修改已有代码)
工厂方法模式：用来生产同一等级结构中的固定产品。(支持增加任意产品)
抽象工厂模式：用来生产不同产品族的全部产品(对于增加新的产品无能为力；支持增加产品族)。
简单工厂模式

interface CarFactory{public static Car getCar(String s){if(s.equals("奥迪")){return new Audi();}else if(s.equals("比亚迪"){return new BYD();}else return null;}
}	//调用：Car car=CarFactory.getCar("奥迪");

工厂方法模式：

interface Factory{Car getCar();
}
定义实际的Car工厂类实现Factory接口，创建具体的Car对象。