Passing method as parameter to another method in Java

I have 3 methods which does the same thing but at the end the 3 methods call a diff method. So instead of having 3 methods, I want to have a single method which will accept a method as parameter which it will call at the end

How can I do this please, I tried having a look at the java reflection that did not work, Not sure if interfaces is the right way for this.

please suggest
Thanks
R

class A {

doSameThingA(int x) {
 //do same thing with x
 methodA()
}
doSameThingB(int x) {
 //do same thing with x
 methodB()
}

doSameThingC(int x) {
 //do same thing with x
 methodC()
}

//I WANT TO WRITE A SINGLE FUNCTION replacing the above three
doSameThing(int x, Method method) {
//do same thing with x
method()
}
} 

An operator exists in java known as the double colon operator. It is also known as the method reference operator because it refers to methods and this feature I believe will allow you to solve your problem by parameterizing your method. Kind of like lambdas.

class A {
    public static void main(String... args) {
        new A().doSameThing(1, MethodClass::printSomething);
    }

    void doSameThing(int x, Runnable method) {
        method.run();
    }
} 

class MethodClass {
    public static void printSomething() {
        System.out.println("Hello World");
    }
}

The above is an example. MethodClass contains the method you want to run (such as your methodA(), methodB(), methodC(), and so forth. The doSameThing method takes in a Runnable, which is a functional interface that takes no parameters and returns no value. By passing the method printSomething, which takes no parameters and returns no value, we can run that method within the doSameThing method.

Of course, the type of functional interface you use would depend on what your methods are designed to accomplish.

Furthermore, if your other methods (methodA(), methodB(), ...) aren't used anywhere else in your code, you can implement the runnable interface in place with an anonymous class. Below is the previous example written in that form:

class A {
    public static void main(String... args) {
        new A().doSameThing(1, new Runnable() {
            public void run() {
                System.out.println("Hello World");
            }
        });
    }
    void doSameThing(int x, Runnable method) {
        method.run();
    }
}

Since Runnable is a functional interface, you could even go as far as using a lambda expression for this.

class A {
    public static void main(String... args) {
        new A().doSameThing(1, () -> {    
            System.out.println("Hello World");
        });
    }
    void doSameThing(int x, Runnable method) {
        method.run();
    }
}

If you can use java 1.8 (and above), you can pass the method as a function

Function<Integer> method = (x) -> { //do something here }

And in doSameThing

doSameThing(int x, Function<Integer> fn) {
   fn.apply(x)
}