在软件开发中，设计模式是一种经过验证的解决方案，它可以帮助开发人员更好地组织和编写代码。设计模式不仅可以提高代码的可读性和可维护性，还可以加速软件开发的进程。
本文将介绍常见的23种设计模式和七大设计模式原则，并对每个模式进行详细解释和示例代码演示。
23种设计模式
创建型模式
创建型模式关注对象的创建过程，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式。
- 简单工厂模式
简单工厂模式通过一个工厂类来创建对象，隐藏了对象创建的细节，并提供了统一的接口，让客户端无需知道具体的实现方式。
代码语言：java复制public class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Invalid product type: " type);
}
}
}- 工厂方法模式
工厂方法模式将对象的创建延迟到子类中处理，通过让子类决定如何创建对象来解耦合。
代码语言：java复制public abstract class Creator {
public abstract Product createProduct();
}
public class ConcreteCreatorA extends Creator {
public Product createProduct() {
return new ConcreteProductA();
}
}
public class ConcreteCreatorB extends Creator {
public Product createProduct() {
return new ConcreteProductB();
}
}- 抽象工厂模式
抽象工厂模式提供一个接口，用于创建相关的一系列产品，而不需要指定具体的实现类。它将工厂方法模式扩展到了多个产品系列上。
代码语言：java复制public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA2();
}
public ProductB createProductB() {
return new ConcreteProductB2();
}
}- 单例模式
单例模式保证一个类只有一个实例，并提供了一个全局访问点，让其他对象可以访问该实例。
代码语言：java复制public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}- 建造者模式
建造者模式将一个复杂对象的创建过程拆分成多个简单的步骤，不同的建造者可以利用这些步骤来构建不同的对象。
代码语言：java复制public class Product {
private String part1;
private String part2;
public void setPart1(String part1) {
this.part1 = part1;
}
public void setPart2(String part2) {
this.part2 = part2;
}
}
public abstract class AbstractBuilder {
protected Product product = new Product();
public abstract void buildPart1();
public abstract void buildPart2();
public Product getResult() {
return product;
}
}
public class ConcreteBuilder extends AbstractBuilder {
public void buildPart1() {
product.setPart1("Part 1");
}
public void buildPart2() {
product.setPart2("Part 2");
}
}
public class Director {
private AbstractBuilder builder;
public Director(AbstractBuilder builder) {
this.builder = builder;
}
public void buildProduct() {
builder.buildPart1();
builder.buildPart2();
}
}- 原型模式
原型模式通过指定一种原型对象来创建新的对象，并且可以通过克隆来创建新的对象。
代码语言：java复制public abstract class Prototype implements Cloneable {
public abstract Prototype clone();
}
public class ConcretePrototypeA extends Prototype {
public Prototype clone() {
try {
return (Prototype) super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
}
public class Client {
private Prototype prototype;
public Client(public Prototype prototype) {
this.prototype = prototype;
}
public Prototype createPrototype() {
return prototype.clone();
}
}结构型模式
结构型模式关注对象的组合方式，包括适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。
- 适配器模式
适配器模式将一个类的接口转换成另一个客户端所期望的接口。它通过封装一个已有的类来实现接口的转换。
代码语言：java复制public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {}
}
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specificRequest();
}
}- 桥接模式
桥接模式将抽象部分和实现部分分离开来，使得它们可以独立变化。它通过将实现细节委托给另一个类来完成这个过程。
代码语言：java复制public abstract class Abstraction {
protected Implementor implementor;
public Abstraction(Implementor implementor) {
this.implementor = implementor;
}
public abstract void operation();
}
public interface Implementor {
void operationImpl();
}
public class ConcreteImplementorA implements Implementor {
public void operationImpl() {}
}
public class RefinedAbstraction extends Abstraction {
public RefinedAbstraction(Implementor implementor) {
super(implementor);
}
public void operation() {
implementor.operationImpl();
}
}- 组合模式
组合模式将一组对象组织成树形结构，以表示“部分-整体”的层次结构。它允许客户端统一处理单个对象和组合对象。
代码语言：java复制public abstract class Component {
protected String name;
public Component(String name) {
this.name = name;
}
public abstract void add(Component component);
public abstract void remove(Component component);
public abstract void display(int depth);
}
public class Leaf extends Component {
public Leaf(String name) {
super(name);
}
public void add(Component component) {}
public void remove(Component component) {}
public void display(int depth) {
System.out.println("-".repeat(depth) name);
}
}
public class Composite extends Component {
private List<Component> children = new ArrayList<>();
public Composite(String name) {
super(name);
}
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
public void display(int depth) {
System.out.println("-".repeat(depth) name);
for (Component component : children) {
component.display(depth 1);
}
}
}- 装饰器模式
装饰器模式可以在不改变原有对象的基础上，通过包装一个装饰器对象来扩展其功能。
代码语言：java复制public abstract class Component {
public abstract void operation();
}
public class ConcreteComponent extends Component {
public void operation() {}
}
public abstract class Decorator extends Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
}
}
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void operation() {
super.operation();
// Add extra behavior
}
}- 外观模式
外观模式提供了一个简单的接口，隐藏了一组子系统复杂的内部结构。它将客户端与子系统之间的依赖关系解耦合。
代码语言：java复制public class Subsystem1 {
public void operation1() {}
}
public class Subsystem2 {
public void operation2() {}
}
public class Facade {
private Subsystem1 subsystem1;
private Subsystem2 subsystem2;
public Facade() {
subsystem1 = new Subsystem1();
subsystem2 = new Subsystem2();
}
public void operation() {
subsystem1.operation1();
subsystem2.operation2();
}
}- 享元模式
享元模式通过共享对象来减少内存中对象的数量，从而提高系统性能。它将对象分为内部状态和外部状态，内部状态可以被共享，而外部状态必须由客户端传入。
代码语言：java复制public interface Flyweight {
void operation(String extrinsicState);
}
public class ConcreteFlyweight implements Flyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
public void operation(String extrinsicState) {}
}
public class FlyweightFactory {
private Map<String, Flyweight> flyweights = new HashMap<>();
public Flyweight getFlyweight(String key) {
if (!flyweights.containsKey(key)) {
flyweights.put(key, new ConcreteFlyweight(key));
}
return flyweights.get(key);
}
}- 代理模式
代理模式在访问对象时引入一个代理对象，以控制原始对象的访问。它可以隐藏对象的实现细节，并提供了一种安全访问对象的方式。
代码语言：java复制public interface Subject {
void request();
}
public class RealSubject implements Subject {
public void request() {}
}
public class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void request() {
// Access control and additional behavior
realSubject.request();
// Additional behavior
}
}七大设计模式原则
- 单一职责原则（SRP）
一个类应该只有一个引起它变化的原因。
- 开放封闭原则（OCP）
软件实体应该对扩展开放，对修改关闭。
- 里氏替换原则（LSP）
子类型必须能够完全替换掉其父类型。
- 接口隔离原则（ISP）
客户端不应该依赖于它不需要的接口。
- 依赖倒置原则（DIP）
高层模块不应该依赖于低层模块，它们应该依赖于抽象接口。抽象接口不应该依赖于具体实现，具体实现应该依赖于抽象接口。
- 迪米特法则（LoD）
一个对象应该对其他对象有最少的了解。
- 组合/聚合复用原则（CARP）
将一组对象组合成一个新的对象时，应该优先使用组合/聚合而不是继承关系来达到复用的目的。
总结
设计模式和设计原则是软件开发中非常重要的概念，它们可以帮助我们更好地理解和设计软件系统。本文介绍了常见的23种设计模式和七大设计模式原则，并提供了详细的示例代码演示。希望读者可以通过本文掌握这些知识，并在实际开发中加以运用。
