Make a methods array for call

What you've got is not an array of methods, it is an array of booleans. Each method is called at the moment the array is created, and the return values of these ten methods become values in the array.

If you would like to make an array of something that you can call, make an array of interface implementations that have a method returning boolean. The way you do this depends on the version of Java. Prior to Java 8, you would do it like this:

interface Predicate {
    boolean test();
}
Predicate[] assertionsArray = new Predicate[] {
    new Predicate() {public boolean test() {return assert0(); }}
,   new Predicate() {public boolean test() {return assert1(); }}
,   new Predicate() {public boolean test() {return assert2(); }}
...
,   new Predicate() {public boolean test() {return assert9(); }}
};

Now you can call the assertions like this:

if (assertionsArray[figureIndex].test()) {
    ...
}

Starting with Java 8 you can use the predicate interface included with Java, and use lambdas instead of anonymous implementations:

Predicate<Object>[] assertionsArray = new Predicate<Object>[] {
    o -> assert0(), o -> assert1(), o -> assert2(), o -> assert3(), 
,   o -> assert4(), ...
};
...
if (assertionsArray[figureIndex].test(null)) {
    ...
}

Putting aside that you cannot do that in java versions lower than 8, you'll be much better off calling a single method that can handle various input.

You provided sparse code, so I'm going to take a shot in the dark here and suggest a switch statement perharps.

What you are doing here will result in an array of boolean, with the results from all your assertX() methods, at the time of array creation.

What you are trying to do here reminds me of function pointers in C, which AFAIK is not possible in Java.

Consider this alternative;

Have one method called: assertByIntArgument(int n) which calls the appropriate assertX() method, based on the argument n

Something like this:

private boolean assertByInt(int n){
  switch(n){
    case 1: return assert1(); break;
    case 2: return assert2(); break;
    // ...
  }
}

With Java 8, you could have the following:

Supplier<Boolean> assertionsArray = {
    SomeClass::assert0(), 
    SomeOtherClass::assert1(), 
    SomeClass::assert2(), 
    SomeClass::assert3(), 
    SomeClass::assert4(),
    SomeClass::assert5(), 
    SomeClass::assert6(), 
    SomeClass::assert7(), 
    SomeClass::assert8(), 
    this::assert9()
};

Then, in a loop or somewhere else:

boolean result = assertionsArray[i].get();

This answer is more of a 'as a matter of interest' than a real solution. The best solution in non-Java 8 environment is probably a switch. Another lead would have been reflection, as presented below, but please be aware that:

• it is less efficient and performant;
• it leaves your IDE (and compiler) blind and hinders you when navigating your code;
• too much reflection makes code just impossible to read.

Use at your own risk.

If you want to stick to several methods though, you could use reflection.

If your methods are declared in MyClass, invoking a no-arg method would be the following:

MyClass.class.getDeclaredMethod("assert" + i).invoke();

If you need to pass arguments (let's say an int and a String), update to the following:

MyClass.class.getDeclaredMethod("assert" + i, int.class, String.class).invoke(3, "Hello");