Java设计模式

单例模式(Singleton Pattern)

定义:确保一个类只有一个实例,并提供一个全局访问点。

原理:通过私有化构造函数和提供一个静态方法来获取实例。

优点

  • 控制实例数量:保证只有一个实例。

  • 提供全局访问点 :方便在全局范围内访问该实例。

    复制代码
    // 单例类
    public class Singleton {
        // 唯一实例
        private static Singleton instance;
    
        // 私有构造函数,防止外部实例化
        private Singleton() {}
    
        // 提供全局访问点
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();  // 懒汉式加载
            }
            return instance;
        }
    }
    工厂方法模式(Factory Method Pattern)

    定义:定义一个创建对象的接口,但由子类决定实例化哪个类。

    原理:将对象的创建逻辑放在子类中,而不是在客户端代码中。

    优点

  • 灵活性:可以在运行时决定创建对象的类型。

  • 符合开闭原则 :对扩展开放,对修改关闭。

    复制代码
    // 产品接口
    public interface Product {
        void operation();
    }
    
    // 具体产品A
    public class ConcreteProductA implements Product {
        @Override
        public void operation() {
            System.out.println("ConcreteProductA operation");
        }
    }
    
    // 具体产品B
    public class ConcreteProductB implements Product {
        @Override
        public void operation() {
            System.out.println("ConcreteProductB operation");
        }
    }
    
    // 工厂接口
    public abstract class Creator {
        public abstract Product factoryMethod();
    }
    
    // 具体工厂A
    public class ConcreteCreatorA extends Creator {
        @Override
        public Product factoryMethod() {
            return new ConcreteProductA();
        }
    }
    
    // 具体工厂B
    public class ConcreteCreatorB extends Creator {
        @Override
        public Product factoryMethod() {
            return new ConcreteProductB();
        }
    }
    
    // 客户端代码
    public class Client {
        public static void main(String[] args) {
            Creator creator = new ConcreteCreatorA();
            Product product = creator.factoryMethod();
            product.operation();
        }
    }

    抽象工厂模式(Abstract Factory Pattern)

    定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    原理:通过定义多个工厂接口,每个接口负责创建一组相关的对象。

    优点:

    一致性:确保创建的一系列对象具有一致性。

    扩展性:易于扩展产品系列,而不影响现有代码。

    复制代码
    // 产品A接口
    public interface ProductA {
        void operationA();
    }
    
    // 产品B接口
    public interface ProductB {
        void operationB();
    }
    
    // 具体产品A1
    public class ConcreteProductA1 implements ProductA {
        @Override
        public void operationA() {
            System.out.println("ConcreteProductA1 operationA");
        }
    }
    
    // 具体产品B1
    public class ConcreteProductB1 implements ProductB {
        @Override
        public void operationB() {
            System.out.println("ConcreteProductB1 operationB");
        }
    }
    
    // 具体产品A2
    public class ConcreteProductA2 implements ProductA {
        @Override
        public void operationA() {
            System.out.println("ConcreteProductA2 operationA");
        }
    }
    
    // 具体产品B2
    public class ConcreteProductB2 implements ProductB {
        @Override
        public void operationB() {
            System.out.println("ConcreteProductB2 operationB");
        }
    }
    
    // 抽象工厂接口
    public interface AbstractFactory {
        ProductA createProductA();
        ProductB createProductB();
    }
    
    // 具体工厂1
    public class ConcreteFactory1 implements AbstractFactory {
        @Override
        public ProductA createProductA() {
            return new ConcreteProductA1();
        }
    
        @Override
        public ProductB createProductB() {
            return new ConcreteProductB1();
        }
    }
    
    // 具体工厂2
    public class ConcreteFactory2 implements AbstractFactory {
        @Override
        public ProductA createProductA() {
            return new ConcreteProductA2();
        }
    
        @Override
        public ProductB createProductB() {
            return new ConcreteProductB2();
        }
    }
    
    // 客户端代码
    public class Client {
        public static void main(String[] args) {
            AbstractFactory factory = new ConcreteFactory1();
            ProductA productA = factory.createProductA();
            ProductB productB = factory.createProductB();
            productA.operationA();
            productB.operationB();
        }
    }

    观察者模式(Observer Pattern)

    定义:定义对象之间的一对多依赖,使得当一个对象改变状态时,所有依赖于它的对象都得到通知并被自动更新。

    原理:通过定义观察者接口和被观察者类来实现一对多的通知机制。

    优点:

    解耦:观察者和被观察者之间的解耦。

    动态更新:自动更新所有观察者

    复制代码
    import java.util.ArrayList;
    import
    
     java.util.List;
    
    // 观察者接口
    public interface Observer {
        void update(String message);
    }
    
    // 被观察者接口
    public interface Subject {
        void addObserver(Observer observer);
        void removeObserver(Observer observer);
        void notifyObservers(String message);
    }
    
    // 具体被观察者
    public class ConcreteSubject implements Subject {
        private List<Observer> observers = new ArrayList<>();
    
        @Override
        public void addObserver(Observer observer) {
            observers.add(observer);
        }
    
        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
        }
    
        @Override
        public void notifyObservers(String message) {
            for (Observer observer : observers) {
                observer.update(message);
            }
        }
    }
    
    // 具体观察者
    public class ConcreteObserver implements Observer {
        private String name;
    
        public ConcreteObserver(String name) {
            this.name = name;
        }
    
        @Override
        public void update(String message) {
            System.out.println(name + " received: " + message);
        }
    }
    
    // 客户端代码
    public class Client {
        public static void main(String[] args) {
            ConcreteSubject subject = new ConcreteSubject();
            Observer observer1 = new ConcreteObserver("Observer1");
            Observer observer2 = new ConcreteObserver("Observer2");
            subject.addObserver(observer1);
            subject.addObserver(observer2);
    
            subject.notifyObservers("Hello Observers!");
        }
    }
相关推荐
0110_10247 分钟前
tauri + rust的环境搭建---初始化以及构建
开发语言·后端·rust
会开花的二叉树8 分钟前
C++微服务 UserServer 设计与实现
开发语言·c++·微服务
像风一样自由202012 分钟前
Rust Tokio vs Go net/http:云原生与嵌入式生态选型指南
开发语言·golang·rust
DuHz14 分钟前
C程序中的数组与指针共生关系
linux·c语言·开发语言·嵌入式硬件·算法
我星期八休息17 分钟前
C++智能指针全面解析:原理、使用场景与最佳实践
java·大数据·开发语言·jvm·c++·人工智能·python
摇滚侠17 分钟前
Spring Boot 3零基础教程,WEB 开发 整合 Thymeleaf 笔记36
java·spring boot·笔记
大猫会长22 分钟前
docker安装php+apache
java·开发语言
野生技术架构师24 分钟前
JAVA 架构师面试题含答案:JVM+spring+ 分布式 + 并发编程
java·jvm·spring
道之极万物灭36 分钟前
Go小工具合集
开发语言·后端·golang
瑞士卷@36 分钟前
MyBatis入门到精通(Mybatis学习笔记)
java·数据库·后端·mybatis