[设计模式] 5 种常见设计模式的 Java 实现

单例模式

饿汉式

public class Singleton {
    // 构造函数私有化
    private Singleton() {}
	// 我很饥饿，在这里就直接创建实例
    private static Singleton instance = new Singleton();
	// 提供一个全局访问点
    public static Singleton getIinstance() {
        return instance;
    }
}

懒汉式

public class Singleton {
    
    private Singleton() {}
    
    private static Singleton instance;
 	// 我比较懒，等到方法被调用时再初始化
    public static Singleton getIinstance() {
        if (instance == null) {
        	instance = new Singleton();
        }
        return instance;
    }
}

双重锁校验

public class Singleton {
    
    private Singleton() {}
	// 保证 instance 每次都是从主存中读取
    private static volatile Singleton instance;

    public static Singleton getIinstance() {
        // 第一层判断，避免每次都进入同步状态
        if (instance == null) {
        	synchronized (Singleton.class) {
                // 第二层判断，在 null 情况下创建实例
            	if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

责任链模式

// 也可以用接口实现
public abstract class Handler {

    protected Handler nextHandler;

    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }

    public abstract void handle(int level);
}

class Handler1 extends Handler{
    @Override
    public void handle(int level) {
        if (level >= 1) {
            System.out.println("当前是第一级");
        }
        nextHandler.handle(level);
    }
}

class Handler2 extends Handler {
    @Override
    public void handle(int level) {
        if (level >= 2) {
            System.out.println("当前是第二级");
        }
        nextHandler.handle(level);
    }
}

class Handler3 extends Handler {
    @Override
    public void handle(int level) {
        if (level >= 3) {
            System.out.println("当前是第三级");
        }
    }
}
// Test code
Handler1 h1 = new Handler1();
Handler2 h2 = new Handler2();
Handler3 h3 = new Handler3();
h1.setNextHandler(h2);
h2.setNextHandler(h3);

h1.handle(1);
h1.handle(2);
h1.handle(3);

建造者模式

public class Computer {

	private String cpu;
    private String gpu;
    private String display;
    private String keyboard;
    
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.display = builder.display;
        this.keyboard = builder.keyboard;
    }
	
    public static class Builder {
    
        private String cpu;
        private String gpu;
        
        public Builder(String cpu, String gpu) {
            this.cpu = cpu;
            this.gpu = gpu;
        }
        
        public Builder setDisplay(String display) {
            this.display = display;
        }
        
        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
        }
        
        public Computer build() {
            return new Computer(this);
        }
    }
}
// Test Code
Computer computer = new Computer.Builder("Intel", "Nvidia")
    .setDisplay("Samsung")
    .setKeyboard("Razer")
    .build();

工厂模式（简单工厂、反射工厂）

public interface Product {
    void produce();
}

class ProductA implements Product {
    @Override
    public void produce() {
        System.out.println("A");
    }
}

class ProductB implements Product {
    @Override
    public void produce() {
        System.out.println("B");
    }
}
// 简单工厂
class ProductFactory {
    public static Product getProduct(String product) {
        if (product == null) {
            return null;
        } else if (product.equals("A")) {
            return new ProductA();
        } else if (product.equals("B")) {
            return new ProductB();
        }
        return null;
    }

    public static void main(String[] args) {
        ProductFactory.getProduct("A").produce();
    }
}
// 反射工厂
class ReflectFactory {
    public static Product getProduct(String className) {
        return (Product) Class.forName(className).newInstance();
    }

    public static void main(String[] args) {
        ReflectFactory.getProduct("pattern.factory.ProductA").produce();
    }
}

代理模式（静态代理、动态代理）

public interface ProxyInterface {
    void doSomething();
}

class ProxyImpl implements ProxyInterface {

    @Override
    public void doSomething() {
        System.out.println("do something");
    }
}
// 静态代理
class StaticProxy implements ProxyInterface {

    private ProxyInterface custom = new ProxyImpl();

    @Override
    public void doSomething() {
        System.out.println("代理开始");
        custom.doSomething();
        System.out.println("代理结束");
    }

    public static void main(String[] args) {
        new StaticProxy().doSomething();
    }
}
// 动态代理
class DynamicProxy implements InvocationHandler {

    private ProxyInterface custom = new ProxyImpl();

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理开始");
        Object result = method.invoke(custom, args);
        System.out.println("代理结束");
        return result;
    }

    public static void main(String[] args) {
        ProxyInterface proxy = (ProxyInterface) Proxy.newProxyInstance(
                ProxyImpl.class.getClassLoader(),
                ProxyImpl.class.getInterfaces(),
                new DynamicProxy()
        );
        proxy.doSomething();
    }
}