Java generic class token

I want to encapsulate requests to my android service because the service has the information to generate the appropriate commands. However I would like to constrain class tokens sent to the service extended from ICommand, so that I dont allow sending of requests with invalide tokens. This will explain more:

public class ServiceRequestArgs implements Serializable {

    private static final long serialVer开发者_如何学CsionUID = -7484807396752170166L;

    private Class m_token; 
    //warning: references to generic type Class<T> should be parameterized
    private IFileUploadListener m_listener;

    public <T extends ICommand> ServiceRequestArgs(
        Class<T> cmdClass, IFileUploadListener listener)
    {
        m_token = cmdClass;
        m_listener = listener;
    }

    public Class getClassToken() //warning: references to generic...
    {
        return m_token;
    }

    public IFileUploadListener getListener()
    {
        return m_listener;
    }
}

//use ->
Intent intent = new Intent(this, MyService.class);
intent.putExtra("svc_command", 
    new ServiceRequestArgs(GetListCommand.class, m_listener);
bindService(intent, m_serviceConnection, 0);

I understand C# generic constraints, but I am not sure how I should be using this in Java.

Edit

Heres what I came up with:

public class ServiceRequestArgs<T extends ICommand> {

    private ServiceRequestArgs(Class<T> token, IFileUploadListener listener);

    public Class<T> getClassToken(); //...
    public IFileUploadListener getListener(); //...

    //to make it easier to call. sorry, cant remember where I found this.
    public <C extends ICommand> ServiceRequestArgs<C> create(
        Class<C> token, IFileUploadListener listener)
    {
        return new ServiceRequestArgs<C>(token, listener);
    }
}

I would implement this as a generic class, rather than trying to implement a generic constructor:

public class ServiceRequestArgs<T extends ICommand> {

    private Class<T> m_token;
    private ICommand m_listener;

    public ServiceRequestArgs(Class<T> cmdClass, ICommand listener)
    {
        m_token = cmdClass;
        m_listener = listener;
    }

    public Class<T> getClassToken()
    {
        return m_token;
    }

    public IFileUploadListener getListener()
    {
        return m_listener;
    }
}

This way, the generic type T (constraint and all) are usable throughout the class. Most of the time, generic constructors (for a non-generic class) aren't the answer.

You want to make the class generic first. Constructors shouldn't have their own generic parameters.

So

public class ServiceRequestArgs<T extends ICommand> implements Serializable {

    private static final long serialVersionUID = -7484807396752170166L;

    private Class<T> m_token; 
    //warning: references to generic type Class<T> should be parameterized
    private IFileUploadListener m_listener;

    public ServiceRequestArgs(
        Class<T> cmdClass, IFileUploadListener listener)
    {
        m_token = cmdClass;
        m_listener = listener;
    }

    public Class<T> getClassToken() //warning: references to generic...
    {
        return m_token;
    }

    public IFileUploadListener getListener()
    {
        return m_listener;
    }
}