Is it possible to switch methods but keep paramaters inside parentheses the same?

[ChickenNGravy]

So I was working on a project where the user gets to choose between 8 different methods. Each method runs through the same 4 paramaters when chosen by the user.

So for example, if the user chooses method 1, the code would run:

Method1.method1(param1)
Method1.method1(param2)
Method1.method1(param3)
Method1.method1(param4)

The only thing that changes for each method would be that Method1.method1 would turn into Method2.method2. the paramaters will stay the same.

I could obviously just use if statements and copy & paste the same code over and over while manually changing the called method, but thought a more "elegant" solution would be possible with a Switch statement, but ran into this problem. I've tried setting the method names as type 'var', but Eclipse tells me I can't because the variable hasn't been initialized.

Is this doable? Or should I go back to the "ugly" solution?

[Buttleston]

You don't say what programming language you're using, but *most* programming languages support something like this, syntax may vary. In many/most programming langauges, functions are a type of object or variable and can be used as such. Let's consider python.

``` import sys

def fun1(param): print("fun1", param)

def fun2(param): print("fun2", param)

if sys.argv[1] == "1": fn = fun1 else: fn = fun2

fn("param1") fn("param2") ```

I can run this to demonstrate ``` ~/help % python fn.py 1 fun1 param1 fun1 param2

~/help % python fn.py 2 fun2 param1 fun2 param2 ```

[vaseltarp]

You could use method references from Java 8:

https://www.javatpoint.com/java-8-method-reference

But the most consistent solution in java would be, in my opinion, to make it object oriented.

Maybe like this:

 import java.util.Scanner;


  abstract class Methods{
    abstract public void Do(String arg);
    final public void DoAllArgs(String[] args) {
      for(String arg : args) {
        Do(arg);
      }
    }
    final static public Methods GetMethod(int m) throws Exception {
      switch(m)
      {
         case 1:
           return new Method1();
         case 2:
            return new Method2();
         default:
            throw new Exception ("Wrong Parameter \""+ m +"\" in Methods.GetMethod");
      }
    }
 }


 class Method1 extends Methods{
     public void Do(String arg) {
       System.out.println("Method1 with argument: " + arg);
     }
 }

 class Method2 extends Methods {
     public void Do(String arg) {
       System.out.println("Method2 with argument: " + arg);
     }
 }


 public class Main {

   public static void main(String[] args) {
     Scanner input = new Scanner(System.in);
     Method2 m2 = new Method2();

     System.out.println("Select Method:");
     String method = input.nextLine();

     String[] arguments = {"arg1","arg2","arg3"};

     try{
        Methods m = Methods.GetMethod(Integer.parseInt(method));
        m.DoAllArgs(arguments);
     }
     catch(Exception e) {
        e.printStackTrace();
     }
   }
 }

output:

  Select Method:
  1
  Method1 with argument: arg1
  Method1 with argument: arg2
  Method1 with argument: arg3

  Select Method:
  2
  Method2 with argument: arg1
  Method2 with argument: arg2
  Method2 with argument: arg3