如何使用名称访问Java中的变量？

我试图在一个类中编写一个方法，该类可以被多次调用，每次修改一个类的字段。但是，如果我想修改它，我需要

new

对象并将字段的值设置为它，但是如果在方法中这样做，引用似乎会丢失，并且在调用后字段保持不变

Public class A {
    private Immutable a;  //Immutable class
    private Immutable b;
    public void modify(Immutable k,int v) {
        k=new Immutable(v);  //Now I am trying to pass 
                             //a and b as parameters but they remain unchanged
    }
}

是否有办法将字段名称传递到方法中（例如，将方法

modify（不可变k，int v）

更改为

modify（String kName，int v）

，然后使用字段名称访问它

---

感谢您的输入！

如果您需要通过字符串键访问变量，则应使用

Map\u vars=newhashmap（）；
公共void修改（字符串键，int v）{
_vars.put（键，新不可变（v）；
}

如果需要通过字符串键访问变量，则应使用

Map\u vars=newhashmap（）；
公共void修改（字符串键，int v）{
_vars.put（键，新不可变（v）；
}

据我所知，您试图在给定整数（v）的情况下创建一个新的不可变项。在您的modify方法中，k是一个临时引用。在此处设置值“k=”只会影响此方法中存储的引用，而不会影响您调用modify时使用的任何引用

您当前的客户端代码如下所示：

A a = new A();
Immutable k = new Immutable(x);
a.modify(k, y);

你希望k会改变。你真正想要的不是第三行，而是：

k = new Immutable(y);

---

假设事情真的更复杂，那么我需要更多的信息来进一步帮助您。

据我所知，您正在尝试创建一个给定整数（v）的新不可变项。在您的modify方法中，k是一个临时引用。设置值“k=”在这里，只影响存储在此方法中的引用，而不影响调用modify时使用的任何引用

您当前的客户端代码如下所示：

A a = new A();
Immutable k = new Immutable(x);
a.modify(k, y);

你希望k会改变。你真正想要的不是第三行，而是：

k = new Immutable(y);

---

假设事情真的更复杂，那么我需要更多的信息来进一步帮助您。

Java不支持按名称调用或按引用调用，只支持按值调用。您的

k

变量（方法参数）完全独立于类外使用的任何变量（如果有）

您可以使用反射来支持传递“a”或“b”（或字段对象），但不应该

最好有两种方法：

public void setA(int v) {
    this.a = new Immutable(v);
}

public void setB(int v) {
    this.b = new Immutable(v);
}

---

如果它比单个构造函数调用更复杂，则将公共部分分解为公共方法。

Java不支持按名称调用或按引用调用，只支持按值调用。您的

k

变量（方法参数）完全独立于类外使用的任何变量（如果有）

您可以使用反射来支持传递“a”或“b”（或字段对象），但不应该

最好有两种方法：

public void setA(int v) {
    this.a = new Immutable(v);
}

public void setB(int v) {
    this.b = new Immutable(v);
}

如果它比单个构造函数调用更复杂，则将公共部分分解为一个公共方法。

使用值持有者

public class ValueHolder<T> {
    private T value ;
    public ValueHolder(T value) {
        this.value = value ;
    }
    public T get() { 
        return value ; 
    }
    public void set(T value) { 
        this.value = value; 
    }
    public static <V> ValueHolder<V> make(V value) {
        return new ValueHolder<V>(value);
    }
}
public class Processor {
    private Inmutable a ;
    private Inmutable b ;
    public void modify(ValueHolder<Inmutable> k, int v) {
        k.set(new Inmutable(v));
    }
}

Processor processor = new Processor();
ValueHolder<Inmutable> holder = ValueHolder.make(k);
processor.modify(holder, value);
k = holder.get() ;

公共类价值持有人{
私人T值；
公共估价师（T值）{
这个值=值；
}
公共不获取（）{
返回值；
}
公共无效集（T值）{
这个值=值；
}
公共静态估价师品牌（V值）{
返回新的价值持有人（价值）；
}
}
公共类处理器{
私有不可变a；
私有不可变b；
公共无效修改（价值持有人k，int v）{
k、 集合（新的不可变（v））；
}
}

完成后，您就可以从值持有者那里获得刚刚创建的实例

public class ValueHolder<T> {
    private T value ;
    public ValueHolder(T value) {
        this.value = value ;
    }
    public T get() { 
        return value ; 
    }
    public void set(T value) { 
        this.value = value; 
    }
    public static <V> ValueHolder<V> make(V value) {
        return new ValueHolder<V>(value);
    }
}
public class Processor {
    private Inmutable a ;
    private Inmutable b ;
    public void modify(ValueHolder<Inmutable> k, int v) {
        k.set(new Inmutable(v));
    }
}

Processor processor = new Processor();
ValueHolder<Inmutable> holder = ValueHolder.make(k);
processor.modify(holder, value);
k = holder.get() ;

处理器=新处理器（）；
估价师=估价师。make（k）；
处理器。修改（持有者、值）；
k=holder.get（）；

使用值保持器

public class ValueHolder<T> {
    private T value ;
    public ValueHolder(T value) {
        this.value = value ;
    }
    public T get() { 
        return value ; 
    }
    public void set(T value) { 
        this.value = value; 
    }
    public static <V> ValueHolder<V> make(V value) {
        return new ValueHolder<V>(value);
    }
}
public class Processor {
    private Inmutable a ;
    private Inmutable b ;
    public void modify(ValueHolder<Inmutable> k, int v) {
        k.set(new Inmutable(v));
    }
}

Processor processor = new Processor();
ValueHolder<Inmutable> holder = ValueHolder.make(k);
processor.modify(holder, value);
k = holder.get() ;

公共类价值持有人{
私人T值；
公共估价师（T值）{
这个值=值；
}
公共不获取（）{
返回值；
}
公共无效集（T值）{
这个值=值；
}
公共静态估价师品牌（V值）{
返回新的价值持有人（价值）；
}
}
公共类处理器{
私有不可变a；
私有不可变b；
公共无效修改（价值持有人k，int v）{
k、 集合（新的不可变（v））；
}
}

完成后，您就可以从值持有者那里获得刚刚创建的实例

public class ValueHolder<T> {
    private T value ;
    public ValueHolder(T value) {
        this.value = value ;
    }
    public T get() { 
        return value ; 
    }
    public void set(T value) { 
        this.value = value; 
    }
    public static <V> ValueHolder<V> make(V value) {
        return new ValueHolder<V>(value);
    }
}
public class Processor {
    private Inmutable a ;
    private Inmutable b ;
    public void modify(ValueHolder<Inmutable> k, int v) {
        k.set(new Inmutable(v));
    }
}

Processor processor = new Processor();
ValueHolder<Inmutable> holder = ValueHolder.make(k);
processor.modify(holder, value);
k = holder.get() ;

处理器=新处理器（）；
估价师=估价师。make（k）；
处理器。修改（持有者、值）；
k=holder.get（）；

谢谢！不过有两个问题：第一，为什么不应该使用反射？第二，如果我有一堆不同的字段，是否没有方便的方法访问它们？这是一个风格问题。你的类的客户应该不知道你的字段，这是你的类的私有领域。因此说“请将你的字段x设置为y”这不是正确的做法。如果你真的有很多这样的属性，请使用Unholy Sampler提出的映射。谢谢！但有两个问题：第一，为什么不应该使用反射？第二，如果我有一堆不同的字段，是否没有方便的方法访问它们？这是一个风格问题。你的类的客户端应该不知道这是你的职业的私人地形。因此说“请将你的职业x设置为y”是不正确的。如果你真的有很多这样的属性，使用地图，就像邪恶采样器建议的那样。