您是否可以在Java中使用类似于关键字args的概念来最小化访问器方法的数量？

Question

I recently learn that in Python 3, to minimize the number of accessor methods for a class, you can use a dictionaries to essentially just have one set of accessor methods as follows:

def __init__(self, **kwargs):
    self.properties = kwargs

def get_properties(self):
    return self.properties

def get_property(self, key):
    return self.properties.get(key, None)

This seems really useful and I want to apply something similar in Java. I have been working on applications that may have multiple attributes, and creating and keeping track of all the accessor methods can be a pain. Is there a similar strategy that I could use for Java?

Answer 1

Use that pattern if it suits and it fits best but it really should be an exception to the rule in Java - it will probably not be appropriate.

Best practice in Java is to use getter and setter methods for each variable. Yes it's more code - so what - if your lazy get your IDE to auto-generate them. It's there for a very good reason. Many good reasons. Some are;

• Promotes private variables
• Defines an external interface to other classes allowing the class to control what and how to set or get variables
• Promotes good coding practice by establishing a standard way to deal with object variables

The problem you'll encounter here by porting this pattern over is due to typing. Python is dynamically typed and Java is statically typed. So, in order to use the same pattern in Java, you will have to store the values in something like a string/object array and then return them like that as an object or as a String. then you'll have to convert them sometime later. Maybe if your 'properties' were all strings it would be okay. There are exceptions to the rule, but you need to know all of the rules in order to break them well. If they are different types (String, int, CustomObject etc.) don't use the same pattern you use in Python.

Answer 2

No there is no kwargs in java. Instead you can something similar to your function by using java varargs to save them as java properties.

You do you can something like this:

useKwargs("param1=value1","param2=value2");

Example code:

public void useKwargs(String... parameters) {

        Properties properties = new Properties();

        for (String param : parameters) {
            String[] pair = parseKeyValue(param);

            if (pair != null) {
                properties.setProperty(pair[0], pair[1]);
            }

        }

        doSomething(properties);
    }

    public void doSomething(Properties properties) {
        /**
         * Do something using using parameters specified in the properties
         */

    }

    private static String[] parseKeyValue(String token) {
        if (token == null || token.equals("")) {
            return null;
        }

        token = token.trim();

        int index = token.indexOf("=");

        if (index == -1) {
            return new String[] { token.trim(), "" };
        } else {
            return new String[] { token.substring(0, index).trim(),
                    token.substring(index + 1).trim() };
        }

    }

Answer 3

Im not sure if this is helpful to you, but Ill try to answer anyway. I'd first make a class Variable. Then I'd make a class Dictionary with one lists:Variables. Then I'd make the function take a Dictionary as argument.