Construtor C#

Neste tutorial, aprenderemos sobre os construtores C# e seus tipos com a ajuda de exemplos.

Em C#, um construtor é semelhante a um método que é invocado quando um objeto da classe é criado.

No entanto, ao contrário dos métodos, um construtor:

tem o mesmo nome da classe
não tem nenhum tipo de retorno

Criar um construtor C#

Veja como criamos um construtor em C#

class Car {
  
  // constructor
  Car() {
    //code
  }

}

Aqui, Carro() é um construtor. Tem o mesmo nome de sua classe.

Chamar um construtor

Uma vez que criamos um construtor, podemos chamá-lo usando o new palavra-chave. Por exemplo,

new Car();

Em C#, um construtor é chamado quando tentamos criar um objeto de uma classe. Por exemplo,

Car car1 = new Car();

Aqui, estamos chamando o Car() construtor para criar um objeto car1 . Para saber mais sobre objetos, visite C# Class and Objects.

Tipos de construtores

Existem os seguintes tipos de construtores:

Construtor sem parâmetros
Construtor parametrizado
Construtor padrão

1. Construtor sem parâmetros

Quando criamos um construtor sem parâmetros, ele é conhecido como construtor sem parâmetros. Por exemplo,

using System;

namespace Constructor {

  class Car {   

    // parameterless constructor
    Car() {
      Console.WriteLine("Car Constructor");
    }
 
    static void Main(string[] args) {

      // call constructor
      new Car();
      Console.ReadLine();
     
    }
  }
}

Saída

Car Constructor

No exemplo acima, criamos um construtor chamado Car() .

new Car();

Podemos chamar um construtor adicionando um new palavra-chave para o nome do construtor.

2. Construtor parametrizado C#

Em C#, um construtor também pode aceitar parâmetros. É chamado de construtor parametrizado. Por exemplo,

using System;

namespace Constructor {

  class Car {   

    string brand;
    int price;

    // parameterized constructor
    Car(string theBrand, int thePrice) {

      brand = theBrand;
      price = thePrice;
    }
  
    static void Main(string[] args) {

      // call parameterized constructor
      Car car1 = new Car("Bugatti", 50000);

      Console.WriteLine("Brand: " + car1.brand);
      Console.WriteLine("Price: " + car1.price);
      Console.ReadLine();
     
    }
  }
}

Saída

Brand: Bugatti
Price: 50000

No exemplo acima, criamos um construtor chamado Car() . O construtor recebe dois parâmetros:theBrand e oPreço .

Observe a afirmação,

Car car1 = new Car("Bugatti", 50000);

Aqui, estamos passando os dois valores para o construtor.

Os valores passados para o construtor são chamados de argumentos. Devemos passar o mesmo número e tipo de valores como parâmetros.

3. Construtor padrão

Se não tivermos definido um construtor em nossa classe, o C# criará automaticamente um construtor padrão com um código vazio e sem parâmetros. Por exemplo,

using System;

namespace Constructor {

  class Program {  

    int a;

    static void Main(string[] args) {

      // call default constructor
      Program p1 = new Program();

      Console.WriteLine("Default value of a: " + p1.a);
      Console.ReadLine();
     
    }
  }
}

Saída

Default value of a: 0

No exemplo acima, não criamos nenhum construtor no Program classe. No entanto, ao criar um objeto, estamos chamando o construtor.

Program p1 = new Program();

Aqui, o C# cria automaticamente um construtor padrão. O construtor padrão inicializa qualquer variável não inicializada com o valor padrão.

Assim, obtemos 0 como o valor do int variável a .

Observação :No construtor padrão, todos os campos numéricos são inicializados com 0, enquanto string e objeto são inicializados como nulos.

4. Copiar construtor em C#

Usamos um construtor de cópia para criar um objeto copiando dados de outro objeto. Por exemplo,

using System;

namespace Constructor {

  class Car {  
    string brand;

    // constructor
    Car (string theBrand) {
      brand = theBrand;
    }

    // copy constructor
    Car(Car c1) {
      brand = c1.brand;
    }

    static void Main(string[] args) {
      // call constructor
      Car car1 = new Car("Bugatti");

      Console.WriteLine("Brand of car1: " + car1.brand);

      // call the copy constructor
      Car car2 = new Car(car1);
      Console.WriteLine("Brand of car2: " + car2.brand);

      Console.ReadLine();
     
    }
  }
}

Saída

Brand of car1: Bugatti
Brand of car2: Bugatti

No programa acima, usamos um construtor de cópia.

Car(Car c1) {
  brand = c1.brand;
}

Aqui, este construtor aceita um objeto de Car como seu parâmetro. Então, ao criar o car2 objeto, passamos o car1 objeto como um argumento para o construtor de cópia.

Car car2 = new Car(car1);

Dentro do construtor de cópia, atribuímos o valor da marca para carro1 opor-se à marca variável para car2 objeto. Portanto, ambos os objetos têm o mesmo valor da marca .

5. Construtor Privado

Podemos criar um construtor privado usando o private especificador de acesso. Isso é conhecido como um construtor privado em C#.

Uma vez que o construtor é declarado privado, não podemos criar objetos da classe em outras classes.

Exemplo 1:Construtor privado

using System;

namespace Constructor {

  class Car {  
  
   // private constructor
   private Car () {
    Console.WriteLine("Private Constructor");    
    }
  }
    
    class CarDrive {

      static void Main(string[] args) {

      // call private constructor
      Car car1 = new Car();
      Console.ReadLine();
    }
  }
}

No exemplo acima, criamos um construtor privado Car() . Como os membros privados não são acessados fora da classe, quando tentamos criar um objeto de Car

// inside CarDrive class
Car car1 = new Car();

recebemos um erro

error CS0122: 'Car.Car()' is inaccessible due to its protection level

Observação :Se um construtor é privado, não podemos criar objetos da classe. Portanto, todos os campos e métodos da classe devem ser declarados como estáticos, para que possam ser acessados usando o nome da classe.

6. Construtor estático C#

Em C#, também podemos tornar nosso construtor estático. Usamos o static palavra-chave para criar um construtor estático. Por exemplo,

using System;

namespace Constructor {

  class Car {  
  
   // static constructor
   static Car () {
    Console.WriteLine("Static Constructor");    
   }

    // parameterless constructor
    Car() {
     Console.WriteLine("Default Constructor");
   } 

    static void Main(string[] args) {

      // call parameterless constructor
      Car car1 = new Car();

      // call parameterless constructor again
      Car car2 = new Car();

      Console.ReadLine();
    }
  }
}

No exemplo acima, criamos um construtor estático.

static Car () {
  Console.WriteLine("Static Constructor");    
}

Não podemos chamar um construtor estático diretamente. No entanto, quando chamamos um construtor regular, o construtor estático é chamado automaticamente.

Car car1 = new Car();

Aqui, estamos chamando o Car() construtor. Você pode ver que o construtor estático também é chamado junto com o construtor regular.

Saída

Static Constructor
Default Constructor
Default Constructor

O construtor estático é chamado apenas uma vez durante a execução do programa. É por isso que quando chamamos o construtor novamente, apenas o construtor regular é chamado.

Observação :Podemos ter apenas um construtor estático em uma classe. Ele não pode ter nenhum parâmetro ou modificador de acesso.

Sobrecarga do construtor C#

Em C#, podemos criar dois ou mais construtores em uma classe. É conhecido como sobrecarga de construtor. Por exemplo,

using System;

namespace ConstructorOverload {

  class Car {   
    
    // constructor with no parameter
    Car() {
      Console.WriteLine("Car constructor");
    }
     
    // constructor with one parameter
    Car(string brand) {
      Console.WriteLine("Car constructor with one parameter");
      Console.WriteLine("Brand: " + brand);
    }

    static void Main(string[] args) {

      // call constructor with no parameter
      Car car = new Car();

      Console.WriteLine();

      // call constructor with parameter
      Car car2 =  new Car("Bugatti");
     
      Console.ReadLine();
    }
  }
}

Saída

Car constructor

Car constructor with one parameter
Brand: Bugatti

No exemplo acima, sobrecarregamos o Car construtor:

um construtor tem um parâmetro
outro tem dois parâmetros

Com base no número do argumento passado durante a chamada do construtor, o construtor correspondente é chamado.

Aqui,

Objeto carro - chama o construtor com um parâmetro
Objeto car2 - chama o construtor com dois parâmetros

Para saber mais, visite Sobrecarga do Construtor C#.

Escopo da variável C# C# esta palavra-chave

Linguagem C