Clases en C#: Blueprint para programación orientada a objetos potente

Al definir una clase, define un modelo para un tipo de dato. Esto no define datos reales, pero define lo que significa el nombre de la clase: 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 llaman miembros de la clase.

Definición de 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 entre llaves.

<especificador_acceso> class nombre_clase {
    // variables miembro
    <especificador_acceso> <tipo_dato> variable1;
    <especificador_acceso> <tipo_dato> variable2;
    ...
    // métodos miembro
    <especificador_acceso> <tipo_retorno> método1(lista_parámetros) {
        // cuerpo del método
    }
    ...
}

Notas:

• Los especificadores de acceso especifican las reglas de acceso para los miembros y la clase. Por defecto: clase internal, miembros private.
• El tipo de dato especifica el tipo de variable, y el tipo de retorno el tipo de dato que devuelve el método.
• Para acceder a los miembros de la clase, use el operador punto (.).

Ejemplo: Clase Box

using System;
namespace AplicaciónCaja {
    class Caja {
        public double longitud;
        public double ancho;
        public double altura;
    }
    
    class ProbadorCaja {
        static void Main(string[] args) {
            Caja Caja1 = new Caja();
            Caja Caja2 = new Caja();
            double volumen = 0.0;
            
            // Especificaciones caja 1
            Caja1.altura = 5.0;
            Caja1.longitud = 6.0;
            Caja1.ancho = 7.0;
            
            // Especificaciones caja 2
            Caja2.altura = 10.0;
            Caja2.longitud = 12.0;
            Caja2.ancho = 13.0;
            
            // Volumen caja 1
            volumen = Caja1.altura * Caja1.longitud * Caja1.ancho;
            Console.WriteLine("Volumen de Caja1: {0}", volumen);
            
            // Volumen caja 2
            volumen = Caja2.altura * Caja2.longitud * Caja2.ancho;
            Console.WriteLine("Volumen de Caja2: {0}", volumen);
            Console.ReadKey();
        }
    }
}

Resultado:

Volumen de Caja1: 210
Volumen de Caja2: 1560

Funciones miembro y encapsulamiento

Una función miembro de una clase tiene su definición o prototipo dentro de la definición de la clase. Opera sobre cualquier objeto de la clase y tiene acceso a todos los miembros de la clase para ese objeto.

Las variables miembro son los atributos de un objeto y se mantienen private para implementar encapsulamiento. Solo se pueden acceder usando funciones miembro públicas.

Ejemplo con encapsulamiento (set/get):

using System;
namespace AplicaciónCaja {
    class Caja {
        private double longitud;
        private double ancho;
        private double altura;
        
        public void SetLongitud(double len) { longitud = len; }
        public void SetAncho(double bre) { ancho = bre; }
        public void SetAltura(double hei) { altura = hei; }
        public double GetVolumen() { return longitud * ancho * altura; }
    }
    
    class ProbadorCaja {
        static void Main(string[] args) {
            Caja Caja1 = new Caja();
            Caja Caja2 = new Caja();
            double volumen;
            
            Caja1.SetLongitud(6.0); Caja1.SetAncho(7.0); Caja1.SetAltura(5.0);
            Caja2.SetLongitud(12.0); Caja2.SetAncho(13.0); Caja2.SetAltura(10.0);
            
            volumen = Caja1.GetVolumen();
            Console.WriteLine("Volumen de Caja1: {0}", volumen);
            volumen = Caja2.GetVolumen();
            Console.WriteLine("Volumen de Caja2: {0}", volumen);
            Console.ReadKey();
        }
    }
}

Constructores en C#

Un constructor es una función miembro especial que se ejecuta al crear nuevos objetos de esa clase. Tiene el mismo nombre que la clase y no tiene tipo de retorno.

Ejemplo: Constructor por defecto

using System;
namespace AplicaciónLínea {
    class Línea {
        private double longitud;
        
        public Línea() {
            Console.WriteLine("Objeto está siendo creado");
        }
        
        public void SetLongitud(double len) { longitud = len; }
        public double GetLongitud() { return longitud; }
        
        static void Main(string[] args) {
            Línea línea = new Línea();
            línea.SetLongitud(6.0);
            Console.WriteLine("Longitud de línea: {0}", línea.GetLongitud());
            Console.ReadKey();
        }
    }
}

Resultado:

Objeto está siendo creado
Longitud de línea: 6

Constructor parametrizado

public Línea(double len) {
    Console.WriteLine("Objeto está siendo creado, longitud = {0}", len);
    longitud = len;
}

Destructores en C#

Un destructor se ejecuta cuando un objeto de su clase sale de ámbito. Tiene el mismo nombre que la clase precedido por tilde (~) y no puede devolver valor ni tomar parámetros.

Útiles para liberar recursos de memoria antes de salir del programa. No pueden heredarse ni sobrecargarse.

Ejemplo:

using System;
namespace AplicaciónLínea {
    class Línea {
        private double longitud;
        
        public Línea() { Console.WriteLine("Objeto está siendo creado"); }
        ~Línea() { Console.WriteLine("Objeto está siendo eliminado"); }
        
        public void SetLongitud(double len) { longitud = len; }
        public double GetLongitud() { return longitud; }
        
        static void Main(string[] args) {
            Línea línea = new Línea();
            línea.SetLongitud(6.0);
            Console.WriteLine("Longitud de línea: {0}", línea.GetLongitud());
        }
    }
}

Resultado:

Objeto está siendo creado
Longitud de línea: 6
Objeto está siendo eliminado

Miembros estáticos de una clase C#

Se pueden definir miembros de clase como static usando la palabra clave static. Significa que no importa cuántos objetos se creen, solo existe una copia del miembro estático.

Las variables estáticas se usan para definir constantes porque sus valores pueden recuperarse invocando la clase sin crear una instancia.

Ejemplo: Variables estáticas

using System;
namespace AplicaciónVarEstática {
    class VarEstática {
        public static int num;
        public void Contar() { num++; }
        public int GetNum() { return num; }
    }
    
    class ProbadorEstático {
        static void Main(string[] args) {
            VarEstática s1 = new VarEstática();
            VarEstática s2 = new VarEstática();
            s1.Contar(); s1.Contar(); s1.Contar();
            s2.Contar(); s2.Contar(); s2.Contar();
            Console.WriteLine("Variable num para s1: {0}", s1.GetNum());
            Console.WriteLine("Variable num para s2: {0}", s2.GetNum());
            Console.ReadKey();
        }
    }
}

Resultado:

Variable num para s1: 6
Variable num para s2: 6

Ejemplo: Funciones estáticas

using System;
namespace AplicaciónVarEstática {
    class VarEstática {
        public static int num;
        public void Contar() { num++; }
        public static int GetNum() { return num; }
    }
    
    class ProbadorEstático {
        static void Main(string[] args) {
            VarEstática s = new VarEstática();
            s.Contar(); s.Contar(); s.Contar();
            Console.WriteLine("Variable num: {0}", VarEstática.GetNum());
            Console.ReadKey();
        }
    }
}

Resultado:

Variable num: 3