常见设计模式

AI时代，做一个古法编程逆行者 ：）

最近 vibecoding 太多，手写一会儿代码，还别有一番风味~

---

单例模式：

懒汉式：

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

饿汉式：

public class Singleton{
	private static final Singleton instance = new Singleton();
	private Singleton(){};
	public static Singleton getInstance(){
		return instance;
	}
}

静态内部类：

public class Singleton{
	private Singleton(){};
	private static class Create{
		static final Singleton instance = new Singleton();
	}
	public static Singleton getInstance(){
		return Create.instance;
	}
}

工厂模式：

简单工厂模式：

interface Button{
	void create();
}
public class WindowsButton implements Button{
	public void create(){
		System.out.println("Windows按钮创建成功！");
	}
}
public class MacButton implements Button{
	public void create(){
		System.out.println("Mac按钮创建成功！");
	}
}
public class ButtonFactory{
	public static Button createButton(String type){
		if("Windows".equalsIgnoreCase(type)){
			return new windowsButton;
		}
		else if("Mac".equalsIgnoreCase(type)){
			return new macButton;
		}
		else{
			throw new IllegalArgumentException("暂不支持该平台类型"+type);
		}
	}
}

工厂方法模式：复用上方的Button接口和两种实现类，将工厂解耦，这样添加商品时，只需要增加类，不需要修改旧类。

interface ButtonFactory{
	Button create();
}
public class WindowsButtonFactory implements ButtonFactory{
	public Button create(){
		return new WindowsButton();
	}
}
public class MacButtonFactory implements ButtonFactory{
	public Button create(){
		return new MacButton();
	}
}

抽象工厂模式：就是在工厂方法里面返回产品族。

interface Checkbox{
	void create();
}
public class WindowsCheckbox implements Checkbox{
	public void create(){
		System.out.println("Windows复选框创建成功！");
	}
}
public class MacCheckbox implements Checkbox{
	public void create(){
		System.out.println("Mac复选框创建成功！");
	}
}
interface AbstractFactory{
	Button createButton();
	Checkbox createCheckbox();
}
public class WindowsFactory implements AbstractFactory{
	public WindowsButton createButton(){
		return new WindowsButton();
	}
	public WindowsCheckbox createButton(){
		return new WindowsCheckbox();
	}
}
public class MacFactory implements AbstractFactory{
	public MacButton createButton(){
		return new MacButton();
	}
	public MacCheckbox createCheckbox(){
		return new MacCheckbox();
	}
}

策略模式：

interface PayStrategy{
	void pay(int amount);
}
class WeChat implements PayStrategy{
	public void pay(int amount){
		System.out.println("微信支付成功！");
	}
}
class Credit implements PayStrategy{
	public void pay(int amount){
		System.out.println("信用卡支付成功！");
	}
}
class Pay{
	private PayStrategy strategy;
	public void setPayStrategy(PayStrategy strategy){
		this.strategy = strategy;
	}	
	public void checkOut(int amount){
		strategy.pay(amount);
	}
}

责任链模式：

abstract class Approver{
	protected Approver next;
	public abstract void handleRequest(int leaveDays);
	public void setNext(Approver next){
		this.next = next;
	}
}
class Boss extends Approver{
	public void handleRequest(int leaveDays){
		System.out.println("通过");
	}
}
class Manager extends Approver{
	public void handleRequest(int leaveDays){
		if(leaveDays<7){
			System.out.println("通过");
		}
		else if(next!=null){
			next.handleRequest(leaveDays);
		}
	}
}
class GroupLeader extends Approver{
	public void handleRequest(int leaveDays){
		if(leaveDays<2){
			System.out.println("通过");
		}
		else if(next!=null){
			next.handleRequest(leaveDays);
		}
	}
}
class Main{
	public static void main(String[] args){
		Boss a = new Boss();
		Manager b = new Manager();
		GroupLeader c = new GroupLeader();
		c.setNext(b);
		b.setNext(a);
		c.handleRequest(7);
	}
}

更新补充 ：

装饰器模式：

abstract class MyInputStream{
	abstract public void run();
}
class FileInputStream extends MyInputStream{
	@Override
	public void run(){
	System.out.println("文件输入流");
	}
}
abstract class FilterInputStream extends MyInputStream{
	private MyInputStream in;
	public FilterInputStream(MyInputStream in){
		this.in = in;
	}
	@Override
	public void run(){
		in.run();
	}
}
class BufferInputStream extends FilterInputStream{
	public BufferInputStream(MyInputStream in){
		super(in);
	}
	@Override
	public void run(){
		super.run();
		System.out.println("输入缓冲池");
	}
}
class EpInputStream extends FilterInputStream{
	public EpInputStream(MyInputStream in){
		super(in);
	}
	@Override
	public void run(){
		super.run();
		System.out.println("加密处理");
	}
}
class Main{
	public static void main(String[] args){
		FileInputStream in = new FileInputStream();
		BufferInputStream bi = new BufferInputStream(in);
		EpInputStream ei = new EpInputStream(bi); 
		ei.run();
	}
}