Java基础教程（210）设计模式之结构型模式：设计模式之美：深度解析Java结构型模式的七大法宝-优快云博客

结构型模式的核心在于如何将类和对象组合成更大的结构，同时保持结构的灵活和高效。Java提供了七种经典结构型模式，每种都解决特定的架构问题。

1. 适配器模式（Adapter）

连接不兼容接口的桥梁。当需要让原本接口不兼容的类一起工作时，适配器模式充当转换器角色。

// 目标接口
interface MediaPlayer {
    void play(String audioType, String fileName);
}

// 被适配者
class AdvancedMediaPlayer {
    void playMp4(String fileName) {
        System.out.println("Playing mp4: " + fileName);
    }
}

// 适配器
class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedPlayer;
    
    public MediaAdapter() {
        this.advancedPlayer = new AdvancedMediaPlayer();
    }
    
    @Override
    public void play(String audioType, String fileName) {
        if(audioType.equalsIgnoreCase("mp4")){
            advancedPlayer.playMp4(fileName);
        }
    }
}

2. 装饰器模式（Decorator）

动态扩展对象功能，提供比继承更灵活的替代方案。

interface Coffee {
    double getCost();
    String getDescription();
}

class BasicCoffee implements Coffee {
    @Override
    public double getCost() { return 2.0; }
    
    @Override
    public String getDescription() { return "Basic Coffee"; }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;
    
    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }
    
    @Override
    public double getCost() {
        return decoratedCoffee.getCost() + 0.5;
    }
    
    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription() + ", Milk";
    }
}

3. 代理模式（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

interface Image {
    void display();
}

class RealImage implements Image {
    private String fileName;
    
    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }
    
    private void loadFromDisk() {
        System.out.println("Loading " + fileName);
    }
    
    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }
}

class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;
    
    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }
    
    @Override
    public void display() {
        if(realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

4. 组合模式（Composite）

将对象组合成树形结构以表示"部分-整体"的层次结构。

interface Employee {
    void showDetails();
}

class Developer implements Employee {
    private String name;
    
    public Developer(String name) {
        this.name = name;
    }
    
    @Override
    public void showDetails() {
        System.out.println("Developer: " + name);
    }
}

class Manager implements Employee {
    private String name;
    private List<Employee> employees = new ArrayList<>();
    
    public Manager(String name) {
        this.name = name;
    }
    
    public void addEmployee(Employee emp) {
        employees.add(emp);
    }
    
    @Override
    public void showDetails() {
        System.out.println("Manager: " + name);
        for(Employee emp : employees) {
            emp.showDetails();
        }
    }
}

5. 桥接模式（Bridge）

将抽象部分与实现部分分离，使它们都可以独立地变化。

interface Color {
    void applyColor();
}

abstract class Shape {
    protected Color color;
    
    public Shape(Color color) {
        this.color = color;
    }
    
    abstract public void draw();
}

class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }
    
    @Override
    public void draw() {
        System.out.print("Circle drawn with ");
        color.applyColor();
    }
}

class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Red color");
    }
}

6. 外观模式（Facade）

为复杂的子系统提供一个统一的简单接口。

class CPU {
    void start() { System.out.println("CPU started"); }
}

class Memory {
    void load() { System.out.println("Memory loaded"); }
}

class ComputerFacade {
    private CPU cpu;
    private Memory memory;
    
    public ComputerFacade() {
        this.cpu = new CPU();
        this.memory = new Memory();
    }
    
    public void startComputer() {
        cpu.start();
        memory.load();
        System.out.println("Computer started successfully");
    }
}

7. 享元模式（Flyweight）

运用共享技术有效地支持大量细粒度的对象。

interface Shape {
    void draw();
}

class Circle implements Shape {
    private String color;
    
    public Circle(String color) {
        this.color = color;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing circle with color: " + color);
    }
}

class ShapeFactory {
    private static final Map<String, Shape> circleMap = new HashMap<>();
    
    public static Shape getCircle(String color) {
        Circle circle = (Circle)circleMap.get(color);
        
        if(circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating circle of color: " + color);
        }
        return circle;
    }
}

每种结构型模式都有其独特的应用场景和优势。掌握这些模式能够帮助开发者创建更加灵活、可维护和可扩展的软件架构。在实际项目中，经常会出现多种模式结合使用的情况，这需要根据具体需求来选择最合适的模式组合。