Scala Equivalent of Java java.lang.Class`<T>` Object

scala

reflection

type-system

class-of

byNikita Barsukov·Dec 1, 2024

In Scala, use ClassTag to resemble Java's Class<T>. The magic? It overcomes JVM type erasure, enabling type retrieval during runtime.

import scala.reflect.{ClassTag, classTag}

// Funnily enough, it's like asking classOf[T]: "Hey, what's your runtime class?"
def getRuntimeClass[T: ClassTag]: Class[_] = classTag[T].runtimeClass

val intClass = getRuntimeClass[Int]
println(intClass) // Prints int as int was like, "I'm an int!".

What's the catch? ClassTag must be within the scope to access runtime class of T.

The Tale of classOf[T] and getClass

A Deep Dive into classOf[T]

classOf[T] is Scala's answer to Java's T.class, coming to life as java.lang.Class[T]. Think of classOf[T] as the Swiss Army Knife; it can access class info for Scala types, interact with Java libraries, and even perform reflective operations.

// Scala's way of asking Account: "Who are you in the world of classes?"
val accountClass: Class[Account] = classOf[Account]
println(accountClass) // Account replies, "Well, I am class Account".

The Ins and Outs of getClass

getClass, who behaves more or less like its Java cousin, has a dark secret: type erasure. Even though it returns a runtime instance Class[_], it appears to suffer from amnesia when it comes to remembering specific type information. But here's the kicker: Scala 2.9.1 gave getClass an upgrade, enhancing its memory (aka, more type info).

val account = new Account()
println(account.getClass) // Account was like, "I am class Account. No doubt!"

The Silver Lining: Implicit Conversions

Ever run into a dead-end when using getClass? Don't worry; implicit conversions within custom classes can save the day! They help maintain and spread type information, somewhat like gossips in the world of Generics.

implicit class RichClass[T](val cls: Class[T]) {
  // Ask RichClass to spill the beans!
  def getSimpleName: String = cls.getSimpleName
}

val richClass = account.getClass.getSimpleName
println(richClass) // RichClass was like, "Did you know Account is actually class Account?"

Diving Deep: Understanding Scala's Type System

The book "The Scala Type System" is a handy guide to thoroughly understand acquiring class objects in Scala. The deeper you dive into Scala's type system, the more you'll appreciate this knowledge when you grapple with classOf[T] and getClass's limitations.

Ticket alert: Scala never sleeps! Improvements are under development for getClass's return type, bolstering the robustness of Scala's type info.

Shining Light on Scala's Reflection Tools

The Mighty TypeTags

When ClassTag falls short, Scala offers TypeTags as its chief ally, enabling generic type info to dodge type erasure and allow detailed type introspection.

import scala.reflect.runtime.universe._

// Just a casual chat with TypeTag about object type.
def getTypeTag[T: TypeTag](obj: T): TypeTag[T] = typeTag[T]

val typeOfAccount = getTypeTag(new Account).tpe
println(typeOfAccount) // Boom! It's Account.

Good Old Manifests

Once upon a time before the era of ClassTag and TypeTag, Scala had Manifests for runtime class info. Even though they're old news, tracing back helps us appreciate Scala's evolution towards robust type introspection.

The Allure of Runtime Reflection

With Scala’s reflection library, you can toy with classes, methods, annotations, and much more at runtime. Talk about dynamic behavior!

val mirror = runtimeMirror(getClass.getClassLoader)
val clazz = mirror.classSymbol(accountClass)
val constructors = clazz.toType.declarations.collect { case m: MethodSymbol if m.isConstructor => m }
println(constructors) // And that's how Scala does the magic trick!