Thread: Implementation problem.

I try to hardcode as little as possible and load my runtime information from files, services, databases, ect.
Apart from making the code more maintainable, I also find it forces me to code very generically, which makes expanding my runtime information at a later time so much easier.

For example, let's say we had rules with different types that we wanted to organize, but we were loading those rules at runtime. We could have classes like these:

public enum RuleType {
	TYPE_ONE,
	TYPE_TWO;
}
 
public class Rule {
	public RuleType type;
	public String name;
	public String details;
 
	public Rule(RuleType type,String name,String details) {
		this.type = type;
		this.name = name;
		this.details = details;
	}
}
 
public class Runner {
	public static void main(String[] args) {
		Map<RuleType,List<Rule>> rules = new HashMap<>();
 
		List<Rule> loadedRules = Helper.loadRules(...);
		// there is more involved in loading, but I can't be bothered
		for(Rule rule : loadedRules) {
			List<Rule> addTo = rules.get(rule.type);
			if(addTo==null) {
				addTo = new ArrayList<>();
			}
			addTo.add(rule);
			rules.put(rule.type,addTo);
		}
 
		for(RuleType type : rules.keySet()) {
			System.out.println("Rules for: "+type.name());
			for(Rule rule : rules.get(type)) {
				System.out.println(rule.name+": "+rule.details);
			}
		}	
	}
}

And here is our input file (in xml for this example):

<rules>
	<rule>
		<type>TYPE_ONE</type>
		<name>Rule Name1</name>
		<details>Rule text 1</details>
	</rule>
	<rule>
		<type>TYPE_TWO</type>
		<name>Rule Name2</name>
		<details>Rule text 2</details>
	</rule>
</rules>

The code would load, organize, and then print the organized rules provided in the input file. Then, if we wanted to add another rule of type: TYPE_TWO, we just need to add it to the input file, and no code changes are needed.

<rules>
	<rule>
		<type>TYPE_ONE</type>
		<name>Rule Name1</name>
		<details>Rule text 1</details>
	</rule>
	<rule>
		<type>TYPE_TWO</type>
		<name>Rule Name2</name>
		<details>Rule text 2</details>
	</rule>
	<rule>
		<type>TYPE_TWO</type>
		<name>Rule Name3</name>
		<details>Rule text 3</details>
	</rule>
</rules>

If you hardcoded these rules, you would probably also hardcoded how you wanted to organize them. By that, I mean you probably wouldn't have given them types, but resolved them in the code, since the values are hardcoded. This would mean that you would then have to also rewrite how you wanted to handle each rule when you hardcode the new rules.
The above would work with hardcoded rules if you provided them with the RuleType values, but you probably wouldn't have considered that flexibility in your design steps if you hardcoded the rules (or, at least, I might not have initially). However, when you load the rules in from a file, you are FORCED to consider that sort of flexibility when you are designing.

You could even make the RuleTypes more abstract by just using Strings which are resolved from the input file instead of enums.
And that's way I mean by "coding generically".

I used XML in the example above because it is a common data format which is easy to read by humans. XML is a possible method of storing your data if you want to. Java has built-in APIs for reading/writing/parsing XML files. A good tutorial can be found here: Reading XML Data into a DOM (The Java™ Tutorials > Java API for XML Processing (JAXP) > Document Object Model)

However, you don't need to do this with XML. You can use any file format, even one you create. For example, you can have:

TYPE_ONE++++Rule Name1++++Rule text 1
TYPE_TWO++++Rule Name2++++Rule text 2
TYPE_TWO++++Rule Name3++++Rule text 3

This format would require more explanation, but it contains the same data. In the above input example, I have each rule on its own line, and I have the data separated with the delimiter: ++++. NOTE: I chose ++++ because you need to choose a delimiter which will not realistically appear in any of your data fields.
As you can see, not nearly as legible as the XML, but serves its purpose just the same.
As a comparison of the two:
Which is a smaller file size? The second one
Which is more structured? The XML one
Which is probably easier to code the reading mechanism for your program? The second one
Which is probably easier for you to edit manually? The XML one
Which is probably easier to notice mistakes and check? The XML one

At the end of the day, you need to assess the tradeoffs and determine which one you are more comfortable using.