Classes e objetos: criação, construtores e inicialização

1. Criando um objeto

Chegamos na parte de criar objetos. Tu já viu isso antes, mas agora vamos destrinchar o assunto. Na real, criar objetos é bem tranquilo.

Pra criar um objeto, tu usa o operador new. Normalmente tu cria uma nova instância (objeto) de uma classe e já salva ela numa variável do mesmo tipo.

Classe nome = new Classe(parâmetros);

Aqui, Classe é o tipo do objeto, nome é o nome da variável (geralmente começa com minúscula, tipo cat), e à direita do = rola a criação do novo objeto dessa classe.

Exemplos:

object o = new object();

Cat pet = new Cat();

var reader = new StreamReader("file.txt");

Muitas vezes a galera chama as variáveis com o mesmo nome da classe, só que começando com minúscula. Pra quem tá começando, isso pode confundir:

Student student = new Student();

Car car = new Car();

PersonInfo personInfo = new PersonInfo();

Mas relaxa, esse código é super normal — só tá criando uma variável e já inicializando ela com um objeto do mesmo tipo.

À esquerda — declaração da variável, à direita — criação do novo objeto na memória usando new. Só isso!

2. Construtor

Tu já deve ter visto que, quando cria um objeto, às vezes passa uns parâmetros. Em alguns objetos tu passa parâmetros, em outros não. Como funciona esse lance dos parâmetros?

É simples: toda classe tem um método especial (ou vários) que cuida dos parâmetros na hora de criar o objeto. Esses métodos são chamados de construtores. Um método desses é um construtor.

Dá pra sacar fácil um construtor no código. Ele tem duas características:

• o nome do construtor é igual ao nome da classe (e começa com maiúscula)
• o construtor não tem tipo de retorno (nem void aparece).

O formato geral é assim:

modificadores Classe(parâmetros)
{
   código do construtor
}

Exemplo de declaração de construtor:

public class Point
{
    public int X;
    public int Y;

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

Usando:

Point p = new Point(5, 10); // Chamando o construtor

Quando tu cria um objeto com new Point(5, 10), vai chamar o construtor com dois parâmetros, que inicializam os campos X e Y.

Às vezes os parâmetros do construtor têm o mesmo nome dos campos — só pra facilitar. Esse conflito de nomes se resolve usando a palavra-chave this:

public Point(int x, int y)
{
    this.x = x; // this.x é o campo do objeto, x é o parâmetro do construtor
    this.y = y;
}

3. Chamando o construtor

Quando tu escreve new Classe(parâmetros), o C#:

• cria um novo objeto na memória,
• chama o construtor certo, passando teus parâmetros.

Exemplo com classe de gato:

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

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

Usando:

Cat cat = new Cat("Vaska", 2); // Pode: chama o construtor com dois parâmetros
Cat cat2 = new Cat("Vaska");   // Não pode: não existe esse construtor — erro de compilação
Cat cat3 = new Cat();          // Não pode: não tem construtor sem parâmetros — erro de compilação

Se a classe só tem construtor com parâmetros, tu é obrigado a passar valores pra eles na hora de criar o objeto.

4. Vários construtores

Mas se tu quiser, pode colocar vários construtores na classe. Não tem limite de quantos construtores ou parâmetros tu pode ter. Quando tu cria o objeto, o compilador escolhe o construtor certo pelos parâmetros.

Exemplo:

public class Cat
{
    public const int DESCONHECIDO = -1;
    public string Name;
    public int Age;

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

    public Cat(string name)
    {
        Name = name;
        Age = DESCONHECIDO; // Valor "padrão" pra idade desconhecida
    }
}

Usando:

Cat cat1 = new Cat("Vaska", 2); // Usa o primeiro construtor
Cat cat2 = new Cat("Murka");    // Usa o segundo construtor
Cat cat3 = new Cat();           // Erro! Não tem construtor sem parâmetros

Aqui a gente pensou que a idade do gato pode ser desconhecida. Pra isso, colocamos uma constante especial — DESCONHECIDO e um construtor que só recebe o nome do gato.

Repara que a gente ainda inicializa as duas variáveis da classe dentro dos dois construtores. Parâmetros desconhecidos/faltando a gente troca pela constante DESCONHECIDO.

5. Construtor padrão

Se tua classe não tem nenhum construtor, o compilador automaticamente coloca um construtor vazio sem parâmetros:

public ClassName()
{
}

Mas se tu já declarou pelo menos um construtor — o construtor vazio não é mais criado automaticamente.

Exemplo 1:

public class Cat
{
    public string Name;
    public int Age;
}

// Pode:
Cat cat = new Cat(); // Vai chamar o construtor padrão (sem parâmetros)

Exemplo 2:

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

    public Cat(string name) { Name = name; }
}

// Não pode:
Cat cat = new Cat(); // Erro: não tem mais construtor sem parâmetros!

6. Inicializando variáveis

Em C#, tu pode inicializar variáveis da classe direto na declaração ou dentro do construtor.

Exemplo:

public class Cat
{
    public string Name;
    public int Age = -1; // Valor inicial

    public Cat(string name, int age)
    {
        Name = name;
        Age = age; // Sobrescreve o valor inicial
    }

    public Cat()
    {
        Name = "SemNome";
        // Age fica -1 (valor inicial)
    }
}

Explicando:

• Quando cria com new Cat("Vaska", 2) a variável Age começa como -1, mas o construtor muda pra 2.
• Quando cria com new Cat() — Age continua -1.

7. Ordem de inicialização das variáveis

Os dados do novo objeto são inicializados nessa ordem:

1. Campos da classe primeiro recebem valores padrão (0 pra int, null pra tipos de referência, etc).
2. Depois rolam os inicializadores que tu colocou na declaração dos campos, na ordem que aparecem no código.
3. Só depois disso roda o código do construtor.

As variáveis são inicializadas antes do construtor e na ordem que tu declarou. Então fica ligado nas dependências entre os campos.

Exemplo errado

Campos não estáticos não podem ser inicializados usando outras variáveis não estáticas:

public class Solution
{
    public int a = 1; 
    public int b = a;        // não pode usar a
    public int c = a + b;   // não pode usar a e b
}
// Esse código vai dar erro de compilação!

Exemplo certo

Pra variáveis estáticas tudo funciona:

public class Solution
{
    public static int a = 1;          // Definindo a = 1
    public static int b = a + 2;      // b = 1 + 2 ⇒ 3
    public static int c = a + b + 3;  // c = 1 + 3 + 3 ⇒ 7

    public Solution()
    {
        Console.WriteLine($"a = {a}, b = {b}, c = {c}");
        // Vai mostrar: a = 1, b = 3, c = 7 — exatamente o esperado
    }
}

Exemplo certo 2

Pra campos estáticos tu pode até fazer assim:

public class Solution
{
    public static int a = b + c + 1;    // b e c ainda são 0
    public static int b = a + c + 2;    // a == 1, c ainda é 0
    public static int c = a + b + 3;    // a == 1, b == 3
}

2

Tarefa

C# SELF, nível 12, lição 0

Bloqueado

Criação de classe e objeto

Criação de classe e objeto

Abrir

2

Tarefa

C# SELF, nível 12, lição 0

Bloqueado

Inicialização de variáveis e múltiplos construtores

Inicialização de variáveis e múltiplos construtores

Abrir