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 : 1560Funçõ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 : 1560Construtores 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 : 6UMA 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 : 6Destruidores 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 deletedMembros 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: 6Você 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