面向对象设计模式详解（Java版）----三大类

1. 单例模式

说明：确保一个类只有一个实例，并提供全局访问点。常用于线程池、缓存、日志对象等全局唯一资源，避免重复创建造成开销或不一致状态。
作用：控制实例数量，节约内存，提供全局访问入口。
场景：数据库连接池、配置管理器、日志记录器。
关键点：私有构造器，线程安全（双重检查锁或静态内部类），防止反射与序列化破坏单例。

代码示例（菜单配置管理器）：

public class MenuConfig {
    private static MenuConfig instance;
    private String shopName = "快乐汉堡店";
    private MenuConfig() {}

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

    public String getShopName() { return shopName; }
}


public static void main(String[] args) {
    MenuConfig config = MenuConfig.getInstance();
    System.out.println(config.getShopName());  // 快乐汉堡店
}

2. 工厂方法模式

说明：定义创建对象的接口，但由子类决定实例化哪个具体类。将产品实例化延迟到子类，使主类不依赖具体产品，符合开闭原则。
作用：解耦产品创建与使用，支持产品族扩展。
场景：不同品牌汽车生产，日志记录器（文件或数据库）。
关键点：抽象工厂类与具体工厂子类，产品接口，符合开闭原则但对产品族扩展较弱。

代码示例（不同口味汉堡工厂）：

interface Burger { 
    String getInfo();
}

class BeefBurger implements Burger {
     public String getInfo() {
         return "牛肉堡"; 
    } 
}

class ChickenBurger implements Burger {
    public String getInfo() {
        return "鸡肉堡";
    }
}


interface BurgerFactory {
    Burger create();
}

class BeefFactory implements BurgerFactory {
    public Burger create() {
        return new BeefBurger();
    }
}

class ChickenFactory implements BurgerFactory {
    public Burger create() {
        return new ChickenBurger();
    }
}


public class FactoryMethodDemo {
    public static void main(String[] args) {
        BurgerFactory factory = new BeefFactory();
        Burger burger = factory.create();
        System.out.println(burger.getInfo());  // 牛肉堡
    }
}

3. 抽象工厂模式

说明：创建一系列相关或相互依赖的产品族，而不指定具体类。适合需要整体替换产品族（如不同操作系统界面）的场景，保证产品间兼容性。
作用：创建一组配套产品，保证产品间一致性。
场景：跨平台UI组件（Windows或Mac的按钮与输入框），不同数据库操作。
关键点：产品族扩展容易而产品等级扩展难，抽象工厂接口配合多个产品接口。

代码示例（儿童套餐与成人套餐工厂）：

interface Burger {
    String name();
}

interface Drink {
    String name();
}

class SmallBurger implements Burger {
    public String name() {
        return "小汉堡";
    }
}
class SmallCoke implements Drink {
    public String name() {
        return "小可乐";
    }
}
class BigBurger implements Burger {
    public String name() {
        return "大汉堡";
    }
}
class BigCoke implements Drink {
    public String name() {
        return "大可乐";
    }
}
interface MealFactory {
    Burger createBurger();
    Drink createDrink();
}
class KidMealFactory implements MealFactory {
    public Burger createBurger() {
        return new SmallBurger();
    }

    public Drink createDrink() {
        return new SmallCoke();
    }
}

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        MealFactory factory = new KidMealFactory();
        Burger burger = factory.createBurger();
        Drink drink = factory.createDrink();
        System.out.println(burger.name() + " + " + drink.name());  // 小汉堡 + 小可乐
    }
}

4. 建造者模式

说明：将复杂对象的构造与表示分离，同一构造过程可创建不同表示。通过链式调用逐步设置可选参数，清晰构建如披萨、查询请求等多属性对象。
作用：分步构建复杂对象，控制构造顺序和细节。
场景：制作披萨（尺寸、酱料、配料），SQL查询构造器，Lombok的@Builder。
关键点：指挥者、建造者接口与具体建造者，链式调用，内部静态Builder类。

代码示例（汉堡定制）：

public class Hamburger {
    private String size, meat, sauce;

    private Hamburger(Builder b) {
        this.size = b.size;
        this.meat = b.meat;
        this.sauce = b.sauce;
    }

    public static class Builder {
        private String size, meat, sauce;

        public Builder setSize(String size) {
            this.size = size; return this;
        }
        public Builder setMeat(String meat) {
            this.meat = meat; return this;
        }
        public Builder setSauce(String sauce) {
            this.sauce = sauce; return this;
        }
        public Hamburger build() {
            return new Hamburger(this);
        }
    }

    
    public static void main(String[] args) {
        Hamburger burger = new Hamburger.Builder()
            .setSize("大").setMeat("牛肉").setSauce("番茄").build();
        System.out.println(burger.getInfo());  // 大号牛肉堡+番茄
    }
}

5. 原型模式

说明：通过复制现有实例来创建新对象，避免昂贵初始化。实现克隆方法区分深浅拷贝，适合创建成本高且结构相似的对象，如文档模板或图形对象。
作用：避免昂贵初始化开销，快速复制对象。
场景：文档模板克隆，图形编辑器复制图形，缓存对象复制。
关键点：实现Cloneable接口，重写clone方法，区分浅拷贝与深拷贝，原型管理器。

代码示例（汉堡模板克隆）：

class BurgerPrototype implements Cloneable {
    private String type;

    public BurgerPrototype(String type) {
        this.type = type;
    }

    public BurgerPrototype clone() {
        try {
            return (BurgerPrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    public void setType(String type) {
        this.type = type;
    }



    public static void main(String[] args) {
        BurgerPrototype template = new BurgerPrototype("牛肉堡");
        BurgerPrototype copy = template.clone();
        copy.setType("鸡肉堡");
        System.out.println(copy.getType());  // 鸡肉堡
    }
}