Definición de clases

En C#, una clase es una estructura fundamental que sirve como plantilla para crear objetos. Podemos pensar en una clase como un plano o modelo que define las características y comportamientos que tendrán los objetos creados a partir de ella.

Sintaxis básica

Para definir una clase en C#, utilizamos la palabra clave class seguida del nombre que queremos darle. Por convención, los nombres de las clases en C# comienzan con mayúscula y utilizan la notación PascalCase (cada palabra comienza con mayúscula sin espacios).

class Producto
{
    // Contenido de la clase
}

Una clase puede contener campos (variables) y métodos (funciones) que definen sus propiedades y comportamientos.

Estructura de una clase

Veamos un ejemplo más completo de cómo se estructura una clase:

using System;

class Producto
{
    // Campos (datos)
    public string nombre;
    public decimal precio;
    public int stock;
    
    // Métodos (comportamientos)
    public void MostrarInformacion()
    {
        Console.WriteLine($"Producto: {nombre}");
        Console.WriteLine($"Precio: {precio:C}");
        Console.WriteLine($"Stock disponible: {stock} unidades");
    }
    
    public bool HayStock()
    {
        return stock > 0;
    }
}

En este ejemplo, hemos definido una clase Producto con:

• Tres campos: nombre, precio y stock
• Dos métodos: MostrarInformacion() y HayStock()

Modificadores de acceso

Los modificadores de acceso determinan desde dónde se puede acceder a los miembros de una clase:

• public: El miembro es accesible desde cualquier parte del código.
• private: El miembro solo es accesible dentro de la misma clase.
• protected: El miembro es accesible dentro de la clase y en clases derivadas.
• internal: El miembro es accesible dentro del mismo ensamblado.

class Persona
{
    // Campo privado (solo accesible dentro de la clase)
    private int edad;
    
    // Campo público (accesible desde cualquier parte)
    public string nombre;
    
    // Método público
    public void CumplirAnios()
    {
        edad++;
        Console.WriteLine($"{nombre} ahora tiene {edad} años");
    }
}

Definición de clases en archivos

En C#, generalmente cada clase se define en su propio archivo .cs con el mismo nombre que la clase. Por ejemplo, la clase Producto se definiría en un archivo llamado Producto.cs.

// Archivo: Producto.cs
using System;

namespace TiendaVirtual
{
    class Producto
    {
        public string nombre;
        public decimal precio;
        // Resto de la implementación...
    }
}

Namespaces

Las clases en C# suelen organizarse en namespaces (espacios de nombres), que son contenedores lógicos que ayudan a organizar el código y evitar conflictos de nombres:

namespace TiendaVirtual
{
    class Producto
    {
        // Implementación de la clase
    }
    
    class Categoria
    {
        // Implementación de la clase
    }
}

Para usar una clase definida en otro namespace, utilizamos la directiva using o la referenciamos con su nombre completo:

using TiendaVirtual;

// Ahora podemos usar directamente
Producto miProducto = new Producto();

// O podemos usar el nombre completo sin la directiva using
TiendaVirtual.Producto otroProducto = new TiendaVirtual.Producto();

Clases parciales

C# permite dividir la definición de una clase en varios archivos usando la palabra clave partial:

// Archivo: Producto.cs
partial class Producto
{
    public string nombre;
    public decimal precio;
}

// Archivo: ProductoMetodos.cs
partial class Producto
{
    public void MostrarInformacion()
    {
        Console.WriteLine($"Producto: {nombre}, Precio: {precio:C}");
    }
}

Esto es útil para separar la generación automática de código del código escrito manualmente, o para dividir clases muy grandes.

Clases estáticas

Una clase estática solo puede contener miembros estáticos y no se puede instanciar. Se utiliza para agrupar funcionalidades relacionadas:

static class Matematicas
{
    public static double PI = 3.14159;
    
    public static double CalcularAreaCirculo(double radio)
    {
        return PI * radio * radio;
    }
}

// Uso (sin crear instancias)
double area = Matematicas.CalcularAreaCirculo(5);

Ejemplo práctico completo

Veamos un ejemplo más completo de definición de una clase que podría usarse en una aplicación real:

using System;

namespace GestionBiblioteca
{
    class Libro
    {
        // Campos
        public string titulo;
        public string autor;
        private int numeroPaginas;
        private bool prestado;
        
        // Método para prestar el libro
        public bool Prestar()
        {
            if (prestado)
            {
                Console.WriteLine("El libro ya está prestado");
                return false;
            }
            else
            {
                prestado = true;
                Console.WriteLine($"Libro '{titulo}' prestado con éxito");
                return true;
            }
        }
        
        // Método para devolver el libro
        public void Devolver()
        {
            if (prestado)
            {
                prestado = false;
                Console.WriteLine($"Libro '{titulo}' devuelto con éxito");
            }
            else
            {
                Console.WriteLine("Este libro no estaba prestado");
            }
        }
        
        // Método para mostrar información del libro
        public void MostrarInformacion()
        {
            string estadoPrestamo = prestado ? "Prestado" : "Disponible";
            
            Console.WriteLine($"Título: {titulo}");
            Console.WriteLine($"Autor: {autor}");
            Console.WriteLine($"Páginas: {numeroPaginas}");
            Console.WriteLine($"Estado: {estadoPrestamo}");
        }
    }
}

En este ejemplo, hemos definido una clase Libro con campos para almacenar información sobre libros y métodos que implementan comportamientos como prestar y devolver libros.

La definición de clases es el primer paso para trabajar con programación orientada a objetos en C#. Una vez definida una clase, podemos crear objetos basados en ella, lo que veremos en la siguiente sección.

Creación de objetos

Una vez que hemos definido una clase, el siguiente paso es crear objetos basados en esa clase. Un objeto es una instancia concreta de una clase, que ocupa espacio en memoria y tiene valores específicos para sus campos.

Instanciación básica

Para crear un objeto en C#, utilizamos el operador new seguido del nombre de la clase y paréntesis:

Producto miProducto = new Producto();

Esta instrucción realiza dos acciones importantes:

• Reserva memoria para almacenar el nuevo objeto
• Devuelve una referencia a ese objeto, que guardamos en la variable miProducto

Asignación de valores a los campos

Después de crear un objeto, podemos asignar valores a sus campos públicos utilizando el operador punto (.):

Producto laptop = new Producto();
laptop.nombre = "Laptop HP";
laptop.precio = 899.99m;
laptop.stock = 10;

Ahora nuestro objeto laptop tiene valores específicos para sus campos. La letra m después del número decimal indica que es un literal de tipo decimal.

Llamada a métodos del objeto

De manera similar, podemos invocar los métodos del objeto utilizando el operador punto:

// Creamos un objeto
Producto smartphone = new Producto();
smartphone.nombre = "Smartphone Samsung";
smartphone.precio = 699.99m;
smartphone.stock = 5;

// Llamamos a sus métodos
smartphone.MostrarInformacion();

if (smartphone.HayStock())
{
    Console.WriteLine("El producto está disponible para compra");
}

Múltiples objetos de la misma clase

Podemos crear tantos objetos como necesitemos a partir de una misma clase. Cada objeto tendrá su propio espacio en memoria y sus propios valores:

// Primer objeto
Producto teclado = new Producto();
teclado.nombre = "Teclado mecánico";
teclado.precio = 89.99m;
teclado.stock = 15;

// Segundo objeto (diferente, pero de la misma clase)
Producto mouse = new Producto();
mouse.nombre = "Mouse inalámbrico";
mouse.precio = 29.99m;
mouse.stock = 20;

// Cada objeto tiene sus propios valores
teclado.MostrarInformacion();
mouse.MostrarInformacion();

Objetos como parámetros y valores de retorno

Los objetos pueden pasarse como parámetros a métodos y también pueden ser devueltos por métodos:

class Tienda
{
    public void AgregarAlInventario(Producto producto)
    {
        Console.WriteLine($"Agregando {producto.nombre} al inventario");
        // Lógica para agregar al inventario
    }
    
    public Producto CrearNuevoProducto(string nombre, decimal precio, int cantidad)
    {
        Producto nuevo = new Producto();
        nuevo.nombre = nombre;
        nuevo.precio = precio;
        nuevo.stock = cantidad;
        return nuevo;
    }
}

// Uso:
Tienda miTienda = new Tienda();

// Pasamos un objeto como parámetro
Producto auriculares = new Producto();
auriculares.nombre = "Auriculares Bluetooth";
auriculares.precio = 59.99m;
auriculares.stock = 8;
miTienda.AgregarAlInventario(auriculares);

// Recibimos un objeto como valor de retorno
Producto monitor = miTienda.CrearNuevoProducto("Monitor 24 pulgadas", 199.99m, 5);
monitor.MostrarInformacion();

Referencias a objetos

En C#, las variables de tipo clase no contienen directamente el objeto, sino una referencia (o dirección de memoria) al objeto. Esto tiene importantes implicaciones:

Producto original = new Producto();
original.nombre = "Tablet";
original.precio = 299.99m;

// Esto NO crea un nuevo objeto, solo copia la referencia
Producto copia = original;

// Modificar a través de cualquier referencia afecta al mismo objeto
copia.precio = 249.99m;

// Ambas variables mostrarán el precio actualizado (249.99)
Console.WriteLine(original.precio); // Muestra 249.99
Console.WriteLine(copia.precio);    // Muestra 249.99

Comparación de objetos

Cuando comparamos objetos con el operador ==, estamos comparando las referencias, no el contenido:

Producto a = new Producto();
a.nombre = "Cámara digital";

Producto b = new Producto();
b.nombre = "Cámara digital";

Producto c = a;

Console.WriteLine(a == b); // False (diferentes objetos en memoria)
Console.WriteLine(a == c); // True (misma referencia)

Objetos nulos

Una variable de tipo objeto puede no referenciar a ningún objeto, en cuyo caso tiene el valor null:

Producto disponible = new Producto();
Producto agotado = null; // No referencia a ningún objeto

// Verificar si un objeto es null antes de usarlo
if (agotado != null)
{
    agotado.MostrarInformacion(); // Esto causaría un error si agotado es null
}

// Forma moderna de verificar (C# 6.0+)
disponible?.MostrarInformacion(); // El operador ?. solo ejecuta si no es null
agotado?.MostrarInformacion();    // No hace nada si es null

Ejemplo práctico completo

Veamos un ejemplo completo que muestra la creación y manipulación de objetos:

using System;

class Program
{
    static void Main(string[] args)
    {
        // Creamos varios objetos Libro
        Libro libroFantasia = new Libro();
        libroFantasia.titulo = "El Señor de los Anillos";
        libroFantasia.autor = "J.R.R. Tolkien";
        
        Libro libroTecnico = new Libro();
        libroTecnico.titulo = "Clean Code";
        libroTecnico.autor = "Robert C. Martin";
        
        // Mostramos información de los libros
        Console.WriteLine("=== Catálogo de libros ===");
        libroFantasia.MostrarInformacion();
        Console.WriteLine();
        libroTecnico.MostrarInformacion();
        
        // Prestamos un libro
        Console.WriteLine("\n=== Realizando préstamos ===");
        libroFantasia.Prestar();
        
        // Intentamos prestar el mismo libro otra vez
        libroFantasia.Prestar();
        
        // Devolvemos el libro
        Console.WriteLine("\n=== Devoluciones ===");
        libroFantasia.Devolver();
        
        // Verificamos el estado actualizado
        Console.WriteLine("\n=== Estado actualizado ===");
        libroFantasia.MostrarInformacion();
    }
}

class Libro
{
    // Campos
    public string titulo;
    public string autor;
    private bool prestado = false;
    
    // Método para prestar el libro
    public bool Prestar()
    {
        if (prestado)
        {
            Console.WriteLine($"El libro '{titulo}' ya está prestado");
            return false;
        }
        
        prestado = true;
        Console.WriteLine($"Libro '{titulo}' prestado con éxito");
        return true;
    }
    
    // Método para devolver el libro
    public void Devolver()
    {
        if (prestado)
        {
            prestado = false;
            Console.WriteLine($"Libro '{titulo}' devuelto con éxito");
        }
        else
        {
            Console.WriteLine($"El libro '{titulo}' no estaba prestado");
        }
    }
    
    // Método para mostrar información del libro
    public void MostrarInformacion()
    {
        string estadoPrestamo = prestado ? "Prestado" : "Disponible";
        
        Console.WriteLine($"Título: {titulo}");
        Console.WriteLine($"Autor: {autor}");
        Console.WriteLine($"Estado: {estadoPrestamo}");
    }
}

La salida de este programa sería:

=== Catálogo de libros ===
Título: El Señor de los Anillos
Autor: J.R.R. Tolkien
Estado: Disponible

Título: Clean Code
Autor: Robert C. Martin
Estado: Disponible

=== Realizando préstamos ===
Libro 'El Señor de los Anillos' prestado con éxito
El libro 'El Señor de los Anillos' ya está prestado

=== Devoluciones ===
Libro 'El Señor de los Anillos' devuelto con éxito

=== Estado actualizado ===
Título: El Señor de los Anillos
Autor: J.R.R. Tolkien
Estado: Disponible

Este ejemplo muestra cómo crear objetos, establecer sus propiedades y llamar a sus métodos para manipular su estado. Cada objeto mantiene su propio estado independiente, lo que es una característica fundamental de la programación orientada a objetos.

Campos y métodos

Los campos y métodos son los componentes fundamentales que conforman una clase en C#. Mientras que los campos almacenan datos, los métodos definen el comportamiento que pueden realizar los objetos creados a partir de la clase.

Campos

Los campos son variables que pertenecen a una clase y representan el estado o las características de los objetos. Podemos pensar en ellos como las propiedades o atributos que describen a nuestros objetos.

class Automovil
{
    // Campos
    public string marca;
    public string modelo;
    public int año;
    public double kilometraje;
    private double combustible;
}

Tipos de campos

Los campos pueden ser de cualquier tipo de dato en C#:

• Tipos primitivos: int, double, bool, char, etc.
• Tipos de referencia: string, arrays, u otros objetos
• Tipos personalizados: enumeraciones o estructuras definidas por el usuario

class Empleado
{
    // Campos de diferentes tipos
    public string nombre;
    public int edad;
    public double salario;
    public bool activo;
    public DateTime fechaContratacion;
    public Departamento departamento; // Tipo personalizado
}

Modificadores de acceso para campos

Los campos pueden tener diferentes niveles de visibilidad:

• public: Accesible desde cualquier parte del código
• private: Solo accesible dentro de la misma clase
• protected: Accesible dentro de la clase y sus derivadas
• internal: Accesible dentro del mismo ensamblado

class CuentaBancaria
{
    public string titular;       // Accesible desde cualquier parte
    private double saldo;        // Solo accesible dentro de esta clase
    protected string numeroCuenta; // Accesible en esta clase y sus derivadas
    internal bool activa;        // Accesible dentro del mismo ensamblado
}

Campos constantes y de solo lectura

• Campos constantes: Se definen con la palabra clave const y su valor no puede cambiar.
• Campos de solo lectura: Se definen con la palabra clave readonly y solo pueden asignarse en el constructor o en su declaración.

class Matematicas
{
    // Constante - debe asignarse en la declaración
    public const double PI = 3.14159;
    
    // Solo lectura - puede asignarse en el constructor
    public readonly double FactorConversion;
    
    public Matematicas(double factor)
    {
        FactorConversion = factor; // Válido para readonly
        // PI = 3.14; // Error: no se puede modificar una constante
    }
}

Campos estáticos

Los campos estáticos pertenecen a la clase en lugar de a instancias individuales. Se comparten entre todos los objetos de esa clase.

class Contador
{
    // Campo estático compartido por todos los objetos
    public static int totalInstancias = 0;
    
    // Campo normal (de instancia)
    public string identificador;
    
    public Contador(string id)
    {
        identificador = id;
        totalInstancias++; // Incrementa el contador compartido
    }
}

// Uso:
Contador c1 = new Contador("Primero");
Contador c2 = new Contador("Segundo");
Console.WriteLine(Contador.totalInstancias); // Muestra: 2

Métodos

Los métodos son bloques de código que definen el comportamiento o las acciones que pueden realizar los objetos. Representan las operaciones que un objeto puede ejecutar.

class Calculadora
{
    // Método simple que suma dos números
    public int Sumar(int a, int b)
    {
        return a + b;
    }
}

Estructura de un método

Un método en C# tiene la siguiente estructura:

[modificador_acceso] [modificadores] tipo_retorno NombreMetodo([parámetros])
{
    // Cuerpo del método
    [return valor;]
}

Donde:

• modificador_acceso: public, private, protected, internal
• modificadores: static, virtual, override, abstract, etc.
• tipo_retorno: El tipo de dato que devuelve el método, o void si no devuelve nada
• parámetros: Lista de variables que el método recibe

Métodos con diferentes tipos de retorno

Los métodos pueden devolver cualquier tipo de dato o no devolver nada (void):

class Utilidades
{
    // Método que no devuelve nada (void)
    public void MostrarMensaje(string mensaje)
    {
        Console.WriteLine(mensaje);
    }
    
    // Método que devuelve un entero
    public int ObtenerEdad(DateTime fechaNacimiento)
    {
        return DateTime.Now.Year - fechaNacimiento.Year;
    }
    
    // Método que devuelve un booleano
    public bool EsNumeroValido(int numero)
    {
        return numero >= 0 && numero <= 100;
    }
    
    // Método que devuelve un string
    public string FormatearNombre(string nombre, string apellido)
    {
        return $"{apellido}, {nombre}";
    }
}

Parámetros de métodos

Los métodos pueden recibir diferentes tipos de parámetros:

• Parámetros por valor: El método recibe una copia del valor.
• Parámetros por referencia (ref): El método recibe una referencia a la variable original.
• Parámetros de salida (out): Similar a ref, pero no requiere que la variable esté inicializada.
• Parámetros opcionales: Tienen un valor predeterminado y pueden omitirse al llamar al método.
• Parámetros con nombre: Permiten especificar el nombre del parámetro al llamar al método.

class Operaciones
{
    // Parámetro normal (por valor)
    public void Incrementar(int numero)
    {
        numero++; // Solo afecta a la copia local
    }
    
    // Parámetro por referencia
    public void IncrementarRef(ref int numero)
    {
        numero++; // Modifica la variable original
    }
    
    // Parámetro de salida
    public void ObtenerCoordenadas(double angulo, out double x, out double y)
    {
        x = Math.Cos(angulo);
        y = Math.Sin(angulo);
    }
    
    // Parámetros opcionales
    public double CalcularPrecio(double precioBase, double descuento = 0, double impuesto = 0.21)
    {
        return precioBase * (1 - descuento) * (1 + impuesto);
    }
}

// Uso:
Operaciones op = new Operaciones();

// Parámetro por valor
int a = 5;
op.Incrementar(a);
Console.WriteLine(a); // Sigue siendo 5

// Parámetro por referencia
int b = 5;
op.IncrementarRef(ref b);
Console.WriteLine(b); // Ahora es 6

// Parámetro de salida
double angulo = Math.PI / 4;
double coordX, coordY;
op.ObtenerCoordenadas(angulo, out coordX, out coordY);
Console.WriteLine($"X: {coordX}, Y: {coordY}");

// Parámetros opcionales
double precio1 = op.CalcularPrecio(100); // Usa valores predeterminados
double precio2 = op.CalcularPrecio(100, 0.1); // Especifica descuento
double precio3 = op.CalcularPrecio(100, 0.1, 0.16); // Especifica todos

// Parámetros con nombre
double precio4 = op.CalcularPrecio(precioBase: 100, impuesto: 0.16); // Omite descuento

Sobrecarga de métodos

La sobrecarga permite definir múltiples métodos con el mismo nombre pero diferentes parámetros:

class Calculadora
{
    // Sobrecarga para enteros
    public int Sumar(int a, int b)
    {
        return a + b;
    }
    
    // Sobrecarga para decimales
    public double Sumar(double a, double b)
    {
        return a + b;
    }
    
    // Sobrecarga con tres parámetros
    public int Sumar(int a, int b, int c)
    {
        return a + b + c;
    }
}

// Uso:
Calculadora calc = new Calculadora();
int suma1 = calc.Sumar(5, 3);           // Llama a la primera versión
double suma2 = calc.Sumar(5.5, 3.2);    // Llama a la segunda versión
int suma3 = calc.Sumar(5, 3, 2);        // Llama a la tercera versión

Métodos estáticos

Los métodos estáticos pertenecen a la clase en lugar de a instancias individuales. Se invocan directamente a través de la clase sin necesidad de crear un objeto:

class Convertidor
{
    // Método estático
    public static double CelsiusAFahrenheit(double celsius)
    {
        return celsius * 9 / 5 + 32;
    }
    
    // Método de instancia (no estático)
    public double FahrenheitACelsius(double fahrenheit)
    {
        return (fahrenheit - 32) * 5 / 9;
    }
}

// Uso:
// Método estático - se llama directamente desde la clase
double tempF = Convertidor.CelsiusAFahrenheit(25);

// Método de instancia - requiere crear un objeto
Convertidor conv = new Convertidor();
double tempC = conv.FahrenheitACelsius(77);

Ejemplo práctico: Integrando campos y métodos

Veamos un ejemplo completo que muestra cómo los campos y métodos trabajan juntos en una clase:

class Vehiculo
{
    // Campos
    public string marca;
    public string modelo;
    private double combustible;
    private double consumoPorKm;
    
    // Campo estático
    public static int vehiculosCreados = 0;
    
    // Método constructor
    public Vehiculo(string marca, string modelo, double consumo)
    {
        this.marca = marca;
        this.modelo = modelo;
        this.consumoPorKm = consumo;
        this.combustible = 0;
        
        // Incrementa el contador estático
        vehiculosCreados++;
    }
    
    // Método para cargar combustible
    public void CargarCombustible(double litros)
    {
        if (litros > 0)
        {
            combustible += litros;
            Console.WriteLine($"Se cargaron {litros} litros. Nivel actual: {combustible} litros");
        }
        else
        {
            Console.WriteLine("La cantidad debe ser positiva");
        }
    }
    
    // Método para conducir
    public bool Conducir(double kilometros)
    {
        double combustibleNecesario = kilometros * consumoPorKm;
        
        if (combustibleNecesario <= combustible)
        {
            combustible -= combustibleNecesario;
            Console.WriteLine($"Viaje de {kilometros} km completado. Combustible restante: {combustible:F2} litros");
            return true;
        }
        else
        {
            Console.WriteLine($"Combustible insuficiente para {kilometros} km. Se necesitan {combustibleNecesario:F2} litros");
            return false;
        }
    }
    
    // Método para obtener información del vehículo
    public string ObtenerInformacion()
    {
        return $"Vehículo: {marca} {modelo}\n" +
               $"Consumo: {consumoPorKm:F2} litros/km\n" +
               $"Combustible: {combustible:F2} litros";
    }
    
    // Método estático para obtener estadísticas
    public static string ObtenerEstadisticas()
    {
        return $"Total de vehículos creados: {vehiculosCreados}";
    }
}

Uso de la clase:

// Crear objetos
Vehiculo coche1 = new Vehiculo("Toyota", "Corolla", 0.06);
Vehiculo coche2 = new Vehiculo("Honda", "Civic", 0.055);

// Cargar combustible
coche1.CargarCombustible(40);
coche2.CargarCombustible(35);

// Mostrar información
Console.WriteLine("\nInformación de vehículos:");
Console.WriteLine(coche1.ObtenerInformacion());
Console.WriteLine();
Console.WriteLine(coche2.ObtenerInformacion());

// Conducir
Console.WriteLine("\nRealizando viajes:");
coche1.Conducir(200);
coche1.Conducir(300);
coche2.Conducir(400);

// Mostrar estadísticas (método estático)
Console.WriteLine("\nEstadísticas:");
Console.WriteLine(Vehiculo.ObtenerEstadisticas());

Este ejemplo muestra cómo:

• Los campos almacenan el estado del vehículo (marca, modelo, combustible)
• Los métodos implementan comportamientos (cargar combustible, conducir)
• Los campos y métodos privados protegen datos internos
• Los campos y métodos estáticos mantienen información compartida

La combinación de campos y métodos permite crear clases que no solo almacenan datos, sino que también implementan comportamientos complejos, siguiendo el principio fundamental de la programación orientada a objetos de encapsular datos y comportamiento en una sola unidad.