Roberto Sánchez - Programador .NET/C++

Constructores.

Un constructor es algo así como el método principal de una clase, al que se le llama de manera automática en el momento de la creación de una instancia de dicha clase. La función del constructor es la de crear el objeto/instancia de la clase, y en él podemos incluir sentencias que realicen un comportamiento deseado a la hora de la creación del objeto. Cuando comiences a realizar programas, generalmente dejarás los constructores vacíos, y así te parecerá lo más correcto en un principio. Sin embargo, cuendo empieces a programar de verdad, comprobarás que será mejor incluir sentencias en los constructores para establecer un comportamiento específico de la clase.

El constructor de la clase se declara en el inicio de ésta, y es fácilmente identificable porque posee el mismo nombre de la clase. No puede retornar un valor (ni siquiera se le puede declarar con la palabra reservada 'void'). Un constructor de una clase, por ejemplo de nuestra clase 'Account', por omisión, se define de la siguiente manera:

public Account() { }

Esto es lo que se denomina un constructor por omisión, que no acepta parámetros de entrada, y podría parecer que no sirvce para nada, pero es necesario pues es el encargado de la creación de la instancia/objeto de esa clase. Al crear una instancia de esta clase con este tipo de constructor, el compilador creará el objeto con los valorexs predeterminados por el sistema, es decir, los atributos numéricos a cero, los alfanuméricvos a nulos y sus referencias a objetos como 'null'.

Sin embargo, como ya te he dicho antes, podemos incluir sentencias en el constructor, de manera que en el momento de la creación del objeto iniciemos los valores de sus atributos con los valores pasados como argumentos al constructor:

public class Program
{
    public static void Main()
    {
        Account account1 = new Account("Zipi", "0001", 100, 0.5);
        Account account2 = new Account("Zape", "0002", 10, 0.5);
    }
}
public class Account
{
    private string name;
    private string accountNumber;
    private double balance;
    private double rate;
    public string Name
    {
        get;
        set;
    }
    public string Name
    {
        get;
        set;
    }
    public string AccountNumber
    {
        get;
        set;
    }
    public double Balance
    {
        get;
        set;
    }
    public double Rate
    {
        get;
        set;
    }
    public Account(string newName, string newAccountNumber, double newBalance, double newRate)
    {
        Name = newName;
        AccountNumber = newAccountNumber;
        Balance = newBalance;
        Rate = newRate;
    }
}

Si analizas detenidamente el programa, te darás cuenta de que, sobre el mismo molde de la clase 'Account' hemos creado dos objetos, uno para Zipi y otro para Zape. Pero como hemos utilizado un constructor que recibe parámetros, la cuenta de Zipi se ha creado con un número '0001' y un saldo de 100, mientras que la cuenta de Zape se ha creado con un número '0002' y un saldo de 10. Como son hermanos, los hemos otorgado automáticamente un tipo de interés de 0,5 para los dos igual.

Ahora vamos a complicarlo un poco. Fíjate en el siguiente código fuente y observa las dos pequelas diferencias:

public class Program
{
    public static void Main()
    {
        Account account1 = new Account("Zipi", "0001", 100, 0.5);
        Account account2 = new Account();
    }
}
public class Account
{
    private string name;
    private string accountNumber;
    private double balance;
    private double rate;
    public string Name
    {
        get;
        set;
    }
    public string Name
    {
        get;
        set;
    }
    public string AccountNumber
    {
        get;
        set;
    }
    public double Balance
    {
        get;
        set;
    }
    public double Rate
    {
        get;
        set;
    }
    public Account() { }
    public Account(string newName, string newAccountNumber, double newBalance, double newRate)
    {
        Name = newName;
        AccountNumber = newAccountNumber;
        Balance = newBalance;
        Rate = newRate;
    }
}

Ahora lo que hemos hecho ha sido crear una cuenta para Zipi con número '0001', saldo de 100 y tipo de interés 0,5. Y hemos creado otra cuenta sin nombre, sin número, con saldo 0 y con tipo de interés 0. ¿Qué conclusión sacamos de esto? Pues que en una clase puede haber lo que se llama un constructor sobrecargado, es decir, un constructor sin parámetros y otro con parámetros, o dos constructores con parámetros diferentes. En el futuro verás la importancia de implementar clases con sobrecarga de constructores para poder crear diferentes tipos de instancias de esas clases. Este concepto de sobrecarga es fundamental que lo entiendas, pues se repetirá a la hora de estudiar la herencia y los métodos, que también pueden soportar sobrecarga, y es de gran interés para la programación avanzada.