Construtores de instâncias (Guia de Programação em C#)

Artigo
06/10/2015

Construtores de instância são usados para criar e inicializar variáveis de membro qualquer instância quando você usa o nova a expressão para criar um objeto de um classe. Para inicializar um estático classe ou variáveis estáticas em uma classe não-estático, você deve definir um construtor estático. Para obter mais informações, consulte Construtores estáticos (Guia de Programação em C#).

O exemplo a seguir mostra um construtor de instância:

class CoOrds
{
    public int x, y;

    // constructor 
    public CoOrds()
    {
        x = 0;
        y = 0;
    }
}

Dica

Para maior clareza, essa classe contém campos públicos.O uso de campos públicos não é uma prática recomendada de programação, pois permite que qualquer método em qualquer lugar em um programa irrestrito e sem a verificação de acesso ao funcionamento interno de um objeto.Membros de dados costuma ser particulares e devem ser acessados apenas por meio de propriedades e métodos da classe.

Este construtor de instância é chamado sempre que um objeto se baseia o CoOrds classe é criada. Um construtor como esta, que leva sem argumentos, será chamado de um construtor padrão. No entanto, muitas vezes é útil fornecer construtores adicionais. Por exemplo, podemos adicionar um construtor para o CoOrds classe que nos permite especificar os valores iniciais para os membros de dados:

// A constructor with two arguments: 
public CoOrds(int x, int y)
{
    this.x = x;
    this.y = y;
}

Isso permite que CoOrd objetos a serem criados com padrão ou valores iniciais específicos, como este:

CoOrds p1 = new CoOrds();
CoOrds p2 = new CoOrds(5, 3);

Se uma classe não tem um construtor, um construtor padrão é gerado automaticamente e os valores padrão serão usados para inicializar os campos do objeto. Por exemplo, um int é inicializado para 0. Para obter mais informações sobre valores padrão, consulte Tabela de valores padrão (Referência de C#). Portanto, porque o CoOrds construtor padrão da classe inicializa todos os membros de dados para zero, pode ser totalmente removido sem alterar o funcionamento da classe. Um exemplo completo usando vários construtores é fornecido no exemplo 1, posteriormente neste tópico, e um exemplo de um construtor gerado automaticamente é fornecido no exemplo 2.

Construtores de instância também podem ser usados para chamar os construtores de instância de classes base. O construtor da classe pode chamar o construtor da classe base através do inicializador, da seguinte maneira:

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {
    }
}

Neste exemplo, o Circle classe passa os valores que representam o radius e a altura para o construtor fornecido por Shape do qual Circle é derivado. Um exemplo completo usando Shape e Circle aparece nesse tópico como exemplo 3.

Exemplo 1

O exemplo a seguir demonstra uma classe com construtores de classe dois um sem argumentos e com dois argumentos.

class CoOrds
{
    public int x, y;

    // Default constructor: 
    public CoOrds()
    {
        x = 0;
        y = 0;
    }

    // A constructor with two arguments: 
    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    // Override the ToString method: 
    public override string ToString()
    {
        return (String.Format("({0},{1})", x, y));
    }
}

class MainClass
{
    static void Main()
    {
        CoOrds p1 = new CoOrds();
        CoOrds p2 = new CoOrds(5, 3);

        // Display the results using the overriden ToString method:
        Console.WriteLine("CoOrds #1 at {0}", p1);
        Console.WriteLine("CoOrds #2 at {0}", p2);
        Console.ReadKey();
    }
}
/* Output:
 CoOrds #1 at (0,0)
 CoOrds #2 at (5,3)        
*/

Exemplo 2

Neste exemplo, a classe Person não tem qualquer construtores, nesse caso, um construtor padrão é fornecido automaticamente e os campos são inicializados para seus valores padrão.

public class Person
{
    public int age;
    public string name;
}

class TestPerson
{
    static void Main()
    {
        Person person = new Person();

        Console.WriteLine("Name: {0}, Age: {1}", person.name, person.age);
        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output:  Name: , Age: 0

Observe que o valor padrão de age é 0 e o valor padrão de name é null. Para obter mais informações sobre valores padrão, consulte Tabela de valores padrão (Referência de C#).

Exemplo 3

O exemplo a seguir demonstra o uso de inicializador de classe base. O Circle classe é derivada da classe geral Shapee o Cylinder classe é derivada da Circle classe. O construtor em cada classe derivada está usando seu inicializador de classe base.

abstract class Shape
{
    public const double pi = Math.PI;
    protected double x, y;

    public Shape(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public abstract double Area();
}

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {
    }
    public override double Area()
    {
        return pi * x * x;
    }
}

class Cylinder : Circle
{
    public Cylinder(double radius, double height)
        : base(radius)
    {
        y = height;
    }

    public override double Area()
    {
        return (2 * base.Area()) + (2 * pi * x * y);
    }
}

class TestShapes
{
    static void Main()
    {
        double radius = 2.5;
        double height = 3.0;

        Circle ring = new Circle(radius);
        Cylinder tube = new Cylinder(radius, height);

        Console.WriteLine("Area of the circle = {0:F2}", ring.Area());
        Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area());

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Area of the circle = 19.63
    Area of the cylinder = 86.39
*/

Para obter mais exemplos sobre como chamar os construtores de classe base, consulte virtual (Referência de C#), override (Referência de C#), e base (Referência de C#).