La diferencia entre el manifiesto de Scala y el manifiesto de clase
Manifest es una característica introducida en Scala2.8, que permite al compilador obtener información de tipo genérico en tiempo de ejecución. En la JVM, el tipo de parámetro genérico T se "borra" en tiempo de ejecución y el compilador trata a T como un objeto, por lo que no se puede obtener la información específica de T para obtener la información de T en tiempo de ejecución, y Scala necesita hacerlo adicionalmente; almacene información T a través del Manifiesto y utilícela como parámetro en el contexto de tiempo de ejecución del método.
def test[T] (x:T, m:Manifest[T]) { ... }
Con Manifest[T], el parámetro m que registra información de tipo T , T se puede juzgar con mayor precisión en función de m durante el tiempo de ejecución. Pero si cada método se escribe así, la persona que llama al método tendrá que pasar un parámetro m adicional, lo cual es muy hostil y dañará el diseño del método. Afortunadamente, Scala tiene la función de conversión implícita y los parámetros implícitos se pueden usar aquí para reducir los problemas de la persona que llama.
Dos formas básicas de obtener manifiestos de clase:
1 def classOf[T <: Any](implícito m: scala.reflect.Manifest[T]): Class[T] = m.erasure.asInstanceOf[Class[T]
Declare un parámetro implícito a través de m implícito: scala.reflect.Manifest[T], para que el compilador Scala pueda proporcionar la información de tipo de T en el momento de la compilación
2 def classOf[T <: Cualquiera: Manifiesto] : Clase[T] = manifiesto[T].erasure.asInstanceOf[Class[T]
Donde T <: Cualquiera: Manifiesto , dividido en dos partes
T <: Any
T es un subtipo de Any (es decir, puede ser cualquier tipo básico scala.AnyVal y tipo de referencia scala.AnyRef)
T: Manifiesto es equivalente a aplicar el método classOf
La lista de parámetros agregados implícitamente es la siguiente: (evidencia implícita$1: Manifest[T]),
A través del manifiesto [T] El método se puede utilizar para obtener la instancia de Manifest.
Se puede ver que la forma 1 y la forma 2 son esencialmente iguales.
Aplicación:
1 Lo más común es obtener la Clase del parámetro tipo, en forma de algúnMétodo[Tipo]
Por ejemplo, la fuente código en akka: def actorOf[T <: Actor: Manifest]: ActorRef = actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor])
class Worker extends Actor {
def recibir = {
caso Trabajo(inicio, nrOfElements) =>
autorespuesta Resultado(calculatePiFor(inicio, nrOfElements)) // realizar el trabajo
}
}
Puedes usarlo así: val workActorRef = actorOf[Worker]
2 Crea una matriz genérica mediante programación
def evenElems[T: ClassManifest](xs: Vector[T]): Matriz[T] = {
val arr = new Array[T]((xs.length + 1) / 2)
for (i <- 0 hasta xs.length por 2)
arr(i / 2) = xs(i)
arr
}
scala> evenElems(Vector("a","b","c"))
res: Array[java.lang.String] = Matriz(a, c)