En PC Resumen hablaremos de los constructores de clases en Java

Puede ser una tarea bastante pesada inicializar todas las variables de una clase cada vez que se crea una instancia. Incluso cuando se añaden funciones como setDim(), es más sencillo y preciso realizar todas las inicializaciones cuando el objeto se crea por primera vez. Como el proceso de inicialización es tan común, Java permite que los objetos se inicializa cuando se crean. Esta inicialización automática se lleva a cabo mediante un constructor.

Un constructor inicializa un objeto inmediatamente después de su creación; tiene el mismo nombre de la clase y es sintácticamente similar a un método. Una vez que se define, se llama automáticamente al constructor justo después de que se haya creado el objeto y antes de que termine el operador new. Los constructores resultan un tanto extraños porque no devuelven nada, ni siquiera vacío. Esto se debe a que el tipo implícito que devuelve el constructor es el mismo tipo de la clase. La función del constructor es inicializar el estado interno de un objeto de forma que el código que crea una instancia tenga una inicialización completa que podrá ser utilizada por ejemplo el objeto de forma inmediata.

Podemos modificar el ejemplo Caja de forma que las dimensiones de la caja se inicializa de forma automática cuando se construye el objeto. Para hacerlo sustituiremos el método setDim con un constructor. Empezaremos definiendo un constructor sencillo que simplemente asigna los mismos valores a las dimensiones de cada caja:

class Caja {
    double anchura;
    double altura;
    double profundidad;

    // Este es el constructor Caja.

    Caja() {
        System.out.println("Construyendo Caixa");
        anchura = 10;
        altura = 10;
        profundidad = 10;
    }

    double volumen() {
        return ancho * altura * profundidad;
    }
}

class CajaDemo6 {
    public static void main(String args[]) {

        // Declara, reserva memoria y inicializa los objetos Caja.

        Caja cajaMia1 = new Caja();
        Caja cajaMia2 = new Caja();
        double volumen;

        // Obtiene el volumen de la primera caja.

        volumen = cajaMia1.volumen();
        System.out.println("volumen es " + volumen);

        // Obtiene el volumen de la segunda caja.

        volumen = cajaMia2.volum();
        System.out.println("volumen es " + volumen);
    }
}

Las dos cajas han sido inicializadas por el constructor Caja() en el momento de crearse. Dado que el constructor da a todas las cajas las mismas dimensiones, tendrán el mismo volumen. La sentencia println dentro del constructor sólo sirve para mostrar cómo funciona el constructor. Normalmente el constructor no presenta nada para la salida, simplemente inicializa el objeto.

Hay que entender que en el momento de hacer new Caja() lo que se está haciendo es llamar al constructor. Cuando no se crea un constructor, Java crea una por defecto. Este asigna automáticamente a todas las variables el valor inicial a 0 o null. Para las clases sencillas, puede ser suficiente utilizar el constructor por defecto, pero esto no es válido para clases más sofisticadas. Una vez definido un constructor propio, el constructor por defecto deja de utilizarse.

Los constructores con parámetros

Aunque el constructor anterior inicializa un objeto Caja, no tiene mucho sentido que todas las cajas tengan las mismas dimensiones. Lo que se necesita es una forma de construir objetos Caja de diferentes dimensiones. La solución más sencilla es introducir parámetros en el constructor. Vemos la siguiente versión que define un constructor con parámetros que asigna a las dimensiones de una caja los valores especificados por los parámetros. Fíjese en la forma en que se crean los objetos Caja:

class Caja {
    double anchura;
    double altura;
    double profundidad;

    // Constructor de Caja.
    
    Caja(double w, double h, double d) {
        anchura = w;
        altura = h;
        profundidad = d;
    }

    // Cálculo y regreso el volumen.

    double volumen() {
        return ancho * altura * profundidad;
    }
}

class CajaDemo7{
    public static void main(String args[]) {

        // Declara, reserva, y inicializa los objetos Caja.

        Caja cajaMia1 = new Caja(10, 20, 15);
        Caja cajaMia2 = new Caja(3, 6, 9);
        double volumen;

        // Obtiene el volumen de la primera caja.

        volumen = cajaMia1.volum();
        System.out.println("volumen es " + volumen);

        // Obtiene el volumen de la segunda caja.
        volumen = cajaMia2.volumen();
        System.out.println("volumen es" + volumen);
    }
}

Si lo ejecutamos se puede ver cómo cada objeto se inicializa como se especifica en los parámetros al constructor.

La palabra clave this

En ocasiones un método necesitará hacer referencia al objeto que la ha llamado. Para que esto pueda suceder, Java define la palabra clave this. Esta palabra puede utilizarse dentro de cualquier métodos para hacer referencia al objeto actual. Es decir, este es siempre una referencia al objeto en el que el método se ha invocado. Puede utilizarse en cualquier lugar en el que se permita una referencia a un objeto del mismo tipo de la clase actual.

En Java no es válido declarar dos variables locales con el mismo nombre dentro del mismo contexto. Curiosamente, pueden haber variables locales, incluyendo los parámetros formales a métodos que coincidan con los nombres de las variables de instancia de clase. Pero cuando una variable local tiene el mismo nombre que una variable de instancia, la variable local oculta la variable de instancia. El hecho de que este permite hacer referencia directa al objeto, puede utilizarse para resolver cualquier colisión en el espacio de nombres que pueda darse entre variables de instancia y variables locales. Por ejemplo:

Caja (double anchura, double altura, double profundidad) {
    this.amplada = ancho;
    this.alçada = altura;
    this.profunditat = profundidad;
}
Pin It