Menu

Conceitos de C #: construtor, destruidor, classe estática, estrutura e enum

  • Principal
  • Outro
  • Conceitos de C #: construtor, destruidor, classe estática, estrutura e enum

c concepts constructor

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica alguns dos conceitos importantes na programação C #, como construtor, destruidores, classe estática, estruturas e enums:

Em um de nossos tutoriais anteriores sobre Objetos e Classes, aprendemos o que são uma classe e um objeto.

Um objeto é semelhante a um objeto do mundo real e uma classe é uma coleção lógica de tipos semelhantes de objetos. É um dos tipos mais fundamentais presentes no C #. Neste tutorial, vamos nos aprofundar nos outros conceitos C # relacionados.

=> Explore a série completa de treinamento C # aqui

Construtor C # e outros conceitos

Neste tutorial, aprenderemos sobre alguns aspectos importantes das aulas e como podemos usá-los em nossos programas. Tentaremos criar programas C # simples com base nos conceitos que aprendemos em nossos tutoriais anteriores.

O que você aprenderá:

O que é um construtor em C #?

O construtor é um tipo especial de método na linguagem de programação C # que é chamado ou invocado automaticamente quando um objeto de determinada classe é criado.

Sua função principal é inicializar os membros de dados do objeto recém-criado. Uma das características mais distintas do construtor é seu nome. Tem o mesmo nome da classe.

Os construtores são basicamente de dois tipos:

  1. Predefinição
  2. Parametrizado

Construtor padrão C #

Como o nome sugere, o construtor padrão é o construtor básico de uma classe. Ele não tem nenhum argumento e é chamado diretamente no momento da criação do objeto.

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

O resultado do seguinte programa será:

Construtor foi invocado

Explicação

Definimos um construtor “Programa” dentro da classe “Programa”. Agora, quando inicializamos a classe dentro do método principal, o construtor é chamado automaticamente.

Conseqüentemente, qualquer trecho de código que mantivemos dentro do construtor será invocado. Aqui, imprimimos uma mensagem “Construtor foi invocado” dentro das chaves do construtor, então quando inicializamos a classe, o construtor por padrão será inicializado e a mensagem será impressa como saída.

Construtor Parametrizado

Como o nome sugere, os construtores parametrizados são o construtor com os parâmetros. Esses construtores são usados ​​para passar valores diferentes para os objetos.

public class Details { public Details(int a, int b){ int c = a+b; Console.WriteLine('The sum is: '+ c); } } public class Program { public static void Main(string() args) { Details d = new Details(2, 3); } }

O resultado do seguinte programa será:

melhor software de banco de dados grátis para windows

A soma é: 5

Explicação

Em nosso exemplo anterior com o construtor padrão, temos nosso método principal na mesma classe. Neste exemplo, temos o método principal em uma classe diferente.

Temos uma classe chamada “Detalhes” que contém um construtor parametrizado que aceita dois valores inteiros. Dentro do construtor, estamos imprimindo a soma dos inteiros. Temos outra classe chamada “Programa” que contém nosso método principal. Dentro do método principal, inicializamos a classe “Details”.

Conforme explicado anteriormente, quando uma classe é inicializada, seus construtores são chamados automaticamente. Assim, neste caso, nosso método construtor “Detalhes” foi invocado e quando passamos o parâmetro durante a inicialização, ele imprime a saída.

Destruidores em C #

Destrutores são exatamente o oposto de construtores. É um método especial da classe que é chamado quando um objeto de classe sai do escopo. Semelhante a um construtor, um nome de destruidor também é exatamente igual ao do nome da classe, mas com um prefixo de “~” (til).

O destruidor não aceita nenhum parâmetro e não retorna nenhum valor. O destruidor destrói os objetos da classe, portanto, é usado principalmente para liberar memória após a execução do programa. Outra coisa importante a se notar sobre o destrutor é que ele não pode ser sobrecarregado nem herdado.

Exemplo de destruidores:

public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } ~Program(){ Console.WriteLine('Destructor has been invoked'); } public static void Main(string() args) { Program p = new Program(); } }

O resultado do seguinte programa será:

Construtor foi invocado
Destruidor foi invocado

Explicação

Usamos o mesmo exemplo que usamos para aprender construtor. Acabamos de adicionar um destruidor na classe do programa (~ Programa). Quando inicializamos o objeto da classe, o construtor é chamado e o objeto da classe é criado. Isso imprime a frase “Construtor foi invocado” no console.

Quando a execução for concluída e o objeto de classe sair do escopo, o programa se moverá para o destruidor. O destruidor é então invocado, que por sua vez destrói o objeto. Aqui, imprimimos uma mensagem dentro do destruidor, que é impressa no console depois que o destruidor é invocado.

Membros estáticos em classe A

Os membros da classe podem ser declarados estáticos usando a palavra-chave static. Quando um objeto é declarado como estático, independentemente do número de objetos criados, haverá apenas uma cópia do objeto estático.

Ser estático implica que haverá uma única instância do membro para uma determinada classe. Isso significa que o valor da função estática ou variáveis ​​dentro da classe pode ser chamado sem criar um objeto para eles.

Variáveis ​​estáticas são usadas para declarar constantes, pois seus valores podem ser obtidos diretamente chamando a classe em vez de criar uma instância dela.

Exemplo:

public class Details { public static void stat(){ Console.WriteLine('Static method invoked'); } } public class Program { public static void Main(string() args) { Details.stat(); } }

O resultado do seguinte programa será:

Método estático invocado

Explicação

No exemplo acima, criamos uma classe “Detalhes” que contém um método estático “stat”. Temos outra classe “Programa” que contém o método principal. Em nossos tópicos anteriores, vimos como podemos inicializar uma classe para acessar métodos. Mas, como discutimos, os membros estáticos da classe podem ser acessados ​​com a inicialização do objeto de classe.

Assim, no método principal, acabamos de invocar o método usando a classe diretamente, sem criar nenhum objeto. A saída do programa executou o código escrito dentro do método estático. Nesse caso, imprimimos uma mensagem no console.

Classe estática em C #

Uma classe estática é semelhante a uma classe normal em C #. A classe estática pode ter apenas membros estáticos e não pode ser instanciada. Uma classe estática é usada para garantir que a classe não seja instanciada. Uma classe estática é declarada usando a palavra-chave static antes da classe de palavra-chave durante a declaração.

Exemplo:

public static class Details { public static void multiply(int a, int b){ int c = a*b; Console.WriteLine('Multiplication result is: '+c); } } public class Program { public static void Main(string() args) { Details.multiply(2,8); } }

O resultado do seguinte programa será:

O resultado da multiplicação é: 16

Explicação

No exemplo acima, criamos uma classe estática “Detalhes” e dentro da classe estática criamos outro método estático “multiplicar”. Dentro do método, temos alguns trechos de código que queremos executar. Também temos outra classe “Programa” com o método principal.

Dentro do método principal, invocamos o método multiply presente na classe estática. Se você observar nosso método principal, verá que não inicializamos ou criamos um objeto para a classe estática, em vez disso, invocamos diretamente a classe do método principal.

Portanto, quando invocamos diretamente o método multiply usando o nome da classe e fornecendo parâmetros, ele executa o código e imprime a saída.

Estruturas em C #

A entidade de tipo de valor no C # é chamada de estrutura. Ajuda o usuário a armazenar dados relacionados de vários tipos de dados diferentes em uma única variável. Conforme declarado, uma estrutura é uma entidade de tipo de valor que contém campos, métodos, construtores, operadores, eventos, etc. Uma estrutura é declarada usando a palavra-chave “struct”.

Características das estruturas:

  • Pode incluir constantes, métodos, propriedades, índice, operadores, construtores, etc.
  • Ele não pode ter nenhum construtor padrão.
  • Ele pode implementar uma interface, mas não pode herdar com outras estruturas ou classes.
  • As estruturas devem ser inicializadas usando uma nova palavra-chave para uso.

Diferença entre estrutura e classe

Struct e Class podem parecer semelhantes entre si de alguma forma, mas têm várias diferenças.

As diferenças incluem:

  • Uma estrutura é um tipo de valor, enquanto uma classe é um tipo de referência.
  • A nova palavra-chave é necessária para inicializar estruturas.
  • As estruturas podem ter apenas construtor parametrizado e, por outro lado, uma classe pode ter construtores padrão e parametrizados.

Struct: Definição

Uma estrutura pode ser definida usando a palavra-chave struct. Uma estrutura pode definir um novo tipo de dados com vários membros diferentes para o programa.

Uma estrutura pode ser inicializada de maneira semelhante à inicialização de um objeto, ou seja, usando a nova palavra-chave. Como uma estrutura é uma entidade do tipo valor, é mais rápida de operar do que um objeto de classe. Sempre que houver necessidade de armazenar dados, precisamos usar uma estrutura. Por outro lado, se você precisar transferir dados, é aconselhável usar uma classe em vez de uma estrutura.

perguntas da entrevista sobre sabão e descanso

Exemplo:

public struct Cuboid { public int length; public int width; public int height; } public class Program { public static void Main(string() args) { Cuboid cb = new Cuboid(); cb.length = 10; cb.width = 20; cb.height = 30; Console.WriteLine('The volume of cuboid is: {0}', (cb.length*cb.width*cb.height)); } }

O resultado do seguinte programa será:

O volume do cubóide é: 6000

Explicação

No exemplo acima, definimos um cuboide de estrutura dentro do qual armazenamos tipos de dados para comprimento, largura e altura do cubóide. Temos outro programa de classe onde temos nosso método principal.

No método principal, inicializamos a estrutura “Cuboid” usando a nova palavra-chave. Em seguida, usamos o objeto para chamar e atribuir valores aos tipos de dados armazenados na estrutura. Em seguida, realizamos uma operação nas variáveis ​​da estrutura e imprimimos o resultado no console.

Então, se você quiser usar qualquer propriedade, evento ou método, a estrutura deve ser inicializada com a nova palavra-chave ou então irá dar um erro de compilação.

Enums em C #

Enum é um conjunto de constantes inteiras e semelhante a uma estrutura, também é uma entidade de tipo de valor. É usado principalmente para declarar uma lista de inteiros usando a palavra-chave “enum” dentro de um namespace, classe ou mesmo estrutura. Em enum, fornecemos um nome para cada uma das constantes inteiras, para que possamos referenciá-las usando seus respectivos nomes.

Enum pode ter um número fixo de constantes. Ajuda a melhorar a segurança e também pode ser atravessado.

Características do Enum

  • Enum melhora a legibilidade e manutenção do código, fornecendo nomes significativos para as constantes.
  • Enum não pode ser usado com constantes do tipo string.
  • Enum pode incluir constantes como int, long, short, byte, etc.
  • Por padrão, o valor das constantes enum começa com zero

Declarando um enum

A sintaxe para declarar enum é fornecida abaixo.

enum { list of integer constants };

Todas as constantes enum têm valores padrão. O valor começa em 0 e sobe um a um.

Exemplo:

public enum Cuboid{ length, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

O resultado do seguinte programa será:

O comprimento é: 0
A largura é: 1
A altura é: 2

Explicação

Trabalhamos com um exemplo semelhante que aprendemos durante a estrutura. Neste exemplo, criamos um enum denominado Cuboid. Este enum contém três membros, ou seja, comprimento, largura e altura.

Temos outra classe Program dentro da qual temos nosso método principal. Uma conversão explícita foi usada para converter variáveis ​​de tipo enum em tipo inteiro, então armazenamos seus valores em variáveis ​​diferentes dentro do método principal e os imprimimos no console.

Por padrão, o valor do primeiro enum será zero, o segundo terá 1 e assim por diante. Portanto, quando imprimimos os valores recebemos a saída mencionada.

Mudando o valor de Enum

Enum também permite que os usuários alterem o índice inicial padrão dos membros. Depois de alterar o índice inicial da variável, os membros subsequentes terão seus valores atualizados na sequência incremental.

Vamos atribuir um valor ao primeiro membro do enum que definimos em nosso exemplo anterior e ver o que acontece:

public enum Cuboid { length = 10, width, height } public class Program { public static void Main(string() args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }

O resultado do seguinte programa será:

O comprimento é: 10
A largura é: 11
A altura é: 12

Explicação

Quando atribuímos ao primeiro membro do enum um valor, todos os membros subsequentes do enum serão atribuídos com o incremento desse valor. Como definimos, o primeiro valor é 10, o valor subsequente torna-se 11 e o próximo torna-se 12.

O usuário pode atribuir qualquer valor de acordo com sua escolha e todos os membros do enum serão atribuídos automaticamente com o incremento dos valores definidos pelo usuário.

Propriedades em C #

Propriedades em C # são basicamente o membro nomeado de interface, classes e estrutura. Propriedades são uma extensão das variáveis ​​de membro / método de estrutura ou classe. Eles são usados ​​para ler, escrever ou alterar o valor dos campos privados.

As propriedades são acessadas da mesma forma que os campos. Eles têm acessores que podem ser usados ​​para obter, definir e calcular os valores. Também podemos colocar lógica ao definir valores nas propriedades. Também pode ser usado com a classe privada que restringe o acesso de fora, mas ao mesmo tempo, permite ao usuário usar propriedades para obter ou definir valores.

O que são acessores?

Acessores de propriedade constituem as declarações que podem ser usadas para ler, escrever ou calcular uma determinada propriedade. A declaração de propriedade pode conter get, set ou ambos.

Exemplo:

public class Cube { private int side; //Declare a Side property of type integer public int Side{ get{ return side; } set{ side = value; } } } public class Program { public static void Main(string() args) { Cube cb = new Cube(); cb.Side = 5; Console.WriteLine('The volume of cube is :{0}', (cb.Side * cb.Side* cb.Side)); } }

Quando o fragmento de código acima é compilado e executado com sucesso, a seguinte saída é observada.

O volume do cubo é: 125

Explicação

No exemplo acima, temos uma classe “Cube” dentro da qual declaramos uma propriedade “Side” do tipo inteiro. Depois disso, obtemos e definimos a propriedade onde retornamos e fornecemos o valor para o lado da variável.

adicionar um elemento a um array java

Temos outra classe “Programa” com o método principal dentro da qual inicializamos a classe Cube e fornecemos o valor para a propriedade Side, e então imprimimos o resultado calculado no console.

Conclusão

Neste tutorial, aprendemos sobre as funções-membro da classe. Uma função de membro pode operar em qualquer objeto da classe onde está presente. Também aprendemos sobre construtores e destruidores.

Os construtores são inicializados automaticamente no momento da criação do objeto de classe, enquanto os destruidores destroem a classe e são usados ​​principalmente para remover a alocação de memória após a conclusão da execução. Os construtores podem ser de dois tipos, ou seja, padrão e parametrizados.

O destruidor não aceita nenhum parâmetro nem retorna nenhum valor. Tanto o Construtor quanto os Destruidores têm nomes que são exatamente iguais ao nome da classe. Também aprendemos sobre variáveis ​​estáticas e classe estática e como elas podem ser acessadas sem usar nenhuma instância de classe. Ficamos sabendo que uma classe estática só pode ter membros estáticos.

Também discutimos Structs ou estruturas. As Structs são entidades de tipo de valor e precisam ser inicializadas para acesso.

Enum e propriedades de C # também foram discutidas. Enum é um conjunto de constantes inteiras nomeadas. Semelhante à estrutura, também é uma entidade de tipo de valor. O enum terá seus membros e cada membro terá seu próprio valor padrão.

No final, discutimos propriedades, que são uma extensão das variáveis ​​de membro / método de estrutura ou classe. Eles são usados ​​para obter, definir ou alterar o valor dos campos privados.

=> Veja nossa série completa de treinamento C # aqui

Leitura recomendada

^