Java常见的设计模式

1.单例模式

作用：保证整个应用中某个实例

• 饿汉模式

public class Singleton {

    //1.将构造方法私有化，不允许外部直接创建对象
    private Singleton(){

    }
    //2.创建类的唯一实例，使用private static修饰
    private static Singleton instance = new Singleton();

    //3.给外部提供一个用户获取实例的方法，使用public static修饰
    public static Singleton getInstance(){
        return instance;
    }
}

• 懒汉模式

public class Singleton2 {

    private Singleton2(){

    }

    private static Singleton2 instance;

    public static Singleton2 getInstance(){
        if(null == instance){
            instance = new Singleton2();
        }
        return instance;
    }
}

区别：饿汉模式在加载类时就会创建实例，所以加载类比较慢，但运行时获取对象较快，线程安全。懒汉模式则相反，加载类较快，获取对象时较慢，线程不安全。

拓展点：懒汉模式线程不安全点在于当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。这就引出了双重检验锁。

    private volatile static Singleton2 instance;

    public static Singleton2 getInstance(){
        if (instance == null) {
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance ;
    }

使用volatile修饰的原因：instance = new Singleton()；这个操作jvm大概会做三件事。

1. 给 instance 分配内存
2. 调用 Singleton 的构造函数来初始化成员变量
3. 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了

在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用的话顺理成章地报错了。

2.代理模式

远程代理，虚拟代理，保护代理，智能引用代理

public class Car implements Moveable{
    @Override
    public void move() {
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中......");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

public class Car3 implements Moveable{

    private Moveable m;

    public Car3(Moveable m) {
        this.m = m;
    }

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶......");
        m.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶......时间：" + (endtime - starttime) + "毫秒！");

    }
}

public class CarLogProxy implements Moveable{

    private Moveable m;

    public CarLogProxy(Moveable m) {
        this.m = m;
    }
    @Override
    public void move() {
        System.out.println("日志记录开始......");
        m.move();
        System.out.println("日志记录结束......");

    }
}

Car car = new Car();
Car3 car3 = new Car3(car);
CarLogProxy carLogProxy = new CarLogProxy(car3);
carLogProxy.move();

JDK动态代理

public class LogHandler implements InvocationHandler {
        private Object target;

    public LogHandler(Object target) {
        super();
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始记录日志......");
        method.invoke(target);
        System.out.println("日志记录结束......");
        return null;
    }

}

public static void main(String[] args) {
        Moveable moveable = new Car();

        InvocationHandler loghandler = new LogHandler(moveable);

        Class<?> cls = moveable.getClass();


        Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), loghandler);

        m.move();
    }

3.工厂模式

1.工厂模式
2.抽象工厂模式

工厂模式是一种极端的抽象工厂模式，下面就以抽象工厂模式上代码了哈～

举个🌰：一个工厂可以生产两种水果，分别是🍎和🍐，同时这两种水果有区分大小。

public interface Apple {

    public void product();
}
public interface Pear {

    public void pearProduct();
}
public class BigApple implements Apple{
    @Override
    public void product() {
        System.out.println("生产了一个大🍎");
    }
}
public class BigPear implements Pear{
    @Override
    public void pearProduct() {
        System.out.println("生产了一个大🍐");
    }
}
public class SmallApple implements Apple{
    @Override
    public void product() {
        System.out.println("生产了一个小🍎");
    }
}
public class SmallPear implements Pear{
    @Override
    public void pearProduct() {
        System.out.println("生产了一个小🍐");
    }
}

大小工厂

public interface Factory {

    public Apple getApple();
    public Pear getPear();
}
public class BigFactory implements Factory{
    @Override
    public Apple getApple() {
        return new BigApple();
    }

    @Override
    public Pear getPear() {
        return new BigPear();
    }
}

public class SmallFactory implements Factory{
    @Override
    public Apple getApple() {
        return new SmallApple();
    }

    @Override
    public Pear getPear() {
        return new SmallPear();
    }
}

客户端调用

public static void main(String[] args) {

        Factory factory = new BigFactory();
        Apple apple = factory.getApple();
        apple.product();
    }

本文章将持续更新