Android中如何从另一个类修改实例变量？

嘿，我懂你这种困惑——之前操作视图时传个Activity，直接调用findViewById()就能搞定，但轮到自己的变量，既没法直接activity.variable访问，用getter又总觉得有点别扭对吧？我给你几个实用的方案，帮你优雅实现这种回调操作变量的需求：

这个思路和你用Activity操作视图的逻辑异曲同工，只不过是针对变量操作自定义接口，让原类（比如你的Activity）实现接口，把接口实例传给另一个类，回调时直接调用接口方法就行，完全不用暴露整个Activity或者变量本身。

举个具体的代码例子：
首先定义一个回调接口，按需提供变量的操作方法：

public interface VariableCallback {
    // 可以根据需求自定义方法，比如获取变量、修改变量
    int getTargetVariable();
    void updateTargetVariable(int newValue);
}

然后让你的Activity实现这个接口：

public class MainActivity extends AppCompatActivity implements VariableCallback {
    private int myVariable = 10; // 你要操作的目标变量

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // 创建工作类实例，把回调接口传过去
        WorkerClass worker = new WorkerClass(this);
        worker.doSomeWork();
    }

    @Override
    public int getTargetVariable() {
        return myVariable;
    }

    @Override
    public void updateTargetVariable(int newValue) {
        myVariable = newValue;
        // 这里还能加变量更新后的逻辑，比如刷新UI
    }
}

最后在WorkerClass（另一个执行任务的类）里调用回调：

public class WorkerClass {
    private VariableCallback callback;

    public WorkerClass(VariableCallback callback) {
        this.callback = callback;
    }

    public void doSomeWork() {
        // 先执行自己的业务逻辑
        Log.d("Worker", "正在处理任务...");
        
        // 需要操作原类变量时，调用回调方法
        int currentValue = callback.getTargetVariable();
        callback.updateTargetVariable(currentValue + 5);
    }
}

这种方式既安全，又不会暴露原类的无关成员，完全是按需提供变量操作能力。

如果你的项目支持Java8或者用Kotlin，完全可以用Lambda来简化接口实现，不用写一堆冗余的接口代码，逻辑更紧凑。

比如Java里用函数式接口：

// 定义函数式接口（只有一个抽象方法）
@FunctionalInterface
public interface VariableUpdater {
    void update(int currentValue);
}

然后在Activity里直接传Lambda给WorkerClass：

public class MainActivity extends AppCompatActivity {
    private int myVariable = 10;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        WorkerClass worker = new WorkerClass((currentVal) -> {
            // 在这里直接操作变量
            myVariable = currentVal + 5;
        });
        worker.doSomeWork();
    }
}

WorkerClass的代码也可以更简洁：

public class WorkerClass {
    private VariableUpdater updater;

    public WorkerClass(VariableUpdater updater) {
        this.updater = updater;
    }

    public void doSomeWork() {
        // 执行任务后，直接调用updater更新变量
        updater.update(myVariable); // 如果需要原变量值，也可以再加个Supplier<Integer>接口传入
    }
}

这种方式适合简单的回调场景，代码量少，逻辑一目了然。

如果你的变量不止一个，或者有很多相关的操作逻辑，可以把变量封装成一个单独的持有类，把这个实例传给WorkerClass，WorkerClass直接调用持有类的getter/setter即可，不用暴露整个Activity。

比如：

public class VariableHolder {
    private int myVariable;

    public VariableHolder(int initialValue) {
        this.myVariable = initialValue;
    }

    public int getMyVariable() {
        return myVariable;
    }

    public void setMyVariable(int myVariable) {
        this.myVariable = myVariable;
        // 还可以在这里加监听，比如变量变化时通知原类
    }
}

然后在Activity里使用：

public class MainActivity extends AppCompatActivity {
    private VariableHolder holder = new VariableHolder(10);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        WorkerClass worker = new WorkerClass(holder);
        worker.doSomeWork();
    }
}

WorkerClass的代码：

public class WorkerClass {
    private VariableHolder holder;

    public WorkerClass(VariableHolder holder) {
        this.holder = holder;
    }

    public void doSomeWork() {
        int current = holder.getMyVariable();
        holder.setMyVariable(current + 5);
    }
}

这种方式适合变量逻辑复杂的场景，把变量的操作都封装在持有类里，职责更清晰。

最后提醒一句：不管用哪种方式，都要注意避免内存泄漏——如果WorkerClass是异步任务，记得用WeakReference持有回调或者持有类，不然会导致Activity无法被系统回收哦。

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