C# - Aulas
Ao definir uma classe, você define um blueprint para um tipo de dados. Na verdade, isso não define 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 entre 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 é interno . O acesso padrão para os membros é privado .
-
Tipo de dados especifica o tipo de variável e 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 -
Demonstração ao vivo
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 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 aquele objeto.
As 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úblico.
Vamos colocar os conceitos acima para definir e obter o valor de diferentes membros de classe em uma classe −
Demonstração ao vivo
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 classe construtor é uma função membro especial de uma classe que é executada sempre que criamos novos objetos dessa classe.
Um construtor tem exatamente o mesmo nome da classe e não possui nenhum tipo de retorno. O exemplo a seguir explica o conceito de construtor -
Demonstração ao vivo
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
Um construtor padrão não tem nenhum parâmetro, mas se precisar, um construtor pode ter parâmetros. Esses construtores são chamados de construtores parametrizados . Essa técnica ajuda você a atribuir valor inicial a um objeto no momento de sua criação, conforme mostrado no exemplo a seguir -
Demonstração ao vivo
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
Destrutores C#
Um destruidor é uma função membro especial de uma classe que é executada sempre que um objeto de sua classe sai do escopo. Um destruidor tem exatamente o mesmo nome da classe com um til prefixado (~) e não pode retornar um valor nem receber nenhum parâmetro.
Destructor 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 -
Demonstração ao vivo
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 membros de classe como estáticos usando o static palavra-chave. Quando declaramos um membro de uma classe como estático, significa que não importa quantos objetos da classe sejam criados, há apenas uma cópia do membro estático.
A palavra-chave estática implica 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 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 variáveis estáticas −
Demonstração ao vivo
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 uma função membro como estático . Tais 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 de funções estáticas −
Demonstração ao vivo
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
Linguagem C