C # - Clases
Cuando define una clase, define un plano para un tipo de datos. En realidad, esto no define ningún dato, pero define lo que significa el nombre de la clase. Es decir, en qué consiste un objeto de la clase y qué operaciones se pueden realizar sobre ese objeto. Los objetos son instancias de una clase. Los métodos y variables que constituyen una clase se denominan miembros de la clase.
Definiendo una clase
Una definición de clase comienza con la palabra clave class seguida del nombre de la clase; y el cuerpo de la clase encerrado por un par de llaves. A continuación se muestra la forma general de una definición de clase:
<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 -
Los especificadores de acceso especifican las reglas de acceso para los miembros, así como la propia clase. Si no se menciona, el especificador de acceso predeterminado para un tipo de clase esinternal. El acceso predeterminado para los miembros esprivate.
El tipo de datos especifica el tipo de variable y el tipo de retorno especifica el tipo de datos de los datos que devuelve el método, si corresponde.
Para acceder a los miembros de la clase, utilice el operador de punto (.).
El operador de puntos vincula el nombre de un objeto con el nombre de un miembro.
El siguiente ejemplo ilustra los conceptos discutidos hasta ahora:
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();
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Volume of Box1 : 210
Volume of Box2 : 1560Funciones de miembro y encapsulación
Una función miembro de una clase es una función que tiene su definición o su prototipo dentro de la definición de clase similar a cualquier otra variable. Opera sobre cualquier objeto de la clase de la que es miembro y tiene acceso a todos los miembros de una clase para ese objeto.
Las variables miembro son los atributos de un objeto (desde la perspectiva del diseño) y se mantienen privados para implementar la encapsulación. Solo se puede acceder a estas variables mediante las funciones de miembros públicos.
Pongamos los conceptos anteriores para establecer y obtener el valor de diferentes miembros de la clase en una clase:
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();
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Volume of Box1 : 210
Volume of Box2 : 1560Constructores de C #
Una clase constructor es una función miembro especial de una clase que se ejecuta cada vez que creamos nuevos objetos de esa clase.
Un constructor tiene exactamente el mismo nombre que el de clase y no tiene ningún tipo de retorno. El siguiente ejemplo explica el concepto de constructor:
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();
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Object is being created
Length of line : 6UNA default constructorno tiene ningún parámetro, pero si lo necesita, un constructor puede tener parámetros. Tales constructores se llamanparameterized constructors. Esta técnica le ayuda a asignar un valor inicial a un objeto en el momento de su creación, como se muestra en el siguiente ejemplo:
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();
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Object is being created, length = 10
Length of line : 10
Length of line : 6Destructores de C #
UNA destructores una función miembro especial de una clase que se ejecuta siempre que un objeto de su clase sale del alcance. UNAdestructor tiene exactamente el mismo nombre que el de la clase con una tilde prefijada (~) y no puede devolver un valor ni tomar ningún parámetro.
Destructor puede ser muy útil para liberar recursos de memoria antes de salir del programa. Los destructores no se pueden heredar ni sobrecargar.
El siguiente ejemplo explica el concepto de destructor:
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());
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Object is being created
Length of line : 6
Object is being deletedMiembros estáticos de una clase C #
Podemos definir a los miembros de la clase como estáticos usando el staticpalabra clave. Cuando declaramos un miembro de una clase como estático, significa que no importa cuántos objetos de la clase se creen, solo hay una copia del miembro estático.
La palabra clave staticimplica que solo existe una instancia del miembro para una clase. Las variables estáticas se utilizan para definir constantes porque sus valores se pueden recuperar invocando la clase sin crear una instancia de ella. Las variables estáticas se pueden inicializar fuera de la función miembro o la definición de clase. También puede inicializar variables estáticas dentro de la definición de clase.
El siguiente ejemplo demuestra el 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();
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Variable num for s1: 6
Variable num for s2: 6También puede declarar un member function como static. Estas funciones solo pueden acceder a variables estáticas. Las funciones estáticas existen incluso antes de que se cree el objeto. El siguiente ejemplo demuestra el 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();
}
}
}Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:
Variable num: 3