Java equivalent of c#'s MakeGenericType to create instance of unknown generic type

Its been a long time since I have touched Java. But given the following C# syntax, is it possible to create an unknown instance of a generic type in java?

public void Send(object message)
{
    Type requestType = message.GetType();
    ReceiverWrapper receiverInstance = (ReceiverWrapper)
            Activator.CreateInstance(typeof(ReceiverWrapper<>).MakeGenericType(requestType));

    // do something with the receiver...
}

So the idea being Object message is of type Message1. I want to create an instance of ReceiverWrapper<Message1>.

I don't want to use generics in method signature - ala public <T> void Send(T message) as I already understand this in Java. I am curious whether we can extract type information from Object and create a generic based on that type.

> I want to create an instance of ReceiverWrapper<Message1>.

There's no such thing in Java. There's just ReceiverWrapper. Java generics are mostly a compile-time artifact. For example, if you have a field which is of type List<String> you can determine that with reflection - but an object isn't an instance of ArrayList<String>, it's just an instance of ArrayList.

There are a few things to unpack here, first of all var is not a generic type. Var will be replaced by an actual type at compile time so if you want to use generics you probably shouldnt use var.

public <T> void Send(T message)
{
    ReceiverWrapper<T> receiverInstance = new ReceiverWrapper<>();

// do something with the receiver...
}

I'm not entirely sure what you want to do with it but something like this?

> „…is it possible to create an unknown instance of a generic type in java?…“

Yes. It is possible. But only if certain preconditions can be guaranteed (see the comments in the code).

I outline the gist of the technique with the snippets below. The working experiment can be run online…

{
    ...
    Optional< Object > parameterizedType ...

    TypeVariable< ? > typeVars[ ] ...

    /* Precondition #1: target MUST be a generic class */
    if( typeVars.length == 0 ){ throw new NotAGenericTypeException( ); }
  
    /* Precondition #2: target MUST expose a constructor that's declared to take arguments
     * whose type is that of those declared in the generic class's type parameter section */
    if( isConstructorCompatible ( target, typeVars ) ){
        
        try{ 
            parameterizedType = Optional.of( target.getClass( ).getConstructors( )[0].newInstance( typeArgs ) );
        } catch( ReflectiveOperationException roe ){ roe.printStackTrace( ); }
    }
    
    return parameterizedType;
}

> „…So the idea being Object message is of type Message1. I want to create an instance of ReceiverWrapper<Message1>…“

Although your question's Send(Object) method returns void, to make my proof of concept more testable my experimental implementation returns an instance of the parameterized type…

...
public Optional< Object > send( Object message ){ 
    return parameterizer.parameterize( ReceiverWrapper.class, message );    
}
...

Usage example…

...
/* Set up a test of @Andez's use case  */
Object sos = new Message( "Friends of space, how are you all? Have you eaten yet? Come visit us if you have time." );
    
/* The class under test */
ProofOfConcept voyager = new ProofOfConcept( );
    
/* Exercise the method under test */
Optional< Object > type  voyager.send( sos );
    
/* Prepare the outcome of the parameterization done in the previous voyager.send( ) call */
ReceiverWrapper< Message > oumuamua = type.map( raw -> (ReceiverWrapper< Message >)raw ).orElseThrow( AssertionError::new );
    
/* Leverage the compiler's type checking */
Message fromSpace = oumuamua.getMessage( );
    
/* Verify that the expected type returned by send( ) is the type of the type argument */
assert ((Object)fromSpace) instanceof Message : "EXPERIMENT FAILED";
...

Results of the experiment…

Message [ payload: Friends of space, how are you all? Have you eaten yet? Come visit us if you have time. ]
             EXPERIMENT SUCCESSFUL

And they said it couldn't be done