Como passo uma classe como parâmetro em Java?

Existe alguma maneira de passar a classe como um parâmetro em Java e disparar alguns métodos dessa classe?

void main()
{
    callClass(that.class)
}

void callClass(???? classObject)
{
    classObject.somefunction
    // or 
    new classObject()
    //something like that ?
}

Estou usando o Google Web Toolkit e ele não suporta reflexão.

public void foo(Class c){
        try {
            Object ob = c.newInstance();
        } catch (InstantiationException ex) {
            Logger.getLogger(App.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(App.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

• Aqui estão alguns bons exemplos da API de reflexão

Como invocar método usando reflexão

 import java.lang.reflect.*;


   public class method2 {
      public int add(int a, int b)
      {
         return a + b;
      }

      public static void main(String args[])
      {
         try {
           Class cls = Class.forName("method2");
           Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod(
              "add", partypes);
            method2 methobj = new method2();
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj 
              = meth.invoke(methobj, arglist);
            Integer retval = (Integer)retobj;
            System.out.println(retval.intValue());
         }
         catch (Throwable e) {
            System.err.println(e);
         }
      }
   }

Veja também

• Reflexão Java

public void callingMethod(Class neededClass) {
    //Cast the class to the class you need
    //and call your method in the class
    ((ClassBeingCalled)neededClass).methodOfClass();
}

Para chamar o método, você chama assim:

callingMethod(ClassBeingCalled.class);

Construa seu método para aceitá-lo.

public <T> void printClassNameAndCreateList(Class<T> className){
    //example access 1
    System.out.print(className.getName());

    //example access 2
    ArrayList<T> list = new ArrayList<T>();
    //note that if you create a list this way, you will have to cast input
    list.add((T)nameOfObject);
}

Chame o método

printClassNameAndCreateList(SomeClass.class);

Você também pode restringir o tipo de classe, por exemplo, este é um dos métodos de uma biblioteca que eu criei.

protected Class postExceptionActivityIn;

protected <T extends PostExceptionActivity>  void  setPostExceptionActivityIn(Class <T> postExceptionActivityIn) {
    this.postExceptionActivityIn = postExceptionActivityIn;
}

Para mais informações, procure Reflexão e Genéricos.

Usar

void callClass(Class classObject)
{
   //do something with class
}

UMA Class também é um objeto Java, para que você possa fazer referência a ele usando seu tipo.

Leia mais sobre isso na documentação oficial .

Esse tipo de coisa não é fácil. Aqui está um método que chama um método estático:

public static Object callStaticMethod(
    // class that contains the static method
    final Class<?> clazz,
    // method name
    final String methodName,
    // optional method parameters
    final Object... parameters) throws Exception{
    for(final Method method : clazz.getMethods()){
        if(method.getName().equals(methodName)){
            final Class<?>[] paramTypes = method.getParameterTypes();
            if(parameters.length != paramTypes.length){
                continue;
            }
            boolean compatible = true;
            for(int i = 0; i < paramTypes.length; i++){
                final Class<?> paramType = paramTypes[i];
                final Object param = parameters[i];
                if(param != null && !paramType.isInstance(param)){
                    compatible = false;
                    break;
                }

            }
            if(compatible){
                return method.invoke(/* static invocation */null,
                    parameters);
            }
        }
    }
    throw new NoSuchMethodException(methodName);
}

Atualização: Espere, acabei de ver a tag gwt na pergunta. Você não pode usar reflexo no GWT

Não tenho certeza do que você está tentando realizar, mas você pode considerar que passar em uma aula pode não ser o que você realmente precisa fazer. Em muitos casos, lidar com uma classe como essa é facilmente encapsulado dentro de um padrão de fábrica de algum tipo e o uso disso é feito por meio de uma interface. aqui está uma das dezenas de artigos sobre esse padrão: http://today.java.net/pub/a/today/2005/03/09/factory.html

o uso de uma classe dentro de uma fábrica pode ser realizado de várias maneiras, principalmente por ter um arquivo de configuração que contém o nome da classe que implementa a interface necessária. Em seguida, a fábrica pode encontrar essa classe de dentro do caminho da classe e construí-la como um objeto da interface especificada.

Como você disse, o GWT não suporta reflexão. Você deve usar ligação adiada em vez de reflexão ou biblioteca de terceiros, como gwt-ent, para suporte à reflexão na camada gwt.

Veja estes: http://download.oracle.com/javase/tutorial/extra/generics/methods.html

Aqui está a explicação para os métodos de modelo.

Dê uma olhada no tutorial de reflexão e na API de reflexão de Java:

https://community.oracle.com/docs/DOC-983192 insira a descrição do link aqui

e

http://docs.oracle.com/javase/6/docs/api/java/lang/Class.html

Classifique como paramater. Exemplo.

Três classes:

class TestCar {

    private int UnlockCode = 111;
    protected boolean hasAirCondition = true;
    String brand = "Ford";
    public String licensePlate = "Arizona 111";
}

-

class Terminal {

public void hackCar(TestCar car) {
     System.out.println(car.hasAirCondition);
     System.out.println(car.licensePlate);
     System.out.println(car.brand);
     }
}

-

class Story {

    public static void main(String args[]) {
        TestCar testCar = new TestCar();
        Terminal terminal = new Terminal();
        terminal.hackCar(testCar);
    }

}

Na classe Método terminal, hackCar () leva a classe TestCar como parâmetro.