Bdtjtk

Define an interface (let's name it ScriptTask) defining the method to execute (let's call it execute). Create an array tasks of ScriptTask. Then use tasks[num].execute(parameters).

Example:

@FunctionalInterface

interface ScriptTask {

    void execute(String s, int i);

}



class Script {



    private ScriptTask tasks;



    Script() {

        this.tasks = new ScriptTask[2];

        this.tasks[0] = this::foo;

        this.tasks[1] = this::bar;

    }



    private void foo(String s, int i) {

        System.out.println(s);

    }



    private void bar(String s, int i) {

        System.out.println(i);

    }



    void run() {

        for (int i = 0; i < tasks.length; i++) {

            tasks[i].execute("hello", i);

        }

    }



    public static void main(String args) {

        new Script().run();

    }

}

Note that if you really have 100 different methods in a single class, that's a clear sign that it should be refactored into several different simpler classes, that can be read, understood and tested more easily. The above is the first step for the refactoring: you can refactor each method into a separate class implementing the ScriptTask interface.

You need to pass the Object of the class in which method is defined, get method name from array and pass arguments. Posting only the required code.

public static Object invokeExactMethod(Object object, String methodName, Object... args) {

        if (null == args) {

            args = ArrayUtils.EMPTY_OBJECT_ARRAY;

        }

        int arguments = args.length;

        Class<?> parameterTypes = new Class[arguments];

        for (int i = 0; i < arguments; i++) {

            parameterTypes[i] = args[i].getClass();

        }

        return invokeExactMethod(object, methodName, args, parameterTypes);

    }





    invokeExactMethod() is method provided my MethodUtils class of apache commons.

Hope this helps..!!

Can create an interface for saving the methods to run, for example :

public interface MethodRunner {

   public void run();

} 

Define the array and add an instance of MethodRunner.

MethodRunner methodsRunners = new MethodRunner[n];

methodsRunners[0] = new MethodRunner() {

      @Override

      public void run() {

        // some method here 

      }

};

methodsRunners[0] = ... 

      . 

      . 

methodsRunners[n] = ... 

And run it by following way :

methodsRunners[n].run();

Well, I think we can make use of Reflection in order to achieve this as follows"

1.) Class to store info about the methods

public class MethodInfo {



    public String methodName;

    public Class<?> params;

}

2.) Class consisting of all the methods

public class Task {



    public void method1(int x, ......){



    }

    And So On..

}

3.) Main class creating array and using it. Here using Reflection we can access methods from array and invoke them.

public class MainClass {



    public static void main(String args) {



        MethodInfo firstMethod = new MethodInfo();

        firstMethod.methodName = "method1";

        firstMethod.params = Array OF Parameter Types(.class values)



        MethodInfo methods = new MethodInfo[10];

        methods[1] = firstMethod;



        java.lang.reflect.Method method = Task.class.getMethod(methods[1].methodName, methods[1].params);

        method.invoke(new Task(), param1, param2,....);

    }

}

in addition to the answer of JB Nizet, other variants of syntax can be used:

    this.tasks = new ScriptTask[4];

    this.tasks[0] = this::foo;

    this.tasks[1] = this::bar;

    this.tasks[2] = (String s, int i) -> {

        System.out.println(s);

    };

    this.tasks[3] = (String s, int i) -> System.out.println(s);

or even:

   this.tasks = new ScriptTask {

        this::foo,

        this::bar,

        (String s, int i) -> {

            System.out.println(s);

        },

        (String s, int i) -> System.out.println(s)

    };

In the program I am working on I accomplished this by creating constructors with overwritten methods.

public class Script 

{

    public Script()

    {



    }



    public void run()

    {



    }

}



public class TestScript extends Script

{

    public TestScript()

    {



    }



    public void run()

    {

        //This Method overwrites the run method of script. This is where your code goes.

    }

}



public class Main

{

    public static Script test = new TestScript();



    public static void main(String args)

    {

        test.run();

    }

}

I'm wondering if there is a way to link an array value to a certain method.

You can use reflection to generate an Array of methods. However, this is a "not ideal solution" because it will make your code hard to maintain. So, I have to say this is not good practice but here it is.

package methodarray;



import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;



public class MethodArray {

    public static void main(String args) {

        Method arrayOfMethods = new Method[100];

        try {

            //...You will need to add the methods by their name, you can use for loops to add them quickly

            arrayOfMethods[1] = MethodArray.class.getDeclaredMethod("someMethodName");

            arrayOfMethods[2] = MethodArray.class.getDeclaredMethod("someOtherMethod");

            //...

        } catch (NoSuchMethodException | SecurityException ex) {

            //this can throw an Exception if the method is not found, handle it here

        }

        //now to call a method from the array just do

        try {

            arrayOfMethods[1].invoke(MethodArray.class);

        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {

            //...handle exceptions

        }

    }



    public void someMethodName(){

        //...logic

    }



    public void someOtherMethod(){

        //...logic

    }

}

This would help you call the methods just like you want, but keep in mind that for security java might throw several expections when using reflection. To send additional arguments just call arrayOfMethods[n].invoke(MethodArray.class, args);

This question is mainly for Java, but if it works for all Object Oriented Programming Languages, then that's good.

For solving these types of common scenarios we use Design Patterns, patterns are tested solutions for common scenarios. All the answers saying that you should "use an interface" are actually trying to help you achieve that, the pattern you might be able to use is called Command Pattern you can read about it here. Understanding or reading about the pattern might not be useful since you've said that you are not familiar with using interfaces. (Personally I always recommend Head First Design Patterns as an introductory book to patterns.)

Once you understand the command pattern you can simply generate an array of commands, this is a better OO solution, keep that in mind. I won't make an example since I think is hard to understand if you don't have a clear idea on how to use interfaces, read about them, it will be worth it!!!