C # - Classes

Ao definir uma classe, você define um blueprint para um tipo de dados. Isso não define realmente nenhum dado, mas define o que o nome da classe significa. Ou seja, em que consiste um objeto da classe e quais operações podem ser executadas nesse objeto. Objetos são instâncias de uma classe. Os métodos e variáveis ​​que constituem uma classe são chamados de membros da classe.

Definindo uma Classe

Uma definição de classe começa com a palavra-chave class seguida pelo nome da classe; e o corpo da classe cercado por um par de chaves. A seguir está a forma geral de uma definição de classe -

<access specifier> class  class_name {
   // member variables
   <access specifier> <data type> variable1;
   <access specifier> <data type> variable2;
   ...
   <access specifier> <data type> variableN;
   // member methods
   <access specifier> <return type> method1(parameter_list) {
      // method body
   }
   <access specifier> <return type> method2(parameter_list) {
      // method body
   }
   ...
   <access specifier> <return type> methodN(parameter_list) {
      // method body
   }
}

Nota -

  • Os especificadores de acesso especificam as regras de acesso para os membros, bem como a própria classe. Se não for mencionado, o especificador de acesso padrão para um tipo de classe éinternal. O acesso padrão para os membros éprivate.

  • O tipo de dados especifica o tipo de variável e o tipo de retorno especifica o tipo de dados dos dados que o método retorna, se houver.

  • Para acessar os membros da classe, você usa o operador ponto (.).

  • O operador ponto vincula o nome de um objeto ao nome de um membro.

O exemplo a seguir ilustra os conceitos discutidos até agora -

using System;

namespace BoxApplication {
   class Box {
      public double length;   // Length of a box
      public double breadth;  // Breadth of a box
      public double height;   // Height of a box
   }
   class Boxtester {
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();   // Declare Box2 of type Box
         double volume = 0.0;    // Store the volume of a box here

         // box 1 specification
         Box1.height = 5.0;
         Box1.length = 6.0;
         Box1.breadth = 7.0;

         // box 2 specification
         Box2.height = 10.0;
         Box2.length = 12.0;
         Box2.breadth = 13.0;
           
         // volume of box 1
         volume = Box1.height * Box1.length * Box1.breadth;
         Console.WriteLine("Volume of Box1 : {0}",  volume);

         // volume of box 2
         volume = Box2.height * Box2.length * Box2.breadth;
         Console.WriteLine("Volume of Box2 : {0}", volume);
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Volume of Box1 : 210
Volume of Box2 : 1560

Funções de membro e encapsulamento

Uma função de membro de uma classe é uma função que tem sua definição ou seu protótipo dentro da definição de classe semelhante a qualquer outra variável. Ele opera em qualquer objeto da classe da qual é membro e tem acesso a todos os membros de uma classe para esse objeto.

Variáveis ​​de membro são os atributos de um objeto (da perspectiva do design) e são mantidas privadas para implementar o encapsulamento. Essas variáveis ​​só podem ser acessadas usando as funções de membro públicas.

Vamos colocar os conceitos acima para definir e obter o valor dos diferentes membros da classe em uma classe -

using System;

namespace BoxApplication {
   class Box {
      private double length;   // Length of a box
      private double breadth;  // Breadth of a box
      private double height;   // Height of a box
      
      public void setLength( double len ) {
         length = len;
      }
      public void setBreadth( double bre ) {
         breadth = bre;
      }
      public void setHeight( double hei ) {
         height = hei;
      }
      public double getVolume() {
         return length * breadth * height;
      }
   }
   class Boxtester {
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();
         double volume;
         
         // Declare Box2 of type Box
         // box 1 specification
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);
         
         // box 2 specification
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);
         
         // volume of box 1
         volume = Box1.getVolume();
         Console.WriteLine("Volume of Box1 : {0}" ,volume);
         
         // volume of box 2
         volume = Box2.getVolume();
         Console.WriteLine("Volume of Box2 : {0}", volume);
         
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Volume of Box1 : 210
Volume of Box2 : 1560

Construtores C #

Uma aula constructor é uma função-membro especial de uma classe que é executada sempre que criamos novos objetos dessa classe.

Um construtor tem exatamente o mesmo nome que o da classe e não possui nenhum tipo de retorno. O exemplo a seguir explica o conceito de construtor -

using System;

namespace LineApplication {
   class Line {
      private double length;   // Length of a line
      
      public Line() {
         Console.WriteLine("Object is being created");
      }
      public void setLength( double len ) {
         length = len;
      }
      public double getLength() {
         return length;
      }

      static void Main(string[] args) {
         Line line = new Line();    
         
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Object is being created
Length of line : 6

UMA default constructornão tem nenhum parâmetro, mas se você precisar, um construtor pode ter parâmetros. Esses construtores são chamadosparameterized constructors. Esta técnica ajuda você a atribuir um valor inicial a um objeto no momento de sua criação, conforme mostrado no exemplo a seguir -

using System;

namespace LineApplication {
   class Line {
      private double length;   // Length of a line
      
      public Line(double len) {  //Parameterized constructor
         Console.WriteLine("Object is being created, length = {0}", len);
         length = len;
      }
      public void setLength( double len ) {
         length = len;
      }
      public double getLength() {
         return length;
      }
      static void Main(string[] args) {
         Line line = new Line(10.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Object is being created, length = 10
Length of line : 10
Length of line : 6

Destruidores C #

UMA destructoré uma função de membro especial de uma classe que é executada sempre que um objeto de sua classe sai do escopo. UMAdestructor tem exatamente o mesmo nome que o da classe com um til prefixado (~) e não pode retornar um valor nem aceitar parâmetros.

O destruidor pode ser muito útil para liberar recursos de memória antes de sair do programa. Os destruidores não podem ser herdados ou sobrecarregados.

O exemplo a seguir explica o conceito de destruidor -

using System;

namespace LineApplication {
   class Line {
      private double length;   // Length of a line
      
      public Line() {   // constructor
         Console.WriteLine("Object is being created");
      }
      ~Line() {   //destructor
         Console.WriteLine("Object is being deleted");
      }
      public void setLength( double len ) {
         length = len;
      }
      public double getLength() {
         return length;
      }
      static void Main(string[] args) {
         Line line = new Line();

         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());           
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Object is being created
Length of line : 6
Object is being deleted

Membros estáticos de uma classe C #

Podemos definir os membros da classe como estáticos usando o staticpalavra-chave. Quando declaramos um membro de uma classe como estático, isso significa que não importa quantos objetos da classe sejam criados, há apenas uma cópia do membro estático.

A palavra-chave staticimplica que apenas uma instância do membro existe para uma classe. Variáveis ​​estáticas são usadas para definir constantes porque seus valores podem ser recuperados invocando a classe sem criar uma instância dela. Variáveis ​​estáticas podem ser inicializadas fora da função de membro ou definição de classe. Você também pode inicializar variáveis ​​estáticas dentro da definição de classe.

O exemplo a seguir demonstra o uso de static variables -

using System;

namespace StaticVarApplication {
   class StaticVar {
      public static int num;
      
      public void count() {
         num++;
      }
      public int getNum() {
         return num;
      }
   }
   class StaticTester {
      static void Main(string[] args) {
         StaticVar s1 = new StaticVar();
         StaticVar s2 = new StaticVar();
         
         s1.count();
         s1.count();
         s1.count();
         
         s2.count();
         s2.count();
         s2.count();
         
         Console.WriteLine("Variable num for s1: {0}", s1.getNum());
         Console.WriteLine("Variable num for s2: {0}", s2.getNum());
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Variable num for s1: 6
Variable num for s2: 6

Você também pode declarar um member function Como static. Essas funções podem acessar apenas variáveis ​​estáticas. As funções estáticas existem antes mesmo de o objeto ser criado. O exemplo a seguir demonstra o uso destatic functions -

using System;

namespace StaticVarApplication {
   class StaticVar {
      public static int num;
      
      public void count() {
         num++;
      }
      public static int getNum() {
         return num;
      }
   }
   class StaticTester {
      static void Main(string[] args) {
         StaticVar s = new StaticVar();
         
         s.count();
         s.count();
         s.count();
         
         Console.WriteLine("Variable num: {0}", StaticVar.getNum());
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Variable num: 3