通过反射获取 Java 字段，而不是通过其字符串名称

Question

如果我有字段本身，是否可以通过 Java 反射获取字段？这是一个原始的浮动（公共，没问题）。我不想将其名称用作字符串。

例子：

public class TVset {
  public float voltageA;
  public float voltageB;
  public float voltageC;
  public TVset(...) {...} // constructor
  public void function() {...} // it changes voltages
}

class Voltmeter{
  Object theObject;
  Field theField;

  Voltmeter(Object obj) {
    theObject = obj;
    Class theFieldClass = obj.getClass();
    Class theContainerClass = theFieldClass.getDeclaringClass();
    Field theField = ??? // <-- here I don't want to use a String
  }

  float getVoltage() {
    return theField.getFloat(theObject);
  }
}

TVset tv1 = new TVset(...);
TVset tv2 = new TVset(...);

Voltmeter meter = new Voltmeter(tv1.voltageB);
meter.getVoltage();
tv1.function();
meter.getVoltage(); <- should reflect the changed voltage
tv1.function();
meter.getVoltage(); <- should reflect the changed voltage
...

效果类似于通过引用传递浮点数，但没有将其包装到包装类中。

我需要在不同的电视机上测量不同的电压，只需更换线路即可：

Voltmeter meter = new Voltmeter(tv1.voltageB);

到别的地方，比如：

Voltmeter meter = new Voltmeter(tv2.voltageA);

是否可以通过反射来做到这一点？

谢谢

Answer 1

要使用反射，您必须使用字符串。您可以使用对象来包装可变浮点数或简单的浮点数[1]，而不是使用浮点数；

顺便说一句，除非您有充分的理由，否则我不会使用 float，double 的舍入误差要小得多。

public class TVset {
  public double[] voltageA = { 0.0 };
  public double[] voltageB = { 0.0 };
  public double[] voltageC = { 0.0 };
}

class Voltmeter{
  final double[] theField;

  Voltmeter(double[] theField) {
    this.theField = theField;
  }

  double getVoltage() {
    return theField[0];
  }
}
// works just fine.
Voltmeter meter = new Voltmeter(tv1.voltageB);

编辑：使用抽象访问器。这是最快的方法。 AFAIK，差异小于 10 纳秒。

public abstract class Voltmeter{ // or use an interface
  public abstract double get();
  public abstract void set(double voltage);
}

public class TVset {
  private double _voltageA = 0.0;
  private double _voltageB = 0.0;
  private double _voltageC = 0.0;
  public final Voltmeter voltageA = new Voltmeter() {
     public double get() { return _voltageA; }
     public void set(double voltage) { _voltageA = voltage; }
  }
  public final Voltmeter voltageB = new Voltmeter() {
     public double get() { return _voltageB; }
     public void set(double voltage) { _voltageB = voltage; }
  }
  public final Voltmeter voltageC = new Voltmeter() {
     public double get() { return _voltageC; }
     public void set(double voltage) { _voltageC = voltage; }
  }
}

就个人而言，如果速度很关键，我会直接按名称使用字段。您不会比这更简单或更快。

Answer 2

为了完整起见，我已经包含了解决此问题的委托方式。我也不建议让您的花车公开访问。

public class stackoverflow_5383947 {

    public static class Tvset {

        public float voltageA;
        public float voltageB;
        public float voltageC;

        public Tvset() {
        }

        public void function() {
            voltageA++;
        }
    };

    public static class Voltmeter {

        private VoltageDelegate _delegate;

        public Voltmeter(VoltageDelegate delegate) {
            _delegate = delegate;
        }

        float getVoltage() {
            return _delegate.getVoltage();
        }
    };

    public static interface VoltageDelegate {

        public float getVoltage();
    }   

    public static void main(String[] args) {
        final Tvset tv1 = new Tvset();
        Voltmeter meter = new Voltmeter(new VoltageDelegate()   {
            public float getVoltage() {
                return tv1.voltageA;
            }
        });

        System.out.println(meter.getVoltage());
        tv1.function();
        System.out.println(meter.getVoltage());
        tv1.function();
        System.out.println(meter.getVoltage());
    }
}

Answer 3

如果您控制 TVSet 但由于某种原因需要使用反射，避免错误的一个好方法是将您需要的方法/字段名称写为 TVSet 类中的字符串常量。

但是，如果您关心的是性能，那么反射不是可行的方法，因为通过反射访问字段或方法可能比通过 getter 或直接访问要慢得多。

Answer 4

这里有一个变体，您可以在其中提供 float 值而不是字符串。

class Voltmeter{
  Object container;
  Field theField;

  Voltmeter(Object obj, float currentValue) {
    container = obj;
    Class<?> containerClass = obj.getClass();
    Field[] fields = containerClass.getFields();
    for(Field f : fields) {
       if (f.getType() == float.class &&
           f.getFloat(container) == currentValue) {
          this.theField = f;
          break;
       }
    }
  }

  float getVoltage() {
    return theField.getFloat(container);
  }
}

然后这样称呼它：

Voltmeter meter = new Voltmeter(tv1, tv1.voltageB);

仅当电压表创建时的电压不同（而不是 NaN）时它才有效，因为它采用具有正确值的第一个字段。而且我认为它并没有真正更有效。

我不会真的推荐这个。