C# - Clases
Cuando define una clase, define un modelo para un tipo de datos. En realidad, esto no define ningún dato, pero sí 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 clase encerrado por un par de llaves. La siguiente es 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 clase misma. Si no se menciona, el especificador de acceso predeterminado para un tipo de clase es interno . El acceso predeterminado para los miembros es privado .
-
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 punto vincula el nombre de un objeto con el nombre de un miembro.
El siguiente ejemplo ilustra los conceptos discutidos hasta ahora:
Demostración en 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();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Volume of Box1 : 210 Volume of Box2 : 1560
Funciones de miembros 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 privadas para implementar la encapsulación. Solo se puede acceder a estas variables utilizando las funciones de miembros públicos.
Pongamos los conceptos anteriores para establecer y obtener el valor de diferentes miembros de clase en una clase −
Demostración en 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();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Volume of Box1 : 210 Volume of Box2 : 1560
Constructores C#
Un constructor de clase 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 la clase y no tiene ningún tipo de retorno. El siguiente ejemplo explica el concepto de constructor −
Demostración en 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();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Object is being created Length of line : 6
Un constructor predeterminado no tiene ningún parámetro, pero si lo necesita, un constructor puede tener parámetros. Dichos constructores se denominan constructores parametrizados . Esta técnica te ayuda a asignar un valor inicial a un objeto en el momento de su creación, como se muestra en el siguiente ejemplo −
Demostración en 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();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Object is being created, length = 10 Length of line : 10 Length of line : 6
Destructores de C#
Un destructor es una función miembro especial de una clase que se ejecuta cada vez que un objeto de su clase queda fuera del alcance. Un destructor tiene exactamente el mismo nombre que el de la clase con una tilde prefijada (~) y no puede devolver un valor ni puede 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 −
Demostración en 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());
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Object is being created Length of line : 6 Object is being deleted
Miembros estáticos de una clase de C#
Podemos definir miembros de clase como estáticos usando static palabra 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 estática implica 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 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 variables estáticas −
Demostración en 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();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Variable num for s1: 6 Variable num for s2: 6
También puede declarar una función miembro como estático . 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 de funciones estáticas −
Demostración en 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();
}
}
}
Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −
Variable num: 3
Lenguaje C
- Clase y objeto de C#
- Modificadores de acceso de C#
- Palabra clave estática de C#
- Clase y método abstractos de C#
- Clase anidada de C#
- Clases y objetos de C++
- C - Clases de almacenamiento
- Clases de almacenamiento en C++
- Interfaces en C++ (Clases Abstractas)
- C# - Estructura del programa
- C# - Sintaxis básica