Introducción a la programación orientada a objetos

La programación orientada a objetos (POO) representa un cambio fundamental en la forma de pensar y estructurar el código. Mientras que hasta ahora hemos trabajado principalmente con programación procedural, donde el código se organiza en funciones que operan sobre datos, la POO nos permite modelar problemas del mundo real de manera más natural y intuitiva. Este paradigma se basa en la idea de crear "objetos" que combinan datos y comportamientos relacionados en una sola entidad.

C# es un lenguaje diseñado desde sus fundamentos para la programación orientada a objetos, y dominar este paradigma es esencial para aprovechar todo su potencial. La POO no solo nos permite escribir código más organizado y reutilizable, sino que también facilita el mantenimiento y la escalabilidad de nuestras aplicaciones. Los conceptos que aprenderemos aquí forman la base de prácticamente todo el desarrollo moderno en C# y .NET.

¿Qué es la programación orientada a objetos?

La programación orientada a objetos es un paradigma de programación que utiliza "objetos" para diseñar aplicaciones y programas. Un objeto es una entidad que combina datos (atributos o propiedades) y funcionalidades (métodos) relacionadas en una sola unidad. Este enfoque nos permite modelar elementos del mundo real de manera más directa y comprensible.

Diferencias entre programación procedural y orientada a objetos

Aspecto	Programación Procedural	Programación Orientada a Objetos
Enfoque	Funciones que operan sobre datos	Objetos que encapsulan datos y comportamiento
Organización	Código dividido en funciones	Código organizado en clases y objetos
Datos	Variables globales o parámetros	Propiedades dentro de objetos
Reutilización	Llamadas a funciones	Herencia y polimorfismo
Mantenimiento	Modificaciones pueden afectar múltiples funciones	Cambios encapsulados dentro de clases

// Ejemplo comparativo: Gestión de una cuenta bancaria

// === ENFOQUE PROCEDURAL ===
// Variables globales
static decimal saldoCuenta = 1000m;
static string numeroCuenta = "12345";
static string titular = "Juan Pérez";

static void MostrarSaldo()
{
    Console.WriteLine($"Saldo de {titular}: {saldoCuenta:C}");
}

static bool Retirar(decimal cantidad)
{
    if (cantidad > saldoCuenta)
    {
        Console.WriteLine("Fondos insuficientes");
        return false;
    }
    
    saldoCuenta -= cantidad;
    Console.WriteLine($"Retirado: {cantidad:C}. Saldo actual: {saldoCuenta:C}");
    return true;
}

// === ENFOQUE ORIENTADO A OBJETOS ===
// (Veremos la implementación completa más adelante)
// Los datos y métodos están encapsulados en una clase CuentaBancaria

Los cuatro pilares fundamentales de la POO

La programación orientada a objetos se sustenta sobre cuatro principios fundamentales que definen su filosofía y funcionamiento.

1. Encapsulación

La encapsulación consiste en agrupar datos y métodos relacionados dentro de una sola unidad (clase) y controlar el acceso a los datos internos. Esto significa que los detalles internos de implementación están ocultos y solo se expone una interfaz pública controlada.

Beneficios de la encapsulación:

• Protección de datos: Los datos internos no pueden ser modificados directamente desde el exterior
• Control de acceso: Se puede validar y controlar cómo se accede a los datos
• Facilita el mantenimiento: Los cambios internos no afectan al código externo
• Mayor seguridad: Reduce la posibilidad de errores por modificaciones inadecuadas

2. Herencia

La herencia permite crear nuevas clases basadas en clases existentes, heredando sus propiedades y métodos. Esto facilita la reutilización de código y establece relaciones jerárquicas entre clases.

Características de la herencia:

• Reutilización de código: Las clases derivadas heredan funcionalidad de la clase base
• Especialización: Las clases derivadas pueden añadir comportamiento específico
• Jerarquías: Se establecen relaciones "es-un" entre clases
• Extensibilidad: Permite añadir nuevas funcionalidades sin modificar código existente

3. Polimorfismo

El polimorfismo permite que objetos de diferentes tipos respondan al mismo mensaje o llamada de método de manera diferente. Esto significa que un mismo método puede comportarse de forma distinta según el objeto que lo ejecute.

Tipos de polimorfismo:

• Polimorfismo de sobrecarga: Múltiples métodos con el mismo nombre pero diferentes parámetros
• Polimorfismo de herencia: Métodos en clases derivadas que redefinen comportamiento de la clase base
• Polimorfismo de interfaz: Diferentes clases implementan la misma interfaz de manera distinta

4. Abstracción

La abstracción consiste en identificar las características esenciales de un objeto y ocultar los detalles innecesarios. Permite crear modelos simplificados de la realidad que incluyen solo los aspectos relevantes para nuestro problema específico.

Niveles de abstracción:

• Abstracción de datos: Definir qué información es importante
• Abstracción de procesos: Definir qué operaciones son necesarias
• Abstracción de implementación: Ocultar cómo se realizan las operaciones internamente

Conceptos fundamentales: Clases y objetos

¿Qué es una clase?

Una clase es una plantilla o molde que define la estructura y comportamiento que tendrán los objetos creados a partir de ella. Es como un plano arquitectónico que especifica cómo será construida una casa, pero no es la casa en sí misma.

// Definición de una clase simple
public class Vehiculo
{
    // Propiedades (datos del objeto)
    public string Marca { get; set; }
    public string Modelo { get; set; }
    public int Año { get; set; }
    public decimal Kilometraje { get; set; }
    
    // Métodos (comportamientos del objeto)
    public void Arrancar()
    {
        Console.WriteLine($"El {Marca} {Modelo} está arrancando...");
    }
    
    public void Acelerar(int velocidad)
    {
        Console.WriteLine($"Acelerando a {velocidad} km/h");
    }
    
    public void MostrarInformacion()
    {
        Console.WriteLine($"Vehículo: {Marca} {Modelo} ({Año})");
        Console.WriteLine($"Kilometraje: {Kilometraje:N0} km");
    }
}

¿Qué es un objeto?

Un objeto es una instancia específica de una clase. Es la representación concreta que existe en memoria y con la que podemos interactuar durante la ejecución del programa.

// Creación y uso de objetos
class Program
{
    static void Main()
    {
        // Crear objetos (instancias de la clase Vehiculo)
        Vehiculo miCoche = new Vehiculo();
        Vehiculo tuMoto = new Vehiculo();
        
        // Asignar valores a las propiedades
        miCoche.Marca = "Toyota";
        miCoche.Modelo = "Corolla";
        miCoche.Año = 2022;
        miCoche.Kilometraje = 15000;
        
        tuMoto.Marca = "Honda";
        tuMoto.Modelo = "CBR600";
        tuMoto.Año = 2021;
        tuMoto.Kilometraje = 8500;
        
        // Usar los métodos de los objetos
        Console.WriteLine("=== Mi Coche ===");
        miCoche.MostrarInformacion();
        miCoche.Arrancar();
        miCoche.Acelerar(60);
        
        Console.WriteLine("\n=== Tu Moto ===");
        tuMoto.MostrarInformacion();
        tuMoto.Arrancar();
        tuMoto.Acelerar(120);
    }
}

Ejemplo práctico: Sistema de biblioteca

Para ilustrar los conceptos de POO de manera práctica, desarrollemos un sistema simple para gestionar libros en una biblioteca.

public class Libro
{
    // Propiedades del libro
    public string Titulo { get; set; }
    public string Autor { get; set; }
    public string ISBN { get; set; }
    public int AñoPublicacion { get; set; }
    public int NumeroPaginas { get; set; }
    public bool EstaPrestado { get; private set; }
    public DateTime? FechaPrestamo { get; private set; }
    
    // Método para prestar el libro
    public bool Prestar()
    {
        if (EstaPrestado)
        {
            Console.WriteLine($"El libro '{Titulo}' ya está prestado.");
            return false;
        }
        
        EstaPrestado = true;
        FechaPrestamo = DateTime.Now;
        Console.WriteLine($"Libro '{Titulo}' prestado exitosamente.");
        return true;
    }
    
    // Método para devolver el libro
    public bool Devolver()
    {
        if (!EstaPrestado)
        {
            Console.WriteLine($"El libro '{Titulo}' no estaba prestado.");
            return false;
        }
        
        EstaPrestado = false;
        TimeSpan tiempoPrestado = DateTime.Now - FechaPrestamo.Value;
        FechaPrestamo = null;
        
        Console.WriteLine($"Libro '{Titulo}' devuelto después de {tiempoPrestado.Days} días.");
        return true;
    }
    
    // Método para mostrar información del libro
    public void MostrarInformacion()
    {
        Console.WriteLine($"Título: {Titulo}");
        Console.WriteLine($"Autor: {Autor}");
        Console.WriteLine($"ISBN: {ISBN}");
        Console.WriteLine($"Año: {AñoPublicacion}");
        Console.WriteLine($"Páginas: {NumeroPaginas}");
        Console.WriteLine($"Estado: {(EstaPrestado ? "Prestado" : "Disponible")}");
        
        if (EstaPrestado && FechaPrestamo.HasValue)
        {
            int diasPrestado = (DateTime.Now - FechaPrestamo.Value).Days;
            Console.WriteLine($"Prestado hace: {diasPrestado} días");
        }
    }
    
    // Método para calcular la antigüedad del libro
    public int CalcularAntiguedad()
    {
        return DateTime.Now.Year - AñoPublicacion;
    }
    
    // Método para determinar si es un libro clásico
    public bool EsClasico()
    {
        return CalcularAntiguedad() > 50;
    }
}

Uso del sistema de biblioteca

class Program
{
    static void Main()
    {
        // Crear una colección de libros
        List<Libro> biblioteca = new List<Libro>();
        
        // Crear libros
        Libro libro1 = new Libro
        {
            Titulo = "El Quijote",
            Autor = "Miguel de Cervantes",
            ISBN = "978-84-376-0494-7",
            AñoPublicacion = 1605,
            NumeroPaginas = 1200
        };
        
        Libro libro2 = new Libro
        {
            Titulo = "Cien años de soledad",
            Autor = "Gabriel García Márquez",
            ISBN = "978-84-376-0495-8",
            AñoPublicacion = 1967,
            NumeroPaginas = 471
        };
        
        Libro libro3 = new Libro
        {
            Titulo = "Clean Code",
            Autor = "Robert C. Martin",
            ISBN = "978-0-13-235088-4",
            AñoPublicacion = 2008,
            NumeroPaginas = 464
        };
        
        // Añadir libros a la biblioteca
        biblioteca.Add(libro1);
        biblioteca.Add(libro2);
        biblioteca.Add(libro3);
        
        // Operaciones con los libros
        Console.WriteLine("=== BIBLIOTECA DIGITAL ===\n");
        
        foreach (Libro libro in biblioteca)
        {
            Console.WriteLine($"--- {libro.Titulo} ---");
            libro.MostrarInformacion();
            Console.WriteLine($"Antigüedad: {libro.CalcularAntiguedad()} años");
            Console.WriteLine($"¿Es clásico?: {(libro.EsClasico() ? "Sí" : "No")}");
            Console.WriteLine();
        }
        
        // Simular préstamos
        Console.WriteLine("=== OPERACIONES DE PRÉSTAMO ===");
        libro1.Prestar();
        libro2.Prestar();
        libro2.Prestar(); // Intento de préstamo duplicado
        
        Console.WriteLine("\n--- Estado después de préstamos ---");
        libro1.MostrarInformacion();
        Console.WriteLine();
        libro2.MostrarInformacion();
        
        // Simular devolución
        Console.WriteLine("\n=== DEVOLUCIÓN ===");
        libro1.Devolver();
    }
}

Beneficios de la programación orientada a objetos

Ventajas principales

Beneficio	Descripción	Ejemplo práctico
Modularidad	El código se organiza en módulos independientes	Cada clase maneja su propia responsabilidad
Reutilización	Las clases pueden usarse en múltiples contextos	Una clase Vehiculo sirve para coches, motos, etc.
Mantenibilidad	Es más fácil localizar y corregir errores	Los errores de préstamo solo afectan a la clase Libro
Escalabilidad	Fácil añadir nueva funcionalidad	Crear nuevos tipos de libros heredando de Libro
Abstracción	Se ocultan detalles de implementación	El usuario no necesita saber cómo se calcula la antigüedad

Comparación con el enfoque procedural

// Enfoque procedural para gestionar libros
static string[] titulos = new string[100];
static string[] autores = new string[100];
static bool[] prestados = new bool[100];
static int contadorLibros = 0;

static void AgregarLibro(string titulo, string autor)
{
    if (contadorLibros < 100)
    {
        titulos[contadorLibros] = titulo;
        autores[contadorLibros] = autor;
        prestados[contadorLibros] = false;
        contadorLibros++;
    }
}

static bool PrestarLibro(int indice)
{
    if (indice < contadorLibros && !prestados[indice])
    {
        prestados[indice] = true;
        return true;
    }
    return false;
}

// Problemas del enfoque procedural:
// 1. Datos dispersos en múltiples arrays
// 2. Difícil mantener consistencia
// 3. Funciones no relacionadas conceptualmente
// 4. Límites artificiales (100 libros máximo)
// 5. Difícil extensión para nuevas propiedades

Cuándo usar programación orientada a objetos

Indicadores para usar POO

La programación orientada a objetos es especialmente útil cuando:

• Modelamos entidades del mundo real: Personas, productos, vehículos, cuentas bancarias
• Necesitamos reutilización de código: Múltiples objetos similares con pequeñas diferencias
• El proyecto es complejo: Múltiples desarrolladores, mantenimiento a largo plazo
• Requerimos extensibilidad: El sistema debe crecer y adaptarse a nuevos requisitos
• Trabajamos con datos relacionados: Información que naturalmente va junta

Casos prácticos donde POO es ideal

// 1. Sistema de gestión de empleados
public class Empleado
{
    public string Nombre { get; set; }
    public decimal Salario { get; set; }
    public DateTime FechaContratacion { get; set; }
    
    public decimal CalcularSalarioAnual() => Salario * 12;
    public int AñosAntiguedad() => DateTime.Now.Year - FechaContratacion.Year;
}

// 2. Juego con personajes
public class Personaje
{
    public string Nombre { get; set; }
    public int Salud { get; set; }
    public int Nivel { get; set; }
    
    public void Atacar(Personaje objetivo) { /* lógica de ataque */ }
    public void Curar(int cantidad) { /* lógica de curación */ }
}

// 3. Sistema de comercio electrónico
public class Producto
{
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
    public int Stock { get; set; }
    
    public bool EstaDisponible() => Stock > 0;
    public decimal CalcularPrecioConIVA() => Precio * 1.21m;
}

Resumen

La programación orientada a objetos representa un paradigma fundamental en el desarrollo de software moderno, especialmente en C#. Hemos explorado sus cuatro pilares fundamentales: encapsulación, herencia, polimorfismo y abstracción, que proporcionan las bases para crear código más organizado, reutilizable y mantenible.

Los conceptos de clases y objetos nos permiten modelar problemas del mundo real de manera intuitiva, agrupando datos y comportamientos relacionados en entidades cohesivas. A través del ejemplo práctico del sistema de biblioteca, hemos visto cómo la POO facilita la gestión de información compleja y proporciona una estructura clara para la funcionalidad de nuestras aplicaciones. En el siguiente artículo, profundizaremos en la implementación práctica de clases y objetos en C#, explorando la sintaxis específica y las mejores prácticas para crear nuestras propias clases.