Construtores e inicialização de objeto

1. Construtores simples

Construtor — é um método especial da classe que é chamado automaticamente quando você cria um objeto. Ele inicializa (configura) o objeto: define valores iniciais, faz validações, pode até te animar se você colocar uma piada nele.

O construtor deixa você criar o objeto já num estado certinho, sem precisar ficar setando cada campo e propriedade na mão. Isso é prático e seguro, porque você já passa tudo que é importante — e não esquece nada crítico.

Sem construtor, o código pode ficar grandão e mais fácil de dar ruim:

Person p = new Person();
p.Name = "Yulia";
p.Age = 25; // E se a gente esquecer de passar a idade?

Com construtor:

Person p = new Person("Yulia", 25); // Tudo passado de uma vez e o objeto já tá pronto pra vida!

Sintaxe do construtor

Construtor é um "método" especial, o nome dele é igualzinho ao nome da classe e ele não tem valor de retorno (nem mesmo void). Assim fica um construtor padrão:

public class Person
{
    // Construtor padrão (sem parâmetros)
    public Person()
    {
        // Aqui você pode colocar código de inicialização
    }
}

O construtor padrão é tipo um "ajudante invisível" que não recebe nenhum parâmetro e só inicializa todos os campos e propriedades da sua classe com os valores padrão:

• Pra tipos numéricos (int, double, float etc.) vai ser 0.
• Pra tipo booleano (bool) é false.
• Pra tipos de referência (string, outras classes) é null (tipo "nada", "sem referência pro objeto").
• Pra DateTime vai ser 01.01.0001 00:00:00.

Como chamar o construtor?

Quando você escreve o operador new pra criar um objeto, você tá chamando o construtor!

Person p = new Person();

Se você não definir nenhum construtor, o compilador C# vai criar pra você um construtor padrão (sem parâmetros). Mas se você declarar pelo menos um construtor seu — o padrão some, e o compilador vai pedir pra você adicionar ele na mão, se precisar.

Exemplo

Bora colocar um construtor na nossa classe do app. Aqui vai uma versão simples da classe de estudante:

public class Student
{
    public string Name;
    public int Age;

    // Construtor com dois parâmetros (nome e idade)
    public Student(string name, int age)
    {
        Name = name; // Atribui valor ao campo
        Age = age;
    }
}

Agora dá pra criar um estudante assim:

Student s = new Student("Ivan", 21);
Console.WriteLine($"{s.Name}: {s.Age} anos"); // Ivan: 21 anos

• A gente declarou o construtor com a mesma visibilidade (public) da classe.
• No construtor, a gente atribui os valores pros campos usando os parâmetros recebidos.
• Assim, o compilador obriga você a passar nome e idade quando cria o objeto — não tem como esquecer.

2. Parâmetros do construtor

No C#, dá pra declarar vários construtores com conjuntos diferentes de parâmetros. Isso se chama sobrecarga de construtor (a gente ainda vai falar de sobrecarga de métodos depois).

Por exemplo, bora adicionar um construtor sem parâmetros:

public class Student
{
    public string Name;
    public int Age;

    // Construtor padrão
    public Student()
    {
        Name = "SemNome";
        Age = 0;
    }

    // Construtor com parâmetros
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Agora os dois jeitos funcionam:

Student s1 = new Student();          // Nome: SemNome, idade: 0
Student s2 = new Student("Olya", 22); // Nome: Olya, idade: 22

Usando construtor pra validação

Construtor é um lugar massa pra validar os dados que chegam. Tipo, estudante não pode ter idade negativa!

public Student(string name, int age)
{
    if (age < 0)
        throw new ArgumentException("Idade não pode ser negativa!");
    Name = name;
    Age = age;
}

Agora, se alguém tentar criar um estudante Student("Bebê", -2), o app vai lançar uma exceção (ArgumentException). Esse jeito é bem usado pra garantir que os dados são confiáveis.

3. Inicialização de objetos complexos

Muitas vezes, nos apps de verdade, um objeto pode ser "montado" não só de tipos primitivos, mas também conter outros objetos:

public class Group
{
    public string GroupName;
    public Student[] Students;

    public Group(string groupName, Student[] students)
    {
        GroupName = groupName;
        Students = students;
    }
}

Agora dá pra criar um grupo com uma galera de estudantes:

var students = new Student[]
{
    new Student("Ivan", 20),
    new Student("Maria", 19)
};
Group g = new Group("Grupo-101", students);

Inicializando campos com valores padrão

Às vezes, você quer definir valores padrão pra alguns campos, caso nem todos os parâmetros venham no construtor. Tipo, se o e-mail não for obrigatório:

public Student(string name, int age)
{
    Name = name;
    Age = age;
    Email = "unknown@noemail.com"; // Valor padrão
}

4. Inicialização via Object Initializer

Com construtores, dá pra misturar outro jeito prático — inicializadores de objetos. Você chama o construtor e depois nas chaves passa os valores das propriedades do novo objeto:

public class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string Email { get; set; }

    // Ainda é recomendado ter construtor
    public Student(string name, int age)
    {
        Name = name;
        Age = age;
        Email = "";
    }
}

Student s = new Student("Anton", 18) { Email = "anton@domain.com" }; // construtor + propriedades

Esse jeito combina bem com construtor, quando alguns parâmetros têm valor padrão ou nem sempre são conhecidos na criação.

5. Erros comuns e detalhes

Quando mexe com construtores, quem tá começando costuma tropeçar em alguns erros clássicos. Bora ver eles rapidinho:

Erro #1: Nome diferente
Às vezes, a galera confunde nome de parâmetro e campo, principalmente se só muda maiúscula/minúscula.

public Student(string Name, int Age) // Com maiúscula!
{
    Name = Name; // Opa! Os dois Name são o parâmetro. O campo fica sem valor.
}

Como fazer certo: Usa this pra referenciar o campo do objeto:

public Student(string name, int age)
{
    this.Name = name;
    this.Age = age;
}

Ou só escolhe nomes diferentes (tipo nameParam, ageParam), mas usar this. é considerado estiloso, principalmente em projetos grandes.

Erro #2: Não tem construtor padrão

Se você declarou pelo menos um construtor, e depois tenta criar objeto sem passar parâmetro — vai dar erro de compilação:

public class Student
{
    public Student(string name) { /*...*/ }
}

// em algum lugar do código
Student s = new Student(); // Erro! Não tem construtor sem parâmetros.

Solução: Adiciona o construtor sem parâmetros na mão:

public Student() { /*...*/ }

Erro #3: Recursão infinita — se o construtor chama ele mesmo

public Student()
{
    // Erro! Chama ele mesmo — recursão infinita.
    new Student();
}