从具有键引用的java公共类中获取值

Question

We have a java public class as,

public class Test {
    public class ob1 {
        public static final String test = "T1T1";
        public static final String test2 = "T7T7";
    }

    public class ob2 {
        public static final String test = "T2T2";
        public static final String test2 = "T8T8";
    }

    public static String getVal(int type, String key) {
        return type == 1 ? ob1.key : ob2.key;
    }
}

How to get the value from class object like,

String t = Test.getVal(1, test);   /// This should return T1T1

String t = Test.getVal(2, test2);  /// This should return T8T8

Answer 1

This is not possible in java to suffix an object with a String to access to a field of it.

Either use reflection to access the fields from the field names or refactor the class so that it provides an implementation key-value with a Map<String,String> for example.

Here is a full example with key-value map.

As ob1 and ob2 are inner classes, these have some limitations about static use (for fields as methods).
So a workaround is declaring the static maps and the static retrieval method in the outer class.
It hurts a little the separation of responsibilities but with these modifier constraints, it is hard to do in a different way but using instance fields and methods in the inner classes.

import java.util.HashMap;
import java.util.Map;

public class Test {

    public class ob1 {
      public static final String test = "T1T1";
      public static final String test2 = "T7T7";
    }

    public class ob2 {
      public static final String test = "T2T2";
      public static final String test2 = "T8T8";
    }

    static Map<String, String> valuesObj1;
    static Map<String, String> valuesObj2;

    static {
      valuesObj1 = new HashMap<>();
      valuesObj1.put("test", ob1.test );
      valuesObj1.put("test2", ob1.test2);

      valuesObj2 = new HashMap<>();
      valuesObj2.put("test", ob2.test);
      valuesObj2.put("test2",ob2.test2);
    }

    public static String getVal(int type, String key) {
      return type == 1 ? valuesObj1.get(key) : valuesObj2.get(key);
    }

    public static void main(String[] args) {
      System.out.println(Test.getVal(1, "test"));
      System.out.println(Test.getVal(2, "test2"));
    }
}

It prints :

T1T1

T8T8

Answer 2

You could use reflection to get the values:

public static String getVal(int type, String key) throws ReflectiveOperationException {
    Class<?> clazz = Class.forName("Test$ob" + type);
    Field field = clazz.getDeclaredField(key);
    return (String) field.get(null);
}

But in general, it is better to maintain a map for your types with inner maps for the key-value-pairs:

Map<String, String> ob1Mapping = new HashMap<>();
ob1Mapping.put("test", "T1T1");
ob1Mapping.put("test2", "");

Map<String, String> ob2Mapping = new HashMap<>();
ob2Mapping.put("test", "T2T2");
ob2Mapping.put("test2", "T8T8");

Map<Integer, Map<String, String>> typeMapping = new HashMap();
typeMapping.put(1, ob1Mapping);
typeMapping.put(2, ob1Mapping);

Now your method becomes as easy as:

public static String getVal(int type, String key) {
    return typeMapping.get(type).get(key);
}

Note, that I intentionally left out failure handling such as unknown types.

Answer 3

public static String getVal(int type, String key) {
    return type == 1 ? ob1.key : ob2.key;
}

This attempts to access a static variable named key in the class ob1 and a another static variable also named key in the class ob2 . Neither class has such a variable and the name is completely unrelated to the parameter named key . This just will not compile no matter how hard you try.

In Java, variable names are only available at compile time (mostly). This means that you cannot use the value of a String variable as a variable name.

Granted there is the Reflection API, but if you find yourself thinking you should use this, you are most likely using the wrong solution for the problem. Reflection is intended for tools, such as IDEs and debuggers.

Answer 4

A solution with reflection:

public class Test {

    public class ob1 {

        public static final String test = "T1T1";
        public static final String test2 = "T7T7";
    }

    public class ob2 {

        public static final String test = "T2T2";
        public static final String test2 = "T8T8";
    }

    public static String getVal(int type, String key) throws Exception {
        return getVal(type == 1 ? ob1.class : ob2.class, key);
    }

    private static String getVal(Class<?> type, String key) throws Exception {
        if (key != null) {
            Field field = type.getDeclaredField(key);
            if (Modifier.isStatic(field.getModifiers()) && field.getType() == String.class) {
                return (String) field.get(null);
            }
        }
        throw new IllegalArgumentException("Wrong argument: "+key);
    }

    public static void main(String[] args) throws Exception {
        System.out.println(Test.getVal(1, "test"));
        System.out.println(Test.getVal(1, "test2"));
        System.out.println(Test.getVal(2, "test"));
        System.out.println(Test.getVal(2, "test2"));
    }
}

It prints:

T1T1
T7T7
T2T2
T8T8

Answer 5

You could use reflection to get to the static Strings. However, instead of using static inner classes, if you have access to class Test, you could refactor it to use a Map.

Answer 6

a solution without reflection and maybe not that clean, but working fine for this example

public static String getVal(int type, String key) {
    if (type == 1) {
        if (key.equalsIgnoreCase("test")) {
            return ob1.test;
        } else {
            return ob1.test2;
        }
    }
    if (type == 2) {
        if (key.equalsIgnoreCase("test")) {
            return ob2.test;
        } else {
            return ob2.test2;
        }
    } else {
        return null;
    }
}

Answer 7

Please find my solution code :-

import java.util.HashMap;
import java.util.Map;

public class Test {

    public class ob1 {
        public static final String test = "T1T1";
        public static final String test2 = "T7T7";
        public ob1() {
              valuesObj1 = new HashMap<>();
              valuesObj1.put("test", ob1.test );
              valuesObj1.put("test2", ob1.test2);


        }
    }

    public class ob2 {
        public static final String test = "T2T2";
        public static final String test2 = "T8T8";
        public ob2() {
              valuesObj2 = new HashMap<>();
              valuesObj2.put("test", test);
              valuesObj2.put("test2",test2);
        }
    }

    static Map<String, String> valuesObj1;
    static Map<String, String> valuesObj2;

    public static String getVal(int type, String key) {
        return type == 1 ? valuesObj1.get(key) : valuesObj2.get(key);
    }

    public static void main(String[] args) {
        Test t =new Test();
         t.new ob1();
         t.new ob2();

        System.out.println(getVal(1, "test"));
    }
}