设计模式

单例设计模式

饿汉式模式

class Person{
      //1.私有化构造器
      private Person(){
            //dosomething
      }

      //2.类内创建 该对象,同时要求该对象是static
      private static Person personInstance = new Person();

      //3. 提供公共的静态方法
      public static Person getInstance(){
            return personInstance ;
      }
}

懒汉式模式

class Person{
      //1.私有化构造器
      private Person(){
          //dosomething
      }

      //2.声明当前 类对象为null,同时要求该对象是static
      private static Person personInstance = null;

      //3. 提供公共的静态方法
      public static Person getInstance(){  //多线程时，懒汉式不安全
            if(personInstance  == null){
                  personInstance  = new Person();
            }
            return personInstance 
      }
}

饿汉式：好处--->线程安全；坏处---> 对象加载时间过长，不论用不用直接new了
懒汉式：好处--->延迟对象的加载；坏处--->线程不安全

懒汉式-线程安全

// 1.
class Person1{
    private Person1(){
        //doSomething
    }
    
    private static Person1 p= null;
    
    public static synchronized Person1 getInstance(){  //同步方法
        if (p== null){
            p= new Person1();
        }
        return p;
    }
}
// 2.
public static Person1 getInstance(){
         //耗时，当第一个线程进来后，对象已经造好，后来线程不需要再判断
        synchronized (Person1.class){
            if (p == null)
                p = new Person1();
            return p;
        }
        // 效率高
        /*if (p == null)
            synchronized (Person1.class)
                if (p == null)
                    p = new Person1();
        return p;*/
    }

代理模式

静态代理

/**
 * 主人委托中介卖房子
 * */
//卖房子的接口
interface House1{
    void sellHouse1();
}
//代理类（中介）
class ProxyHouse implements House1{

    private Host1 host1; //真正的主人

    public ProxyHouse(Host1 host1){
        this.host1 = host1;
    }

    @Override
    public void sellHouse1() {
        seeHouse();
        host1.sellHouse1();
        money();
    }

    public void seeHouse(){
        System.out.println("中介带看房");
    }

    public void money(){
        System.out.println("收中介费");
    }
}
//被代理类（主人  ）
class Host1 implements House1{

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void sellHouse1() {
        System.out.println("我是主人"+getName()+"我要卖房子");
    }
}
public class StaticProxyTest {
    public static void main(String[] args) {
        Host1 host1 = new Host1();
        host1.setName("Jack");
        ProxyHouse proxyHouse = new ProxyHouse(host1);
        proxyHouse.sellHouse1();
    }
}
/**结果：
中介带看房
我是主人Jack我要卖房子
收中介费
*/

动态代理

//接口
interface House{
    void rent(); //出租房子
}

//被代理类,真实类
class Host implements House{

    @Override
    public void rent() {
        System.out.println("主人要租房子");
    }
}

class ProxyInvocationHandler implements InvocationHandler{

    //被代理的类，即真实类
    private Object obj;
    public void setObject(Object obj){
        this.obj = obj;
    }

    //获取代理对象
    public Object getProxyInstance(){
        //newProxyInstance(ClassLoader loader, 参数1：代理的那个类的类加载，也即真实类(被代理类)
        //                 Class<?>[] interfaces,  中介 或者 被代理类实现的接口
        //                 InvocationHandler h) //调度处理器
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        //Object invoke(Object obj, Object... args)
        //参数1-obj：被代理类的对象，参数2-args：该方法形参
        Object invoke = method.invoke(obj, args);//通过反射调用方法
        after();
        return invoke;
    }
    public void before(){
        System.out.println("卖房子--前");
    }
    public void after(){
        System.out.println("卖房子--后");  
    }
}

  public class DynamicProxyTest {
    public static void main(String[] args) {
        Host host = new Host(); //真实对象
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setObject(host);
        House proxyInstance = (House) pih.getProxyInstance(); //这才是代理对象
        proxyInstance.rent();  
    }
}
/** 结果
卖房子--前
主人要租房子
卖房子--后
*/

工厂模式

① 实例化对象不使用new ，用工厂方法代替 ② 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们实现的类解耦。

静态(简单)工厂模式

编写Car接口，ACar类，BCar类，CarFactory

//Car接口
public interface Car {
    void name();
}
//ACar 类实现Car接口
public class ACar implements Car{
    @Override
    public void name() {
        System.out.println("我是A车");
    }
}
//BCar 类实现Car接口
public class BCar implements Car{
    @Override
    public void name() {
        System.out.println("我是B车");
    }
}
//CarFactory 工厂类
public class CarFactory {
    public static Car getCar(String car){
        if (car.equals("A车")){
            return new ACar();
        }else if(car.equals("B车")){
            return new BCar();
        }else return null;
    }
}

编写测试类

public void test(){
/**  原始写法
        Car car2 = new ACar();
        car2.name();
        Car car3 = new BCar();
        car3.name();
*/
    //工厂模式的写法  在这里不用new car()对象，也就是不用知道内部造车的细节。只需要通过工厂拿到车即可
        Car car = CarFactory.getCar("A车");  
        car.name();
        Car car1 = CarFactory.getCar("B车");
        car1.name();
    }

该简单工厂模式存在的问题：不遵循开闭原则(开闭原则：不修改原来的代码，同时可以增加模块功能)，若：此时在 加一个CCar类，则工厂CarFactory里面的代码逻辑就要修改，违法了开闭原则。

工厂方法模式

编写Car接口和CarFactory

//Car
public interface Car {
    void name();
}
//CarFactory
public interface CarFactory {
    Car getCar();
}

编写ACar类，AcarFactory类 让AcarFactory实现CarFactory

public class ACar implements Car {
    @Override
    public void name() {
        System.out.println("我是A车");
    }
}
public class ACarFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new ACar();
    }
}

编写BCar类，BcarFactory类 让BcarFactory实现CarFactory

public class BCar implements Car {
    @Override
    public void name() {
        System.out.println("我是B车");
    }
}
public class BCarFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new BCar();
    }
}

编写测试类：

public void test(){
        Car car = new ACarFactory().getCar();  //造A车
        car.name();
        Car car1 = new BCarFactory().getCar();　／／造B车
        car1.name();
    }

当继续扩展C车时，只需要编写CCar类和CCarFactory，实现了开闭原则，但是类增多了

原型模式

其实就是克隆对象。