Aprenda a criar classes em C#

A programação orientada a objetos é um dos paradigmas de programação mais populares. Isso ocorre porque ele modela dados e funções e permite que você pense em termos de objetos do mundo real. As classes são um aspecto fundamental da programação orientada a objetos, pois fornecem o modelo necessário para criar objetos.

C# é uma linguagem de programação multiparadigma popular, que usa o paradigma orientado a objetos. Neste artigo, você aprenderá como criar e usar classes em C#.

Criando uma declaração de classe

Em C#, uma classe é um tipo de referência, que conterá o nulo value até que você crie um novo objeto da classe. Para criar uma nova classe em C# você precisará de vários componentes:

• Um modificador de acesso.
• o classe palavra-chave.
• O nome que você deseja atribuir à classe.
• Um par de chaves abertas e fechadas (que incluirão os atributos, construtores e métodos da classe).

internal class Customer{ }

O código acima cria uma nova classe que pode ser acessada por outras classes no mesmo assembly (arquivo de compilação). C# tem exatamente seis modificadores de acesso que você pode usar para controlar os níveis de acessibilidade de suas classes, variáveis ​​e métodos. Os seis modificadores de acesso são:

• público: cada classe (independentemente de seu assembly) pode acessar a classe pública e seus membros públicos (atributos, construtores e métodos).
• privado: somente a classe privada e seus membros podem acessá-la.
• protegido: somente classes derivadas (classes filhas e netos) podem acessar a classe protegida.
• interno: somente classes no mesmo assembly podem acessar a classe interna.
• interno protegido: somente classes no mesmo assembly ou uma classe derivada de outro assembly podem acessar a classe interna protegida.
• privado protegido: somente classes derivadas no mesmo assembly podem acessar a classe protegida privada.

Declarando e Acessando Atributos

Os atributos são os blocos de construção para as classes que você cria. Eles contêm dados confidenciais e geralmente têm um modificador de acesso privado ou protegido. Portanto, para acessar essas classes de classes externas, você precisaria usar acessadores e mutadores (getters e setters).

C# permite que você declare seus atributos, mutadores e acessadores da seguinte forma:

internal class Customer
{
private int IdNumber;
private string Name;
private double Total;

public void SetIdNumber(int IdNumber) { this.IdNumber = IdNumber; }
public void SetName(string Name) { this.Name = Name; }
public void SetTotal(double Total) { this.Total = Total; }

public int GetIdNumber() { return this.IdNumber; }
public string GetName() { return this.Name; }
public double GetTotal() { return this.Total; }
}

Outras linguagens orientadas a objetos populares também usam a abordagem acima. Na verdade, se você quiser criar classes Java, terá que usar a estrutura acima. No entanto, o C# agora tem uma maneira mais fácil de criar atributos e acessadores. Em C#, esta classe tem a mesma função que a acima:

internal class Customer
{
public int IdNumber { get; set; }
public string Name { get; set; }
public double Total { get; set; }
}

A classe acima contém o que C# chama propriedades, que é uma combinação de atributos (campos) e métodos. Com propriedadesvocê pode reduzir sua declaração de atributo, mutadores e código de acesso pela metade.

Declarando Construtores

Construtores são outro aspecto fundamental de uma classe. Para criar um objeto de uma classe você terá que chamar um de seus construtores. Cada construtor tem um modificador de acesso opcional e o mesmo nome de sua classe. Para linguagens de programação orientadas a objetos, geralmente existem três tipos de construtores:

• Construtor padrão: não recebe argumentos e fornece a cada atributo um valor padrão.
• Construtor primário: recebe um ou mais argumentos (dependendo do número de variáveis ​​na classe).
• Copiar construtor: recebe outro construtor como argumento.

C# tem um termo abrangente para os construtores padrão e primários acima — construtores de instância. Essa linguagem de programação também possui dois outros construtores (privado e estático). Este artigo se concentra nos três construtores tradicionais.

Construtor padrão

public Customer()
{
IdNumber = 0;
Name = "unknown";
Total = 0;
}

Construtor primário

public Customer(int IdNumber, string Name, string CustomerType, double Total)
{
this.IdNumber = IdNumber;
this.Name = Name;
this.Total = Total;
}

Copiar Construtor

public Customer(Customer previousCustomer)
{
this.IdNumber = previousCustomer.IdNumber;
this.Name = previousCustomer.Name;
this.Total = previousCustomer.Total;
}

Criando métodos

Os métodos não são um componente de classe crucial, mas são úteis. Uma classe pode ter um ou mais métodos. Um método tem um modificador de acesso, um tipo de retorno, um nome e um corpo.

public string CustomerDetail()
{
return " ID: " + IdNumber + " Name: " + Name + " Total: " + Total;
}

O código acima retorna uma representação em string do objeto cliente.

Criando objetos

Depois de criar uma classe completa, equipando-a com atributos, construtores e um método, você pode começar a criar objetos usando os diferentes construtores. Para criar um objeto sem atributos, você pode usar o construtor padrão:

Customer John = new Customer();

A linha de código acima cria um cliente padrão e o atribui a uma variável chamada John. Com Johnvocê pode acessar o valor padrão de cada atributo de cliente.

Console.WriteLine(John.Name);

A execução do código acima imprime o seguinte no console:

Unknown

Você também pode usar o John variável para acessar qualquer método na classe cliente.

Console.WriteLine(John.CustomerDetail());

A execução da linha de código acima imprime a seguinte saída no console:

ID: 0 Name: unknown Total: 0

Para criar um objeto com atributos, você usaria o construtor primário:

Customer John = new Customer(1001, "John Doe", 250.20);
Console.WriteLine(John.CustomerDetail());

A execução do código acima imprime a seguinte saída no console:

ID: 1001 Name: John Doe Total: 250.2

Para criar uma cópia do objeto acima, você pode usar o construtor de cópia:

Customer Johnny = new Customer(John);
Console.WriteLine(Johnny.CustomerDetail());

A execução do código acima imprime a seguinte saída no console:

ID: 1001 Name: John Doe Total: 250.2

Como você pode ver, o construtor de cópia é uma cópia do construtor primário. O construtor de cópia também pode receber um construtor padrão como argumento:

Customer John = new Customer();
Customer Johnny = new Customer(John);
Console.WriteLine(Johnny.CustomerDetail());

A execução do código acima imprime a seguinte saída no console:

ID: 0 Name: unknown Total: 0

Agora você pode criar e usar classes C#

Você pode usar o paradigma orientado a objetos em C# para definir classes e criar objetos a partir delas. Você pode criar métodos para cada classe que podem operar nos atributos de seus objetos.

No entanto, o paradigma orientado a objetos não é o único com o qual você precisa estar familiarizado. Os três principais paradigmas de programação são imperativos, orientados a objetos e funcionais.