0Pricing
C# Academy · Aula

Definindo construtores

Crie instâncias com construtores parametrizados.

Definindo construtores é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O que é um construtor

Um construtor é um método especial executado quando um objeto é criado com new. Ele tem o mesmo nome da classe e nenhum tipo de retorno. Sua função é colocar o objeto em um estado inicial válido.

using System;

class Dog
{
    public Dog()
    {
        Console.WriteLine("A dog was created");
    }
}

class Program
{
    static void Main()
    {
        var d = new Dog();
    }
}

Construtores parametrizados

Um construtor pode receber parâmetros para que o chamador forneça os valores iniciais. Esse é o padrão mais comum para definir dados obrigatórios.

using System;

class Person
{
    public string Name;
    public int Age;

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main()
    {
        var p = new Person("Ada", 36);
        Console.WriteLine(p.Name + " is " + p.Age);
    }
}

A palavra-chave this nos construtores

Quando o nome de um parâmetro corresponde ao nome de um campo, use this. para fazer referência ao campo e distingui-lo do parâmetro.

using System;

class Book
{
    public string Title;

    public Book(string title)
    {
        this.Title = title;
    }
}

class Program
{
    static void Main()
    {
        var b = new Book("C# Basics");
        Console.WriteLine(b.Title);
    }
}

O construtor padrão

Se o senhor não escrever nenhum construtor, o compilador fornecerá um construtor sem parâmetros. Porém, assim que definir qualquer construtor, esse padrão desaparecerá, a menos que o senhor o adicione manualmente.

using System;

class Empty
{
    // No constructor written -> compiler supplies a default one
    public int Value;
}

class Program
{
    static void Main()
    {
        var e = new Empty();
        Console.WriteLine("Default Value: " + e.Value);
    }
}

Validação em um construtor

Um construtor pode validar seus argumentos, garantindo que o objeto nunca seja criado em um estado inválido.

using System;

class Account
{
    public decimal Balance;

    public Account(decimal initial)
    {
        if (initial < 0)
            throw new ArgumentException("Initial balance cannot be negative");
        Balance = initial;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account(100m);
        Console.WriteLine("Balance: " + a.Balance);
    }
}

Sobrecarga de construtores

Uma classe pode ter vários construtores com diferentes listas de parâmetros. O compilador escolhe aquele que corresponde aos argumentos fornecidos.

using System;

class Point
{
    public int X;
    public int Y;

    public Point()
    {
        X = 0;
        Y = 0;
    }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

class Program
{
    static void Main()
    {
        var origin = new Point();
        var p = new Point(3, 4);
        Console.WriteLine(origin.X + "," + origin.Y + " | " + p.X + "," + p.Y);
    }
}

Definindo propriedades a partir de um construtor

Os construtores normalmente atribuem valores a propriedades automáticas, inclusive às que permitem apenas inicialização ou possuem acessadores de escrita privados.

using System;

class Product
{
    public string Name { get; }
    public decimal Price { get; }

    public Product(string name, decimal price)
    {
        Name = name;
        Price = price;
    }
}

class Program
{
    static void Main()
    {
        var p = new Product("Pen", 1.50m);
        Console.WriteLine(p.Name + ": " + p.Price);
    }
}

Valores padrão de parâmetros

Os parâmetros do construtor podem ter valores padrão, permitindo que os chamadores os omitam. Isso frequentemente reduz a necessidade de várias sobrecargas.

using System;

class Circle
{
    public double Radius;
    public string Color;

    public Circle(double radius, string color = "black")
    {
        Radius = radius;
        Color = color;
    }
}

class Program
{
    static void Main()
    {
        var c1 = new Circle(2);
        var c2 = new Circle(3, "red");
        Console.WriteLine(c1.Color + " | " + c2.Color);
    }
}

Executando trabalho em um construtor

Além de atribuir valores aos campos, um construtor pode calcular dados derivados ou preparar os recursos necessários ao objeto.

using System;

class Rectangle
{
    public double Width;
    public double Height;
    public double Area;

    public Rectangle(double w, double h)
    {
        Width = w;
        Height = h;
        Area = w * h;
    }
}

class Program
{
    static void Main()
    {
        var r = new Rectangle(4, 5);
        Console.WriteLine("Area: " + r.Area);
    }
}

Construtores e dados obrigatórios

Colocar valores obrigatórios no construtor torna-os necessários: não é possível criar o objeto sem fornecê-los.

using System;

class User
{
    public string Id;
    public string Email;

    public User(string id, string email)
    {
        Id = id;
        Email = email;
    }
}

class Program
{
    static void Main()
    {
        var u = new User("u1", "a@b.com");
        Console.WriteLine(u.Id + " / " + u.Email);
    }
}

Reunindo tudo

Um construtor bem projetado valida a entrada, atribui valores aos campos e deixa o objeto totalmente pronto para uso.

using System;

class Temperature
{
    public double Celsius { get; }
    public double Fahrenheit { get; }

    public Temperature(double celsius)
    {
        if (celsius < -273.15)
            throw new ArgumentException("Below absolute zero");
        Celsius = celsius;
        Fahrenheit = celsius * 9 / 5 + 32;
    }
}

class Program
{
    static void Main()
    {
        var t = new Temperature(25);
        Console.WriteLine(t.Celsius + "C = " + t.Fahrenheit + "F");
    }
}

Verificação rápida

Teste sua compreensão sobre construtores.

Recapitulação

Um construtor compartilha o nome da classe, não tem tipo de retorno e é executado com new. Construtores parametrizados recebem valores iniciais; this. diferencia campos de parâmetros. Você pode sobrecarregar construtores e usar valores padrão para parâmetros. Definir qualquer construtor remove o construtor padrão gerado automaticamente.

using System;

class Demo
{
    public string Name;
    public Demo(string name = "anon")
    {
        this.Name = name;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(new Demo().Name);
        Console.WriteLine(new Demo("Kai").Name);
    }
}

Perguntas Frequentes

A aula “Definindo construtores” é grátis?

Sim — o texto completo de “Definindo construtores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Definindo construtores”?

Crie instâncias com construtores parametrizados. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Definindo construtores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definindo construtores
  2. Encadeamento de construtores com this
  3. Inicializadores de objetos e coleções
  4. Construtores estáticos
← Voltar para C# Academy