Llame al constructor predeterminado antes, pero no con frecuencia

Java requiere que hagas esto en la primera línea cuando llamas a un constructor desde dentro de otro constructor. Aprenda la lógica detrás de esta sintaxis y vea cómo usar this() para su beneficio.

P: ¿Por qué tiene que estar this() en la primera línea cuando se llama a un constructor desde dentro de otro constructor? ¿Hay alguna razón técnica detrás de esto?

R: La respuesta a esta pregunta es breve porque es la regla; la sintaxis del lenguaje Java establece que this() y super() solo se pueden usar en la primera línea de un constructor. Pero como normalmente descubrirá, hay una razón lógica detrás de esta sintaxis. En este caso, se basa en la inicialización y las llamadas al constructor. Esencialmente, siempre usa this() y super() en la primera línea de un constructor para evitar cambios en los pasos de ejecución del código que podrían sobrescribir valores específicos con valores predeterminados no deseados de otros constructores.

Primero, algunos antecedentes sobre this() y super() . Estos operadores llaman al constructor predeterminado de la instancia actual. Esta es una forma común de evitar la duplicación de código en una clase. Otros constructores definidos en la clase también pueden requerir parámetros. Los invoca de la misma manera, excepto que también pasa los argumentos apropiados. En algunos casos, es posible que se requiera una inicialización compleja cuando se crea una instancia de su clase. Cuando se crea una nueva instancia de clase, el cuerpo de su constructor se ejecuta después de todas sus superclases para garantizar que se acceda a los miembros de la superclase después de que se hayan inicializado. Las subclases pueden cambiar los valores de los miembros heredados, suponiendo que la superclase permita el acceso. El mismo principio se aplica a los constructores de clases sobrecargados. Entonces, solo usar this() y super() en la primera línea de un constructor permite que los constructores compartan código común, al tiempo que le brinda la flexibilidad de cambiar esos miembros diferentes sin arriesgarse a perder las personalizaciones.

Para demostrar cómo la ubicación de la llamada this() afecta los pasos de ejecución para crear una nueva clase, inicialicemos una clase de ejemplo llamada Simple, que es una subclase de Object, a través de algunos métodos diferentes. En el primer caso, la instancia de clase se crea a través del constructor predeterminado. Este constructor no contiene una llamada this(). Dicha clase se inicializaría como se muestra en el Listado A.

El primer paso para crear una instancia de la clase Simple es asignar memoria para las variables de instancia de Simple y su superclase, Object. A continuación, configure las variables de instancia en las clases Object y Simple a sus valores predeterminados: 0 para los números enteros iCount e iLine, y nulo para sStr. El constructor Simple se llama sin ningún parámetro. Dado que la clase Simple no llama a this() o super(), el compilador agrega una llamada al constructor predeterminado super(), que llama al constructor de la clase Object. Inicialice cualquier variable de instancia, ejecute el cuerpo del constructor del Objeto y devuelva el flujo de control a la clase Simple. A continuación, a sStr se le asigna el valor «Prueba simple» y se ejecuta el resto del constructor de la clase Simple, configurando las variables de instancia iCount en 2 e iLine en 1. Finalmente, el control vuelve a main.

Si cambia la llamada a la clase Simple para usar el constructor parametrizado, verá claramente por qué this() debe ser el primer elemento del constructor. El Listado B muestra cómo se lee ahora el código de CallSimple.

Como en el ejemplo anterior, cuando se crea una instancia de la clase Simple, se asigna memoria para la clase de instancia y su superclase, las variables de instancia se establecen en sus valores predeterminados y se llama al constructor. Esta vez, se llama al constructor con un parámetro. Este constructor llama a this() en la primera línea, lo que hace que se llame al constructor predeterminado. La primera línea del constructor predeterminado no tiene super() ni this(), por lo que el compilador agrega una llamada a super() para la clase Object. Cuando se devuelve el control de esta llamada super(), sStr se establece en «Prueba simple» y se ejecuta el resto del constructor predeterminado de la clase Simple. Luego devuelva el control al constructor que llamamos. Su cuerpo se ejecuta anulando los valores asignados por otros constructores de las variables que comparten. La Figura A muestra los pasos de ejecución en este caso.

Figura A

La primera línea usa los pasos de ejecución de this()

Ahora, supongamos que no hay límite en cuanto a dónde ocurre la llamada this() en el constructor. Cambie el constructor de Simple para que aparezca en la segunda línea en lugar de la primera, de la siguiente manera:
simple(int iCnt) {
iCuenta = iCant;
este();
}

La figura B muestra un nuevo conjunto de pasos de ejecución.

Figura B

Pasos para ejecutar cuando this() no está en la primera línea

El valor de iSimple.iCount ahora es 2 en lugar del valor esperado de 4. Llamar a this() desde cualquier lugar, excepto la primera línea en el constructor, puede cambiar la variable después de realizar otro trabajo. Este ejemplo básico solo asigna un valor diferente a un miembro de su clase. Imagínese lo desordenadas que pueden ser las cosas si una gran cantidad de miembros dependen de otros miembros. La recursividad de llamar a un constructor desde otro constructor, ya sea explícito o implícito, es confuso a primera vista. Sin embargo, en una inspección más detallada, se hace evidente que la recursividad es necesaria para garantizar que se acceda a los miembros de la superclase y a la clase en el orden correcto. Consulte la Sección 12.5 de la Especificación del lenguaje Java para obtener más detalles sobre este tema.

¿Tiene usted alguna pregunta?

¿Necesita ayuda con Java? Los técnicos de Builder.com están listos y dispuestos. Envíanos tu pregunta sobre Java y la analizaremos.