Équivalent de la Scala de java.lang.Class Java<T> Object</T>

Question

La question est mieux expliquée par un exemple :

En Java pour un EntityManager JPA, je peux faire ce qui suit (le compte est ma classe d’entité) :

Scala, ma tentative naïve est :

Mais quand j’essaye d’utiliser `` à la Scala, il semble ne pas comme ça. Comment puis-je indiquer l’objet java.lang.Class pour la classe Account en Scala ?

Answer 1

Selon "La Scala Type de Système",

val c = new C
val clazz = c.getClass              // method from java.lang.Object
val clazz2 = classOf[C]             // Scala method: classOf[C] ~ C.class
val methods = clazz.getMethods      // method from java.lang.Class<T>

L' classOf[T] méthode retourne l'exécution de la représentation pour un Scala type. Il est analogue à l'expression de Java T.class.
À l'aide de classOf[T] est pratique lorsque vous avez un type que vous souhaitez obtenir des informations, tout en getClass est pratique pour récupérer les mêmes informations à partir d'une instance de ce type.

Toutefois, classOf[T] et getClass retour des valeurs légèrement différentes, reflétant l'effet du type d'effacement sur la JVM, dans le cas de getClass.

scala> classOf[C]
res0: java.lang.Class[C] = class C

scala> c.getClass
res1: java.lang.Class[_] = class C

C'est pourquoi le code suivant ne fonctionnera pas:

val xClass: Class[X] = new X().getClass //it returns Class[_], nor Class[X]

val integerClass: Class[Integer] = new Integer(5).getClass //similar error

Il y a un billet concernant le type de retour d' getClass.

(James Moore rapports que le billet est "maintenant", c'est à dire Nov. En 2011, deux ans plus tard, fixe.
Dans 2.9.1, getClass maintenant:

scala> "foo".getClass 
       res0: java.lang.Class[_ <: java.lang.String] = class java.lang.String

)

De retour en 2009:

Il serait utile si Scala ont été de traiter le retour de getClass() comme un java.lang.Class[T] forSome { val T : C } où C est quelque chose comme l'effacement du type statique de l'expression sur laquelle getClass est appelé

Il serait permettez-moi de faire quelque chose comme ce qui suit, lorsque je veux connaître le fonctionnement d'une classe, mais ne devrait pas besoin d'une instance de classe.
Je tiens également à limiter les types de classes, je veux l'introspection, j'ai donc utiliser la Classe[_ <: Foo]. Mais cela m'empêche de passer dans une classe Foo en utilisant Foo.getClass() sans un plâtre.

Remarque: en ce qui concerne getClass, une solution possible serait:

class NiceObject[T <: AnyRef](x : T) {
  def niceClass : Class[_ <: T] = x.getClass.asInstanceOf[Class[T]]
}

implicit def toNiceObject[T <: AnyRef](x : T) = new NiceObject(x)

scala> "Hello world".niceClass                                       
res11: java.lang.Class[_ <: java.lang.String] = class java.lang.String

Answer 2

classOf [compte]