There are 3 parts to this.
1. Determine how to save a file. I'd use spaces to separate the digits.
2. Get save to work
3. Get load to work

1 is basically done
2 is easy.. just make a string, and output all the numbers to that, with spaces between..
ie
String str = "";
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
if(j > 0){
str += " "; // add a space if it's not the first digit
}
str += ""+arr[i][j];
}
str += "\n"; // new line
}

then, save the string. look up saveStrings in the reference

3.
loadStrings give you an array of lines
then you just have to split each line on space, and you'll have your array

good luck!

Ah, like seltar, I initially misunderstood the question...

For what it is worth, I did something similar in a version of my (unpublished yet) fern drawing sketch: I made a generic code to draw ferns using trunk, branches, leaves, with variations on angles, lengths, colors.
The base drawing unit of my sketch is a line segment.
So, in a .java file, I defined an abstract class Segment, base class of Trunk, Branch, Leaf classes, each instance holding a Genotype reference.

Genotype is an interface (that's why I had to make a .java file, interfaces cannot be internal to a class).

interface Genotype
{
float GetBaseLength(Segment seg);
float GetLength(Segment seg);
float GetBaseWidth(Segment seg);
float GetWidth(Segment seg);
float GetAbsoluteAngle(Segment seg, boolean bIsLeft);
float GetAngle(Segment seg, boolean bIsLeft);
int GetBaseColor(Segment seg);
int GetColor(Segment seg);
boolean ShouldAddSegment(Segment seg);
}

Then I have a number of genotype .pde files, currently unimaginatively named Genotype01 to Genotype09, implementing Genotype, where I can make more or less convoluted variations on these parameters.

Advantage: no need for reflection, natural OO approach, .pde files act as script files (although you need Processing to add them and they have to be known by the final sketch).

Hope it will give you some ideas.

If you are curious, you can see a static view of the result at Ferns - Static view.
I made a short video with QuickTime, but due to lack of time (it was for a kind of challenge), I didn't made the ferns to grow as I wanted, but just appear and disappear at various times, and move everything regularly to the left...
I should finish this sketch someday.

To answer your question, my abstract Segment class has a Genotype member. I use that in the derivated classes, to set settings based on support segment, eg. for Leaf:

SetWidth(m_genotype.GetBaseWidth(baseBranch));
SetLength(m_genotype.GetBaseLength(baseBranch));
SetAbsoluteAngle(m_genotype.GetAbsoluteAngle(baseBranch, m_bIsLeftLeaf));
SetColor(m_genotype.GetBaseColor(baseBranch));

I made a fern class taking a genotype in the constructor:

Fern(Genotype genotype, float startTime, float endTime)
{
 this(null, genotype, startTime, endTime);
}

The times indicate when the fern appeared and disappeared in the movie.
And I created a bunch of ferns put in an ArrayList with:

ferns.add(new Fern(new Genotype07(), 0.45, 0.67));// Big

There are some things I might redo today, but the design was relatively flexible.

It shouldn't be hard to select a class from user input.
Something like:

Genotype g;
switch (choice) {
case LEFT: g = new GenotypeLeft(); break;
case RIGHT: g = new GenotypeRight(); break;
//[...]
default: g = new GenotypeFoo(); break;
}

switch is often frown upon, these days, but allows simple, efficient code...
Or you can use an enum. In a .java file, since 1.5 syntax isn't yet supported by Processing, AFAIK.

Ah, bah, I like the forum discussion, and who know, perhaps somebody will find ideas in our discussion...

"add one condition for each effect", "reading a directory a listing all files"?
Unless I misunderstood the purpose, you have to compile everything, with PDE or something else. It isn't so much dynamic. The logic works with interpreted languages, not so much with (semi-)compiled ones. So adding conditions isn't so much a constraint.
But of course, that's just my point of view, using Class.forName() is perfectly valid too, AFAIK it is often used to manage plugins and similar, which isn't far from your approach.
There is rarely (never?) an unique truth in programming!