Java OOP passing 'inner' field

Question

I'm playing with Object-Oriented programming in Java language and I got some idea but I'm now sure is it possible to implement.

class Class()
{
     int a,b,c;
     ...

     public void method(int x){...}
     ...

}

And now is it possible to pass name of variable which is located in that class like this:

obj.method(a);

I know to do this on two ways:
1. To pass obj.a
2. To pass some kind of id and to resolve that id inmethod()

But I'm curious to know is it possible to pass only a name of variable?

Better explanation: My question is it possible to pass string which consist name of variable, and than resolve this in method and get reference to it?

Answer 1

You appear to want to pass the name of a parameter into a method and then do something with that parameter. You seem to be intent on not providing any context of your problem, which leads me to believe you are merely interested in the possibility, and are not looking to use this in actual application code. As such, I will show you for the sake of reference:

public void method(String parameterName) {
    try {
        // We can get the current field value:
        int value = (int) getClass().getField(parameterName).get(this);

        // And update it (for example, set it to 23)
        getClass().getField(parameterName).set(this, 23);
    catch (NoSuchFieldException | IllegalAccessException ex) {
        // Field does not exist or is not public.
    }
}

It can be used as follows (this sets the value of field a to 23 if it exists).

MyClass instance = new MyClass();
instance.method("a");

Note that this requires the field to be public. It is possible to this with non-public fields as well but that is an even worse idea, since it bypasses the entire access control mechanism of Java. There are better solutions which involve using a Map object to implement a similar kind of structure. These are definitely better than using this.

Last remark (I cannot stress this enough): Do not use Reflection calls in actual code! It is always possible to do everything you need to without it (For example, use a Map<String, Integer> instead of individual fields).

Answer 2

It seems like you want to do something to the field of your class: Class? There is a specific set of operations for this in OOP called "mutators". There is also "accessors" to access fields of a class.

Note these are not required of course but it is good practice. Encapsulation is an important feature of object oriented programming, and having direct access to the inner parts of a class can lead to confusion in regards to what a class actually does.

class Class()
{
     int a,b,c;
     ...

     //mutator for a
     public void setA(int newValue)
     {
          //...do something do a?
          a = newValue;
     }

     //accessor for a
     public int getA()
     {
          return a;
     }

}

Now that OOP is covered, you can do what you are asking through reflection, but there are few situations that I think actually warrant the use of reflection and this is not one of them.

Answer 3

I think the poster wants a "multi-purpose-super-dynmic-method", working only on specific attributes of the class definied by the caller.

Your first way is not possible, as your attributes are effectivly protected from direct access by an extern class. You could declare your attributes as public, but this would be a very bad idea. Another option would be to create getters and setters for your attributes and use them instead of directly referencing your attributes. This would be a clean solution and I think the best "OOP-way" to do so.

Your second way is possible, but not so easy to implement. This would need Reflection to access the attributes and can introduce some nasty bugs and unexpected behaviour at runtime. That would also defeat the purpose of using setters and getters to provide access control and validation for your attributes.

Conclusion: Stick to getters and setters. They're very handy and everyone uses them.

Answer 4

If you only want to pass the colour into the object as a string, you could write a switch case for the provided content, like this (using your car example in the comments):

public class Car {
    private String red = "#ff0000";
    private String white = "#ffffff";
    private String black = "#000000";

    public String colour(String colour) {
        String input = colour.toLowerCase();
        switch(input) {
            case "red":
                return red;
                break;
            case "white":
                return white;
                break;
            case "black":
                return black;
                break;
            default:
                System.out.println("The car doesn't come in that colour :(");
                return null;
                break;
        }
    }
}

* Note that the break cases after the returns are unnecessary, but I put them there just to be safe.

However, this does sound like a design flaw in the code. If you just want to access the values in the object I recommend you use getters and setters.