Java写一套漂亮的代码，哪些设计模式比较常用

设计模式是解决特定问题的优雅且可重用的解决方案，在Java编程中应用广泛。常用的设计模式包括：单例模式、工厂模式、策略模式、观察者模式、装饰器模式、等。其中，单例模式保证了一个类只有一个实例，并提供一个全局访问点。它通常用于管理共享资源，如配置类或日志记录器。

一、单例模式

单例模式保证在应用程序中，一个类只有一个实例存在，并且提供一个全局的访问点。为了实现单例，Java中你可以使用多种方法，如懒汉式、饿汉式、双重校验锁、枚举式等。核心在于私有化构造方法、提供一个公共静态方法返回唯一实例、确保实例的唯一性以及线程安全。

在懒汉式中，实例在首次使用时才被创建，这可以延迟其加载时间。饿汉式则在类加载时就立即初始化，并创建单例对象，没有加锁执行效率会提高，但是类加载时就初始化，没有达到lazy loading的效果。

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

二、工厂模式

工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式，用于创建对象，而不将对象的创建逻辑暴露给客户端。简单工厂通过接收参数来决定创建哪种类型的对象。而工厂方法模式则是定义一个创建对象的接口，让子类决定实例化哪一个类。抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需指定具体类。

public interface Product {
    void doSomething();
}
public class ConcreteProductA implements Product {
    public void doSomething() {
        // 具体操作
    }
}
public class ConcreteProductB implements Product {
    public void doSomething() {
        // 具体操作
    }
}
public abstract class Creator {
    public abstract Product factoryMethod();
}
public class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}
public class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

三、策略模式

策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。适用于有多种类似行为的场合，通过一个策略接口来定义这些行为，并通过具体策略类来实现这个接口，上下文环境类会根据不同情况使用不同策略。

public interface Strategy {
    void executeAlgorithm();
}
public class ConcreteStrategyA implements Strategy {
    @Override
    public void executeAlgorithm() {
        // 具体策略A的算法
    }
}
public class ConcreteStrategyB implements Strategy {
    @Override
    public void executeAlgorithm() {
        // 具体策略B的算法
    }
}
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void executeStrategy() {
        strategy.executeAlgorithm();
    }
}

四、观察者模式

观察者模式定义了对象间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。通常用于实现分布式事件处理系统、新闻订阅、股价更新等场景。

import java.util.ArrayList;
import java.util.List;
public interface Subject {
    void attach(Observer o);
    void detach(Observer o);
    void notifyUpdate(Message m);
}
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    public void attach(Observer o) {
        observers.add(o);
    }
    public void detach(Observer o) {
        observers.remove(o);
    }
    public void notifyUpdate(Message m) {
        for(Observer o: observers) {
            o.update(m);
        }
    }
}
public interface Observer {
    void update(Message m);
}
public class MessageSubscriber implements Observer {
    @Override
    public void update(Message m) {
        System.out.println("MessageSubscriber: " + m.getContent());
    }
}
public class Message {
    private String content;
    public Message(String content) {
        this.content = content;
    }
    public String getContent() {
        return content;
    }
}

五、装饰器模式

装饰器模式允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，作为现有类的一个包装。这对于遵循开闭原则是非常有用的，在不修改原始代码的情况下，增加新功能。

public interface Component {
    void operation();
}
public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        // 原始实现
    }
}
public abstract class Decorator implements Component {
    protected Component wrappedComponent;
    public Decorator(Component component) {
        this.wrappedComponent = component;
    }
    public void operation() {
        wrappedComponent.operation();
    }
}
public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }
    @Override
    public void operation() {
        super.operation();
        addedFunctionality();
    }
    private void addedFunctionality() {
        // 新增的功能
    }
}