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

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）时它才起作用，因为它采用具有正确值的第一个字段。我认为这并没有真正提高效率。

我真的不会推荐这个。