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() {
        // 新增的功能
    }
}

使用以上的设计模式可以帮助你写出一套漂亮、结构清晰且可维护的Java代码。当然，根据实际需求，不同的问题可能需要不同的模式，或是多种模式的组合。不过，在应用设计模式时也要注意避免过度设计，务必根据实际场景需求去选择最合适的设计模式。

相关问答FAQs：

为什么在Java代码中使用设计模式是一种好习惯？

使用设计模式可以提高代码的可读性和可维护性，以及降低代码的复杂性。设计模式提供了经过验证和优化的解决方案，可以在不同情况下重复使用，而无需重新发明轮子。

有哪些常用的设计模式可用于编写漂亮的Java代码？

1. 单例模式（Singleton）：确保类只有一个实例，并提供全局访问点。
2. 工厂模式（Factory）：根据给定的参数或条件创建对象。
3. 装饰器模式（Decorator）：动态地为对象添加额外的职责。
4. 观察者模式（Observer）：定义对象之间的一对多依赖关系，当一个对象状态改变时，它的所有依赖都会收到通知。

如何在Java代码中有效地使用设计模式？

1. 理解设计模式的工作原理：在使用设计模式之前，确保对其原理和用途有深入的了解。
2. 选择合适的设计模式：根据具体情况选择适用的设计模式，避免过度使用或不正确地使用设计模式。
3. 封装设计模式的实现：将设计模式的实现封装在适当的类或接口中，以降低代码的耦合度并提高可维护性。
4. 注重代码质量：编写清晰、易读、可测试和可扩展的代码，同时遵循Java编码规范和良好的设计原则。

注意：以上提到的设计模式只是一部分常用的模式，在实际开发中还有许多其他的设计模式可供选择。