如何让两个对象共享访问同一对象的数据？类实例数据重置问题

嘿，这个问题其实是开发里很常见的对象状态共享场景，我给你整理几个实用的解决方案，都是日常项目里常用的：

方案1：单例模式（Singleton） #

如果你希望整个应用里只有一个B类实例，不管哪个类调用都是同一个，那单例模式最适合。核心思路是让B类自己控制实例的创建，对外只提供一个获取实例的入口，禁止外部直接new。

举个Java的例子（其他语言思路类似）：

public class B {
    // 私有静态实例，保存唯一的B对象
    private static B instance;

    // 私有构造方法，防止外部通过new创建新实例
    private B() {}

    // 公共方法，返回唯一的实例
    public static B getInstance() {
        // 懒加载：第一次调用才创建实例
        if (instance == null) {
            instance = new B();
        }
        return instance;
    }

    // 你的业务变量和方法
    public int sharedValue;
    public void updateData(int value) {
        this.sharedValue = value;
    }
}

之后不管是类A还是其他类，都通过B.getInstance()获取实例：

// 类A里的调用
public class A {
    public void setBData() {
        B b = B.getInstance();
        b.updateData(100); // 设置共享数据
    }
}

// 另一个类C里的调用
public class C {
    public void readBData() {
        B b = B.getInstance();
        System.out.println(b.sharedValue); // 输出100，和A设置的一致
    }
}

⚠️ 注意：如果是多线程环境，上面的懒加载写法会有线程安全问题，建议用枚举单例或者加同步锁的方式实现。

方案2：依赖注入（Dependency Injection） #

如果你的场景不需要全局唯一的B实例，只是想让特定的几个类共享同一个B对象，那依赖注入是更灵活的选择。核心思路是：先提前创建好一个B实例，然后把这个实例传递给需要它的类（比如A和另一个类），而不是让这些类自己去new B。

例子如下：

// 类A：通过构造方法接收B实例
public class A {
    private B bInstance;

    public A(B b) {
        this.bInstance = b;
    }

    public void modifyBData() {
        bInstance.sharedValue = 200;
    }
}

// 另一个类C：同样接收同一个B实例
public class C {
    private B bInstance;

    public C(B b) {
        this.bInstance = b;
    }

    public void printBData() {
        System.out.println(bInstance.sharedValue); // 输出200
    }
}

// 调用入口
public class Main {
    public static void main(String[] args) {
        // 先创建一个共享的B实例
        B sharedB = new B();
        
        // 把同一个sharedB传给A和C
        A a = new A(sharedB);
        C c = new C(sharedB);
        
        a.modifyBData();
        c.printBData(); // 共享数据生效
    }
}

这种方式的好处是非常灵活：如果需要另一组类共享另一个B实例，只要新建一个B对象注入即可，不会像单例那样全局唯一。而且符合面向对象的依赖倒置原则，代码耦合度更低。

方案3：静态变量（不推荐，仅适用于简单场景） #

如果只是想共享某个具体的数据，而不是整个B对象的状态，可以把B里的变量设为静态的。静态变量属于类本身，所有实例共享同一个值：

public class B {
    // 静态变量，所有B实例共享
    public static int sharedValue;

    public void doSomething() {
        // 业务逻辑
    }
}

之后不管类A还是其他类，不管new多少个B实例，访问B.sharedValue都是同一个值。但这种方式的缺点很明显：静态变量是全局状态，容易导致代码难以维护和调试，不符合对象封装的思想，所以除非是非常简单的场景，否则不推荐使用。

内容的提问来源于stack exchange，提问作者asdfs99