Java中的设计模式：面向对象设计的实用技巧

原创

省赚客开发者 2024-09-09 09:58:10 ©著作权

文章标签 设计模式 Java 工厂方法模式 文章分类 Python 后端开发

©著作权归作者所有：来自51CTO博客作者省赚客开发者的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java中的设计模式：面向对象设计的实用技巧

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

设计模式是软件工程中被广泛应用的一系列最佳实践，它们可以帮助解决常见的软件设计问题。在Java中，设计模式尤其重要，因为它们提供了一套标准的方法来创建灵活且可维护的代码。本文将探讨一些在Java中常用的设计模式及其实现。

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。

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

工厂方法模式

工厂方法模式定义了一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。

public interface Factory {
    Product createProduct();
}

public class ConcreteFactory implements Factory {
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

public class Product {
}

public class ConcreteProduct extends Product {
}

建造者模式

建造者模式允许你分步骤创建复杂对象，并允许只通过必要的步骤构建对象。

public class Builder {
    private Product product;

    public Builder() {
        this.product = new Product();
    }

    public Builder addPart(String part) {
        product.add(part);
        return this;
    }

    public Product build() {
        return product;
    }
}

public class Product {
    public void add(String part) {
        // 添加部件
    }
}

原型模式

原型模式通过复制现有对象来创建新对象，而不是通过新建一个实例。

import java.io.*;

public class Prototype implements Cloneable, Serializable {
    private String id;

    public Prototype(String id) {
        this.id = id;
    }

    public Prototype clone() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Prototype) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

适配器模式

适配器模式允许不兼容的接口协同工作。

public interface Adapter {
    void request();
}

public class ConcreteAdapter implements Adapter {
    private LegacySystem legacySystem;

    public ConcreteAdapter(LegacySystem legacySystem) {
        this.legacySystem = legacySystem;
    }

    public void request() {
        legacySystem.specificRequest();
    }
}

public class LegacySystem {
    public void specificRequest() {
        // 遗留系统的请求
    }
}

装饰器模式

装饰器模式动态地给对象添加额外的功能。

public abstract class Component {
    public abstract void operate();
}

public class ConcreteComponent extends Component {
    public void operate() {
        // 基本操作
    }
}

public abstract class Decorator extends Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public void operate() {
        component.operate();
    }
}

public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    public void operate() {
        super.operate();
        // 添加额外功能
    }
}

观察者模式

观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

import java.util.*;

public interface Observer {
    void update(String message);
}

public interface Subject {
    void register(Observer obj);
    void unregister(Observer obj);
    void notifyObservers();
}

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void register(Observer obj) {
        observers.add(obj);
    }

    public void unregister(Observer obj) {
        observers.remove(obj);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
}

public class ConcreteObserver implements Observer {
    public void update(String message) {
        // 更新逻辑
    }
}

策略模式

策略模式定义了一系列算法，并将每个算法封装起来让它们可以互换。

public interface Strategy {
    int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}