java项目中使用的设计模式，java几种常用的设计模式

更新： 2025-03-09 11:54:37 编辑：268网络 归类： 资讯教程 人气：

在现代软件开发中，设计模式是解决常见软件架构问题的重要工具。设计模式提供了一种成熟的解决方案，使开发者能够以更高效的方式构建可维护、可扩展的代码。本文将探讨几种在Java项目中常用的设计模式，帮助开发者更好地理解并应用这些概念。

一、创建型模式

创建型模式主要关注对象的创建过程，以适应不同的需求。常见的创建型设计模式有单例模式、工厂模式和抽象工厂模式等。

1. 单例模式

单例模式确保一个类只有一个实例，并提供全局访问点。这种模式常用于需要共享资源的场合。

例如，在Java的数据库连接池中，单例模式可以确保只有一个连接池实例。实现单例模式的常用方法是使用饿汉式或懒汉式：

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

2. 工厂模式

工厂模式通过定义一个创建对象的接口，让子类决定实例化哪一个类，从而达到解耦的效果。常见于需要创建复杂对象的场景。

在Java中，工厂方法可以用来创建不同类型的产品对象，如下所示：

public interface Product {
    void use();
}
public class ConcreteProductA implements Product {
    public void use() {
        System.out.println(使用产品A);
    }
}
public class ConcreteProductB implements Product {
    public void use() {
        System.out.println(使用产品B);
    }
}
public abstract class Creator {
    public abstract Product factoryMethod();
}
public class ConcreteCreatorA extends Creator {
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}
public class ConcreteCreatorB extends Creator {
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

二、结构型模式

结构型模式主要关注对象或类的组合。它的核心在于如何通过组合来实现更大的功能。常见的结构型设计模式有适配器模式、装饰模式和代理模式等。

1. 适配器模式

适配器模式用于将一个类的接口转换成客户端所期望的另一个接口。它允许不兼容的接口之间进行合作。

举个例子，假设我们有一个老旧的接口需要被新的系统兼容，可以用适配器模式如下实现：

public interface Target {
    void request();
}
public class Adaptee {
    public void specificRequest() {
        System.out.println(旧接口的具体请求);
    }
}
public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    public void request() {
        adaptee.specificRequest();
    }
}

2. 装饰模式

装饰模式允许在不改变对象的结构的情况下，动态地给一个对象添加一些额外的职责。这种模式的使用非常灵活。

例如，假设你有一个基础的咖啡类，想在不修改原有类的情况下为其添加糖和牛奶，可以通过装饰模式实现：

public interface Coffee {
    String getDescription();
    double cost();
}
public class SimpleCoffee implements Coffee {
    public String getDescription() {
        return 普通咖啡;
    }
    public double cost() {
        return 5.0;
    }
}
public abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
}
public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }
    public String getDescription() {
        return coffee.getDescription() + , 牛奶;
    }
    public double cost() {
        return coffee.cost() + 1.0;
    }
}
public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }
    public String getDescription() {
        return coffee.getDescription() + , 糖;
    }
    public double cost() {
        return coffee.cost() + 0.5;
    }
}

三、行为型模式

行为型模式主要关注对象之间的交互和责任分配。常见的行为型设计模式有观察者模式、策略模式和状态模式等。

1. 观察者模式

观察者模式定义了一种一对多的依赖关系，使得一个对象（主题）的状态发生变化时，所有依赖于它的对象（观察者）都能得到通知并更新。这种模式常用于实现事件驱动机制。

例如，在Java中，一个简单的观察者模式实现：

public interface Observer {
    void update(String message);
}
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}
public class ConcreteSubject implements Subject {
    private List observers = new ArrayList<>();
    private String state;
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}