Quand dois-je passer une classe comme argument?

Question

Je suis confus à undrestand quand nous devrions passer une classe en tant qu'argument au lieu de son instance. par exemple:

myMethod(classA.class); 

Pourriez-vous faire un exemple quand et comment nous devrions adopter une classe comme argument?

Answer 1

Un exemple classique est lors de la création d'une instance d'une classe par réflexion:

//avoiding exception handling, leave that up to you 
static <T> T make(Class<T> clazz) { 
    return clazz.newInstance(); 
} 
//... 
A a = make(A.class); 

Aussi, lorsque vous voulez vous assurer au moment de la compilation que certaines références appartiennent à une classe spécifique, tel qu'il est utilisé dans Collections#checkedXxx.

Answer 2

Lets considérons que nous avons un certain Créateur

abstract class Creator<T> 
    { 
    Creator(Class<T> c) 
    { 
     this.c = c; 
    } 

    T addMainElement(Object obj) 
    { 
     return c.cast(this); 
    } 

    private Class<T> c; 
    } 

Et une enveloppe

class CreatorWrapper extends Creator<CreatorWrapper> 
    { 
     CreatorWrapper() { 
     super(CreatorWrapper.class); 
     } 

     CreatorWrapper addMinorElement(Object obj) 
     { 
     return this; 
     } 
    } 

Le principal avantage de le faire de cette façon que nous pouvons utiliser notre créateur comme ça

CreatorWrapper creator = new CreatorWrapper() 
     .addMainElement(someObj1) 
     .addMinorElement(someObj2); 

Nous ne serons pas en mesure de le faire si la classe de base n'a aucune connaissance de la classe enfant.
Et nous ne serons pas perturbés par « cast de Décoché main.Creator à T » avertissement que nous serons si nous jetons comme ça

return (T)this; 

Voir Java Class.cast() vs. cast operator

Answer 3

Par exemple, si vous voulez encapsuler la valeur de nombreux champs dans une entité telle que la méthode du framework Hibernate "session.get (Classe entityClass, String primaryKey)" .Vous devez définir entityClass pour qu'Hibernate sache comment encapsuler le résultat de la requête dans une entité. Un exemple simple à utiliser classe comme argument:

public T getInstance(Class<T extends Serializable> clazz) throws Exception 
    { 
      // the ParameterType "T extend Serializable" means that: 
      // the argument clazz must be a sub of the Interface Serializable 
      if(null != clazz) 
      { 
       return clazz.newInstacne(); 
      } 

     return null; 
    } 

Answer 4

exemple idiot:

public class PassClassExample { 

    public static class ClassValidator { 
     private Class theClass; 
     public ClassValidator(Class theClass) { 
      this.theClass = theClass; 
     } 

     public boolean instanceOf(Class someClass) { 
      return theClass == someClass; 
     } 
    } 

    public static void main (String [] args) { 
     ClassValidator personValidator = new ClassValidator(Person.class); 

     Person you = new Person(); 
     Animal me = new Animal(); 

     System.out.println(personValidator.instanceOf(you.getClass())); 
     System.out.println(personValidator.instanceOf(me.getClass())); 

    } 

    public static class Person { 

    } 

    public static class Animal { 

    } 
} 

imprimera

true 
false 

indiquant que vous êtes une personne et je suis un animal :)