Hay varias razones por las que es incorrecto usar object .

1. el stacktrace es incorrecto de varias maneras:

   • Se crea en el momento de la creación de instancias, por lo que verá <clinit> como la primera línea en el seguimiento de la pila porque se crea al inicializar la clase del objeto por primera vez.
   • Incluso si lo lanza desde el mismo lugar, no será necesariamente cuando lo llame la misma persona que llama, por lo que la parte inferior (raíz) del seguimiento de la pila será incorrecta si esta excepción se lanza varias veces a lo largo de la vida de su aplicación.

2. técnicamente, la clase de excepción tiene partes mutables y sería peligroso/incorrecto permitir que el código del usuario altere esto. Un ejemplo muy concreto de esto es que el código de usuario podría agregar excepciones suprimidas a su instancia de excepción (que solo sería válida para un lanzamiento y, sin embargo, persistiría en su objeto). Esto es técnicamente una pérdida de memoria.

3. es probable que necesite mensajes diferentes con más información sobre por qué se lanzó (en ese caso, la ID duplicada es muy necesaria), por lo que necesita diferentes instancias con datos diferentes de todos modos

4. podría lanzarlo desde diferentes lugares en el futuro (¿incluso ahora en pruebas/simulacros tal vez?), y en ese caso el stacktrace sería aún más incorrecto

5. independientemente de tecnicismos como los anteriores, la class contra el object también envía un mensaje al lector que no está claro: ¿por qué un object aquí? Esta excepción no es inherentemente única. Da la casualidad de que lo lanzas en un lugar específico en este momento y confías en que el stacktrace sea el mismo.

Aquí hay un ejemplo para el problema principal (# 1):

 object MyExceptionObject : RuntimeException("boom") fun main() { try { caller1() // line 7 } catch (e: Exception) { } caller2() // line 10 } fun caller1() = doStuff() // line 13 fun caller2() = doStuff() // line 14 fun doStuff() { throw MyExceptionObject // line 17 }

El caller1() lanza la excepción pero esa es atrapada. El caller2() vuelve a lanzar la excepción y esa no se detecta. El seguimiento de pila que obtenemos para la excepción no detectada muestra incorrectamente la persona que llama 1 (con las líneas 7 y 13), pero la correcta debería ser la persona que llama 2 (con las líneas 10 y 14):

 Exception in thread "main" com.example.MyExceptionObject: boom at com.example.MyExceptionObject.<clinit>(ExceptionObjectExample.kt) at com.example.ExceptionObjectExampleKt.doStuff(ExceptionObjectExample.kt:17) at com.example.ExceptionObjectExampleKt.caller1(ExceptionObjectExample.kt:13) at com.example.ExceptionObjectExampleKt.main(ExceptionObjectExample.kt:7) at com.example.ExceptionObjectExampleKt.main(ExceptionObjectExample.kt)

Con todo, solo usa una clase.