Construtores de instâncias (Guia de Programação em C#)Instance Constructors (C# Programming Guide)

Os construtores de instância são usados para criar e inicializar quaisquer variáveis de membro de instância quando você usa a expressão new para criar um objeto de uma classe.Instance constructors are used to create and initialize any instance member variables when you use the new expression to create an object of a class. Para inicializar uma classe estática ou variáveis estáticas em uma classe não estática, defina um construtor estático.To initialize a static class, or static variables in a non-static class, you define a static constructor. Para obter mais informações, consulte Construtores estáticos.For more information, see Static Constructors.

O exemplo a seguir mostra um construtor de instância:The following example shows an instance constructor:

class Coords
{
    public int x, y;

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

Observação

Para maior clareza, essa classe contém campos públicos.For clarity, this class contains public fields. O uso de campos públicos não é uma prática de programação recomendada, porque permite que qualquer acesso de programa não restrito e não verificado a trabalhos internos de um objeto.The use of public fields is not a recommended programming practice because it allows any method anywhere in a program unrestricted and unverified access to an object's inner workings. Geralmente os membros de dados devem ser privados e devem ser acessados apenas por meio de propriedades e métodos de classe.Data members should generally be private, and should be accessed only through class methods and properties.

Esse construtor de instância é chamado sempre que um objeto com base na classe Coords é criado.This instance constructor is called whenever an object based on the Coords class is created. Um construtor como este, que não usa nenhum argumento, é chamado um construtor sem parâmetros.A constructor like this one, which takes no arguments, is called a parameterless constructor. No entanto, geralmente é útil fornecer construtores adicionais.However, it is often useful to provide additional constructors. Por exemplo, podemos adicionar um construtor à classe Coords que nos permite especificar os valores iniciais para os membros de dados:For example, we can add a constructor to the Coords class that allows us to specify the initial values for the data members:

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

Isso permite que objetos Coords sejam criados com os valores iniciais padrão ou específicos, como este:This allows Coords objects to be created with default or specific initial values, like this:

var p1 = new Coords();
var p2 = new Coords(5, 3);

Se uma classe não tiver um construtor, um construtor sem parâmetros será gerado automaticamente e os valores padrão serão usados para inicializar os campos de objeto.If a class does not have a constructor, a parameterless constructor is automatically generated and default values are used to initialize the object fields. Por exemplo, um int é inicializada como 0.For example, an int is initialized to 0. Para obter informações sobre os valores padrão de tipo, consulte valores C# padrão de tipos.For information about the type default values, see Default values of C# types. Portanto, como construtor sem parâmetros da classe Coords inicializa todos os membros de dados como zero, ele pode ser totalmente removido sem alterar a maneira como a classe funciona.Therefore, because the Coords class parameterless constructor initializes all data members to zero, it can be removed altogether without changing how the class works. Um exemplo completo que usa vários construtores é fornecido no Exemplo 1 posteriormente neste tópico e um exemplo de um construtor gerado automaticamente é fornecido no Exemplo 2.A complete example using multiple constructors is provided in Example 1 later in this topic, and an example of an automatically generated constructor is provided in Example 2.

Construtores de instância também podem ser usados para chamar os construtores de instância de classes base.Instance constructors can also be used to call the instance constructors of base classes. O construtor de classe pode invocar o construtor da classe base por meio do inicializador, da seguinte maneira:The class constructor can invoke the constructor of the base class through the initializer, as follows:

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

Neste exemplo, a classe Circle passa valores que representam o raio e a altura do construtor fornecido pelo Shape do qual Circle é derivado.In this example, the Circle class passes values representing radius and height to the constructor provided by Shape from which Circle is derived. Um exemplo completo que usa Shape e Circle é exibido neste tópico como Exemplo 3.A complete example using Shape and Circle appears in this topic as Example 3.

Exemplo 1Example 1

O exemplo a seguir demonstra uma classe com dois construtores de classe, um sem argumentos e outro com dois argumentos.The following example demonstrates a class with two class constructors, one without arguments and one with two arguments.

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 $"({x},{y})";
    }
}

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

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

Exemplo 2Example 2

Neste exemplo, a classe Person não tem nenhum construtor. Nesse caso, um construtor sem parâmetros é fornecido automaticamente e os campos são inicializados com seus valores padrão.In this example, the class Person does not have any constructors, in which case, a parameterless constructor is automatically provided and the fields are initialized to their default values.

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

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

        Console.WriteLine("Name: {person.name}, Age: {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.Notice that the default value of age is 0 and the default value of name is null.

Exemplo 3:Example 3

O exemplo a seguir demonstra como usar o inicializador de classe base.The following example demonstrates using the base class initializer. A classe Circle é derivada da classe geral Shape e a classe Cylinder é derivada da classe Circle.The Circle class is derived from the general class Shape, and the Cylinder class is derived from the Circle class. O construtor em cada classe derivada está usando seu inicializador de classe base.The constructor on each derived class is using its base class initializer.

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 a invocação de construtores de classe base, consulte virtual, override e base.For more examples on invoking the base class constructors, see virtual, override, and base.

Veja tambémSee also