Pass any Class as a parameter for a method

Question

This has probably been asked before and I've seen a few similar/along the lines, but didn't quite understand it.

In Java, how do make it so a method accepts any class as a parameter?

For example,

public (AnyClass) myMethod(String whatever, (AnyClass) thisClass){

}

to be used like:

myMethod("Hello", ClassA);
myMethod("Hello", ClassB);

Thanks for any help!

Edit:

Usage example was asked for; What I'm doing is mapping a JSON string to a POJO, but trying to abstract this whole thing out so it can be reused. So - I need to be able to pass through any class, and the JSON string (or HttpConn), then build then use Jackson to build that POJO and return the object, of whatever type that may be.

(An idea of what I want to do):

public Class<?> doSomething(String jsonString, Class<?> clazz){
    clazz newInstance = mapper.readValue(jsonString, clazz);
    return clazz;
}

called like:

ClassA test = doSomething("String One", ClassA.class);
ClassB testTwo = doSomething("Different format string", ClassB.class);

Hope that helps understanding of the problem... and my understanding of the solutions!

Any Class object or any instance? For the former use `Class>` for the latter use `Object` — Lino, Jan 24 '19 at 10:36
No it has to be the class itself - or class reference to be used later (for mapping). Is that possible? — AristotleTheAxolotl, Jan 24 '19 at 10:37
This may help you.https://stackoverflow.com/questions/4872978/how-do-i-pass-a-class-as-a-parameter-in-java?answertab=active#tab-top — ramya br, Jan 24 '19 at 10:38
In that case you can just use `Class>` as the parameter type and then call it like: `myMethod("Hello", ClassA.class)` — Lino, Jan 24 '19 at 10:38
I still didn't manage to - sorry! Will post an update/select an answer when I do. — AristotleTheAxolotl, Jan 25 '19 at 15:26
This is pretty much working based on the answer from @DodgyCodeException , final bits i think are from a different problem now. — AristotleTheAxolotl, Jan 25 '19 at 16:12

J-Alex · Answer 1 · 2019-01-24T12:40:14.293

1) Without type information:

public static Class<?> myMethod(String text, Class<?> clazz) {
    // body
    return clazz;
}

Client code:

public static void main(String[] args) {
    Class<?> clss = myMethod("Example", String.class);
}

2) With type information:

public static <T> Class<T> myMethod(String x, Class<T> clazz) {
    // body
    return clazz;
}

Client code:

public static void main(String[] args) {
    Class<String> clsStr = myMethod("Example", String.class);
    Class<?> clsAny = myMethod("Example", String.class);
}

3) Raw type (will work but NOT recommended):

public static Class myMethod(String x, Class clazz) {
    // body
    return clazz;
}

Client code:

public static void main(String[] args) {
    Class<String> clsStr = myMethod("Example", String.class); // warning for Unchecked Assignment 
    Class<?> clsAny = myMethod("Example", String.class);
    Class clsRaw = myMethod("Example", String.class);
}

4) With type information defined at class level:

public class Main<T> { 

    // cannot be static
    public Class<T> myMethod(String x, Class<T> clazz) {
        // body
        return clazz;
    }
}

Client code:

public static void main(String[] args) {
    Main<String> m = new Main<>();
    Class<String> cls = m.myMethod("x", String.class);
}

score 3 · Answer 2 · answered Jan 24 '19 at 10:56

I assume you need to accept a class of some type T as a parameter and return that class as well. In that case, your method signature will be something like this:

public <T> Class<T> myMethod(String whatever, Class<T> clazz){
    // put the rest of your code here
}

DodgyCodeException · Accepted Answer · 2019-01-25T14:23:51.637

In your latest edit, your usage example is like this:

ClassA test = doSomething("String One", ClassA.class);

The question shows confusion between a class name, the Class object and an instance of a class. So just to clarify, using the above example:

A class name – ClassA – is used to declare a variable.
A Class instance – ClassA.class – is a singleton object that holds information about a class and can be passed as an argument to a method.
An instance of a class – test – is an object. It's usually created using the new keyword.

You can't use a Class object, such as ClassA.class, directly in a declaration. Instead, you have to call the newInstance() method of the Class class. That method can be used only if your class has a no-args constructor. To create an instance with constructor arguments, use something like this:

public <T> T doSomething(String jsonString, Class<T> clazz) throws ReflectiveOperationException {
    Constructor<T> constructor = clazz.getConstructor(String.class);
    return constructor.newInstance(jsonString);
}

The above method creates an instance of the required class using a constructor that takes a String (the string that was passed in). Change its body to create an instance according to your requirements.

Thanks a lot for the explanation and help! This is just about the most coherent answer to this I've managed to find :) — AristotleTheAxolotl, Jan 25 '19 at 16:12

Pass any Class as a parameter for a method

3 Answers3