Creación de objetos

Operador new

    Ahora que ya sabemos cómo definir las clases de objetos que podremos usar en nuestras aplicaciones ha llegado el momento de explicar cómo crear objetos de una determinada clase. Algo de ello ya se introdujo en el Tema 4: Aspectos Léxicos cuando se comentó la utilidad del operador new, que precisamente es crear objetos y cuya sintaxis es:

	
new
<nombreTipo>(<parametros>)

    Este operador crea un nuevo objeto del tipo cuyo nombre se le indica y llama durante su proceso de creación al constructor del mismo apropiado según los valores que se le pasen en <parametros>, devolviendo una referencia al objeto recién creado. Hay que resaltar el hecho de que new no devuelve el propio objeto creado, sino una referencia a la dirección de memoria dinámica donde en realidad se ha creado.

    El antes comentado constructor de un objeto no es más que un método definido en la definición de su tipo que tiene el mismo nombre que la clase a la que pertenece el objeto y no tiene valor de retorno. Como new siempre devuelve una  referencia a  la dirección de memoria donde se cree el objeto y los constructores sólo pueden usarse como operandos de new, no  tiene  sentido que un constructor devuelva objetos, por lo que no tiene sentido incluir en su definición un campo <tipoDevuelto> y el compilador considera erróneo hacerlo (aunque se indique void)

    El constructor recibe ese nombre debido a que su código suele usarse precisamente para construir el objeto, para inicializar sus miembros. Por ejemplo, a nuestra clase de ejemplo Persona le podríamos añadir un constructor dejándola así:


  class Persona
  {
     string Nombre; // Campo de cada objeto Persona que almacena su nombre
     int    Edad;   // Campo de cada objeto Persona que almacena su edad
     string NIF;    // Campo de cada objeto Persona que almacena su NIF
 
     void Cumpleaños()   // Incrementa en uno la edad del objeto Persona
     {
              Edad++;
     }
                       
     Persona (string nombre, int edad, string nif) // Constructor
     {
              Nombre = nombre;
              Edad = edad;
              NIF = nif;
     }
  }

      
    Como se ve en el código, el constructor toma como parámetros los valores con los que deseemos inicializar el objeto a crear. Gracias a él, podemos crear un objeto Persona de nombre José, de 22 años de edad y NIF 12344321-A así:

	
new Persona("José", 22, "12344321-A")

    Nótese que la forma en que se pasan parámetros al constructor consiste en indicar los valores que se ha de dar a cada uno de los parámetros indicados en la definición del mismo separándolos por comas. Obviamente, si un parámetro se definió como de tipo string habrá que pasarle una cadena, si se definió de tipo int habrá que pasarle un entero y, en general, a todo parámetro habrá que pasarle un valor de su mismo tipo (o de alguno convertible al mismo), produciéndose un error al compilar si no se hace así.

    En realidad un objeto puede tener múltiples constructores, aunque para diferenciar a unos de otros es obligatorio que se diferencien en el número u orden de los parámetros que aceptan, ya que el nombre de todos ellos ha de coincidir con el nombre de la clase de la que son miembros. De ese modo, cuando creemos el objeto el compilador podrá inteligentemente determinar cuál de los constructores ha de ejecutarse en función de los valores que le pasemos al new.

    Una vez creado un objeto lo más normal es almacenar la dirección devuelta por new en una variable del tipo apropiado para el objeto creado. El siguiente ejemplo -que como es lógico irá dentro de la definición de algún método- muestra cómo crear una variable de tipo Persona llamada p y cómo almacenar en ella la dirección del objeto que devolvería la anterior aplicación del operador new:


Persona p; // Creamos variable p
p = new Persona("Jose", 22, "12344321-A");
// Almacenamos en p el objeto creado con new

    A partir de este momento la variable p contendrá una referencia a un objeto de clase Persona que representará a una persona llamada José de 22 años y NIF 12344321-A. O lo que prácticamente es lo mismo y suele ser la forma comúnmente usada para decirlo: la variable p representa a una persona llamada José de 22 años y NIF 12344321-A.

    Como lo más normal suele ser crear variables donde almacenar referencias a objetos que creemos, las instrucciones anteriores pueden compactarse en una sola así:


Persona p = new Persona("José", 22, "12344321-A");

    De hecho, una sintaxis más general para la definición de variables es la siguiente:


<tipoDato> <nombreVariable> = <valorInicial>;

    La parte = <valorInicial> de esta sintaxis es en realidad opcional, y si no se incluye la variable declarada pasará a almacenar una referencia nula (contendrá el literal null)

Constructor por defecto

    No es obligatorio definir un constructor para cada clase, y en caso de que no definamos ninguno el compilador creará uno por nosotros sin parámetros ni instrucciones. Es decir, como si se hubiese definido de esta forma:


<nombreTipo>(){}

    Gracias a este constructor introducido automáticamente por el compilador, si Coche es una clase en cuya definición no se ha incluido ningún constructor, siempre será posible crear uno nuevo usando el operador new así:


Coche c = new Coche(); //Crea coche c llamando al constructor por defecto de Coche
        
    Hay que tener en cuenta una cosa: el constructor por defecto es sólo incluido por el compilador si no hemos definido ningún otro constructor. Por tanto, si tenemos una clase en la que hayamos definido algún constructor con parámetros pero ninguno sin parámetros no será válido crear objetos de la misma llamando al constructor sin parámetros, pues el compilador no lo habrá definido automáticamente. Por ejemplo, con la última versión de la clase de ejemplo Persona es inválido hacer:


Persona p = new Persona(); // ERROR:
// El único constructor de Persona
// toma 3 parámetros

Referencia al objeto actual con this

    Dentro del código de cualquier método de un objeto siempre es posible hacer referencia al propio objeto usando la palabra reservada this. Esto puede venir bien a la hora de escribir constructores de objetos debido a que permite que los nombres que demos a los parámetros del constructor puedan coincidir nombres de los campos del objeto sin que haya ningún problema. Por ejemplo, el constructor de la clase Persona escrito anteriormente se puede rescribir así usando this:


Persona (string Nombre, int Edad, string NIF)
{
 this.Nombre = Nombre;
 this.Edad = Edad;
 this.NIF = NIF;
}

    Es decir, dentro de un método con parámetros cuyos nombres coincidan con campos, se da preferencia a los parámetros y para hacer referencia a los campos hay que prefijarlos con el this tal y como se muestra en el ejemplo.

    El ejemplo anterior puede que no resulte muy interesante debido a que para evitar tener que usar this podría haberse escrito el constructor tal y como se mostró en la primera versión del mismo: dando nombres que empiecen en minúscula a los parámetros y nombres que empiecen con mayúsculas a los campos. De hecho, ese es el convenio que Microsoft recomienda usar. Sin embargo, como más adelante se verá sí que puede ser útil this cuando los campos a inicializar a sean privados, ya que el convenio de escritura de identificadores para campos privados recomendado por Microsoft coincide con el usado para dar identificadores a parámetros (obviamente otra solución sería dar cualquier otro nombre a los parámetros del constructor o los campos afectados, aunque así el código perdería algo legibilidad)

    Un uso más frecuente de this en C# es el de permitir realizar llamadas a un método de un objeto desde código ubicado en métodos del mismo objeto. Es decir, en C# siempre es necesario que cuando llamemos a algún método de un objeto precedamos al operador . de alguna expresión que indique cuál es el objeto a cuyo método se desea llamar, y si éste método pertenece al mismo objeto que hace la llamada la única forma de conseguir indicarlo en C# es usando this.

    Finalmente, una tercera utilidad de this es permitir escribir métodos que puedan devolver como objeto el propio objeto sobre el que el método es aplicado. Para ello bastaría usar una instrucción return this; al indicar el objeto a devolver.

Creación de objetos
José Antonio González Seco

José Antonio es experto en tecnologias Microsoft. Imparte cursos y conferencias en congresos sobre C# y .NET en Universidades de toda España (Sevilla, Barcelona, San Sebastián, Valencia, Oviedo, etc.) en representación de grandes empresas como Microsoft.
Fecha de alta:03/10/2006
Última actualizacion:03/10/2006
Visitas totales:83766
Valorar el contenido:
Últimas consultas realizadas en los foros
Últimas preguntas sin contestar en los foros de devjoker.com