How to create constructor in java parameterized with class?

Question

I want to have a class to run other classes in java, like constructor parameterized with a class to run that class later on, similar to this

class MyClass{
    Class classToRun;
    public MyClass(Class c) {
        super();
        this.classToRun = c;
    }
    public void runClass(){
        classToRun.someStaticMethod();
    }
}

where classToRun possible classes doesn't have a common ancestor, but all have method someStaticMethod, and have no idea about MyClass, which runs them.

But there are problems, like inner classes cannot have static methods, classes cannot be cast Class, etc.

There are solutions for parameterized with class methods, like

How do I pass a class as a parameter in Java?

Passing a class as an argument to a method in java

but not for constructors.

What is the proper solution to do this?

Answer 1

Use lambdas and pass the method reference: they match on the method signature. For void someStaticMethod() you can use Runnable.

class MyClass{
    private final Runnable methodToRun;
    public MyClass(Runnable someStaticMethod) {
        methodToRun = someStaticMethod;
    }
    public void runClass(){
        methodToRun.run();
    }
}

new MyClass(SomeClass::someStaticMethod).runClass();

You cannot enforce that the method passed has the right name, but looks even neater IMHO.

Answer 2

You need to understand what generics are.

interface

public interface SomeInterface {
    void someStaticMethod();
}

use

class MyClass<T extends SomeInterface>{
    T classToRun;
    public MyClass(T c) {
        super();
        this.classToRun = c;
    }
    public void runClass(){
        classToRun.someStaticMethod();
    }
}

Answer 3

As 2 of 3 answers were not to the point, I decided to publish fixed versions of both answers as far as they can be fixed.

The f1sh version from the above should like follows:

public class ClassToRunOthers {
    Class classToRun;
    public ClassToRunOthers(Class c) {
        this.classToRun = c;
    }
    public void runClass() throws Exception {
        Optional<Method> method = Arrays.stream(classToRun.getDeclaredMethods()).filter(m -> m.getName().equals("someStaticMethod")).findFirst();
        if(!method.isPresent()) {
            throw new RuntimeException();
        }
        method.get().invoke(null);
    }
    public static void main(String[] args) throws Exception {
        ClassToRunOthers mc = new ClassToRunOthers(SomeClass.class);
        mc.runClass();
    }
}

class SomeClass {
    static void someStaticMethod() {
        System.out.println("test");
    }
}

The zwei solution above can not be fixed without reflection, as generics is not to the point. Evan if you try to parametrize not with SomeInerface (because SomeClass does not extend a common SomeInterface), but with Object, it is still won't solve the problem:

public class MyClass<T extends Object> {
    T classToRun;

    public MyClass(T c) {
        super();
        this.classToRun = c;
    }

    public void runClass() {
        //        classToRun.someStaticMethod(); // Cannot resolve method 'someStaticMethod' in 'T'
    }

    public static void main(String[] args) {
        MyClass mc = new MyClass(SomeClass.class);
    }
}

class SomeClass {
    static void someStaticMethod() {
        System.out.println("test");
    }
}

This can be fixed like the above, via reflection. I believe, it can be done with annotations in some elegant way, and may be someone will share us with such a solution or I will do it by myself as time permits. By now for myself, a solution with saving class name in the String in constructor next day after the question been asked did the trick.

Answer 4

You will have to use reflection if you want to execute a method when you only have the Class instance.

In the code below, runClass finds the method of the class using it's name as a String, then executes it. This code assumes that the method is static, also ignoring any Exception handling.

The following code prints "test":

class MyClass {
    Class classToRun;
    public MyClass(Class c) {
        this.classToRun = c;
    }
    public void runClass() throws Exception {
        Optional<Method> method = Arrays.stream(classToRun.getDeclaredMethods()).filter(m -> m.getName().equals("someStaticMethod")).findFirst();
        if(!method.isPresent()) {
            throw new RuntimeException();
        }
        method.get().invoke(null);
    }
}


class Main {
    public static void main(String[] args) throws Exception {
        MyClass mc = new MyClass(Main.class);
        mc.runClass();
    }

    static void someStaticMethod() {
        System.out.println("test");
    }
}