java代码设计模式

一、单例模式。

   懒汉模式：加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);