设计模式指南：结构型模式（桥接模式、外观模式、享元模式、适配器模式）

在设计模式的世界中，结构型模式扮演着至关重要的角色，它提供了将类和对象组合成更大结构的方法。在这篇文章中，我们将探讨四种常见的结构型模式：桥接模式、外观模式、享元模式和适配器模式。

桥接模式

想象一下，你想为一辆车设计一个引擎和一个变速箱。每种发动机类型（汽油、柴油或电动）都可以与多种变速箱类型（手动、自动或无级变速）配合使用。使用桥接模式，你可以将这两类解耦，以便独立于对方进行修改。

桥接模式的优点：

• 提高了类的灵活性，允许在不影响客户端的情况下修改类的行为。
• 减少了类的数量，因为不再需要为每种组合创建单独的类。

外观模式

当你需要与一个复杂的子系统交互时，外观模式可以简化接口。它提供了一个统一的界面，隐藏了子系统的内部细节。

外观模式的优点：

• 使得客户端代码更容易维护，因为客户端只需与外观对象交互。
• 提高了子系统可扩展性，允许在不影响客户端的情况下更改子系统实现。

享元模式

享元模式用于优化对象的创建，特别是在需要创建大量相似对象的场景中。它通过存储和重用共享对象来减少内存消耗。

享元模式的优点：

• 减少了内存使用，提高了性能。
• 降低了对象创建的开销，从而提高了效率。

适配器模式

适配器模式允许对象与不兼容的接口进行交互。它充当了桥梁，将一个对象的接口转换为另一个对象需要的接口。

适配器模式的优点：

• 增加了类的可重用性，允许在不同接口之间进行转换。
• 提高了系统的灵活性，使得不同的类可以协同工作，即使它们的接口不兼容。

桥接模式示例：

public interface Engine {
    void start();
}

public class PetrolEngine implements Engine {
    @Override
    public void start() {
        // ...
    }
}

public class DieselEngine implements Engine {
    @Override
    public void start() {
        // ...
    }
}

public interface Transmission {
    void gearUp();
}

public class ManualTransmission implements Transmission {
    @Override
    public void gearUp() {
        // ...
    }
}

public class AutomaticTransmission implements Transmission {
    @Override
    public void gearUp() {
        // ...
    }
}

public class Car {
    private Engine engine;
    private Transmission transmission;

    public Car(Engine engine, Transmission transmission) {
        this.engine = engine;
        this.transmission = transmission;
    }

    public void startCar() {
        engine.start();
    }

    public void gearUp() {
        transmission.gearUp();
    }
}

外观模式示例：

public interface ComplexSubSystem {
    void operation1();
    void operation2();
    void operation3();
}

public class ComplexSubSystemImpl implements ComplexSubSystem {
    @Override
    public void operation1() {
        // ...
    }

    @Override
    public void operation2() {
        // ...
    }

    @Override
    public void operation3() {
        // ...
    }
}

public class Facade {
    private ComplexSubSystem subSystem;

    public Facade() {
        subSystem = new ComplexSubSystemImpl();
    }

    public void doSomething() {
        subSystem.operation1();
        subSystem.operation2();
        subSystem.operation3();
    }
}

享元模式示例：

public class ShapeFactory {
    private Map<String, Shape> shapes = new HashMap<>();

    public Shape getShape(String shapeType) {
        if (!shapes.containsKey(shapeType)) {
            shapes.put(shapeType, new Shape(shapeType));
        }
        return shapes.get(shapeType);
    }
}

public class Shape {
    private String type;

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

    public String getType() {
        return type;
    }
}

适配器模式示例：

public interface Target {
    void operation();
}

public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void operation() {
        adaptee.specificOperation();
    }
}

public class Adaptee {
    public void specificOperation() {
        // ...
    }
}

结构型设计模式提供了强大的工具，可以改善代码的设计和可维护性。通过了解和使用这些模式，开发者可以创建灵活、可扩展和高效的软件系统。