一、单例模式。
懒汉模式：加synchronized修饰 就是线程安全的，不加就是线程不安全的。
public class SingleObj { private SingleObj () {} /*私有化构造方法，在其它类中不能调用new StaZhang()创建SingleObj对象*/ private static SingleObj singleObj =null; /*getStaticZhangObj()为外部类提供调用，来返回SingleObj 的一个实例*/ public static synchronized SingleObj getStaticZhangObj() { /* 判断是否为初次调用，如果是初次调用就实例化SingleObj对象，并返回*/ if (singleObj ==null) { singleObj =new SingleObj (); return singleObj ; }else return singleObj ; } }恶汉模式：static修饰的优先加载，所以也是线程安全的。
public class SingleObject { private SingleObject(){}/*构造函数私有化*/ private static SingleObject singleObject=new SingleObject(); public static SingleObject getSingleObject(){ /*提供外部调用方法*/ return singleObject; } }二、工厂模式。
简单工厂模式：
必须创建一个共同实现的接口(生产车间接口)
/*生产车间接口*/ public interface WorkShop { /*生产方法*/ public void product(); }创建汽车生产车间类 实现 生产车间接口
public class CarworkShopImple implements WorkShop { @Override public void product() { System.out.println("生产汽车。。。"); } } 创建自行车生产车间类实现 生产创建接口 public class BikeworkShopImple implements WorkShop { @Override public void product() { System.out.println("生产自行车。。。"); }创建工厂类 根据getVehicle方法参数 匹配类 ，返回该实例对象，注意方法的返回值类型是父类接口类型
public class FactoryUtil { public WorkShop getVehicle(String name){ if (name==null) return null; else if (("car").equals(name)) return new CarworkShopImple(); else if (("bike").equals(name)) return new BikeworkShopImple(); else return null; } }调用
@Test public void test2(){ FactoryUtil factoryUtil=new FactoryUtil(); WorkShop bike=factoryUtil.getVehicle("bike"); bike.product(); WorkShop car=factoryUtil.getVehicle("car"); car.product(); }抽象工厂模式：
三、代理模式。
静态代理：
步骤一、必须创建接口
public interface Animal { public String eat(String food); }步骤二、创建接口实现类
public class Dog implements Animal { @Override public String eat(String food) { return "狗吃"+food; } }
步骤三、创建目标类的代理类
public class DogProxy implements Animal{ private Dog dog; public DogProxy(Dog dog) { this.dog=dog; } @Override public String eat(String food) { System.out.println("扩展操作"); return dog.eat(food); } }步骤四、调用
Animal animal=new DogProxy(new Dog()); String str=animal.eat("骨头"); System.out.println(str);动态代理：
步骤一、首先必须定义接口
public interface Animal { public String eat(String food); }步骤二、定义接口的实现类(目标类)
public class Dog implements Animal { @Override public String eat(String food) { return "狗吃"+food; } }步骤三、实现InvocationHandler实现类并实现构造方法初始化。（和静态代理的区别 就在于Object 类型参数）
public class MyInvocationHandler implements InvocationHandler { /*创建目标对象*/ private Object target; public MyInvocationHandler(Object target) { this.target=target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("扩展开始*****"); System.out.println("扩展结束*****"); /*相当于定义eat()方法*/ return method.invoke(target,args); } }步骤四、调用Proxy.newProxyInstance()生成代理类对象。
/*目标对象*/ Dog dog = new Dog(); /*调用函数对象*/ MyInvocationHandler myInvocationHandler=new MyInvocationHandler(dog); /*Proxy.newProxyInstance()生成的是Animal接口的实现类 和目标类Dog是兄弟关系。 */ Animal animal = (Animal) Proxy.newProxyInstance ( dog.getClass().getClassLoader(), dog.getClass().getInterfaces(), myInvocationHandler );/*创建Dog代理对象*/ String foodDog = animal.eat("骨头"); System.out.println(foodDog);
