Programación Orientada a Objetos (POO) en C#
La Programación Orientada a Objetos (POO) es un paradigma que organiza el software en objetos, los cuales combinan datos (atributos) y comportamientos (métodos).
En C#, la POO es uno de los pilares fundamentales para construir aplicaciones modulares, reutilizables y fáciles de mantener.
Introducción a UML
UML (Unified Modeling Language) es un lenguaje de modelado estandarizado que permite visualizar, especificar y documentar sistemas orientados a objetos antes de implementarlos.
Principios básicos de UML
- Diagramas de clases: Representan la estructura del sistema mostrando clases, atributos, métodos y relaciones.
- Diagramas de casos de uso: Describen cómo los usuarios (actores) interactúan con el sistema.
- Diagramas de secuencia: Muestran la interacción entre objetos a lo largo del tiempo.
Ejemplo simple de diagrama de clases
+-------------------+
| Persona |
+-------------------+
| - nombre: string |
| - edad: int |
+-------------------+
| + Saludar(): void |
+-------------------+
Software recomendado para diagramar UML
- Draw.io (Diagrams.net) → Gratuito y online.
- StarUML → Potente y multiplataforma.
- Visual Paradigm → Enfocado en proyectos grandes.
- PlantUML → Basado en texto, ideal para programadores.
Recurso recomendado: UML en 24 horas - Martin Fowler.
Fundamentos de POO en C#
En C#, todo comienza con clases y objetos.
Para trabajar con objetos en C#, primero es necesario definir una clase. Una clase es un plano que describe los datos y el comportamiento de los objetos que se crearán a partir de ella. Un objeto es una instancia de una clase, es decir, una realización concreta de la estructura definida por la clase.
Clases y objetos
Una clase en C# se define utilizando la palabra clave class, seguida del nombre de la clase y un cuerpo que contiene sus miembros (propiedades, métodos, etc.)
- Clase: Es un modelo que define atributos y comportamientos.
- Objeto: Es una instancia concreta de una clase.
public class Persona
{
// Atributos
public string Nombre { get; set; }
public int Edad { get; set; }
// Constructor
public Persona(string nombre, int edad)
{
Nombre = nombre;
Edad = edad;
}
// Método
public void Saludar()
{
Console.WriteLine($"Hola, mi nombre es {Nombre} y tengo {Edad} años.");
}
}
// Uso
Persona p1 = new Persona("Ana", 25);
p1.Saludar();
Constructores en C#
Los constructores en C# son métodos especiales que se invocan automáticamente al crear una instancia de una clase. Se utilizan para inicializar el estado del objeto y establecer valores predeterminados para sus campos. Los constructores se pueden sobrecargar para ofrecer diferentes maneras de inicializar objetos.
Constructor básico
Un constructor tiene el mismo nombre que la clase y no tiene un tipo de retorno. Su propósito principal es inicializar los campos o propiedades del objeto cuando este se instancia.
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
// Constructor
public Person()
{
Name = "mario";
Edad = 21;
}
}
En este ejemplo, la clase Person tiene un constructor que inicializa Name como "mario" y Age como 21. Este constructor se llama cuando se crea una nueva instancia de Person sin argumentos.
Person person = new Person();
Console.WriteLine($"Nombre: {person.Name}, Edad: {person.Age}"); // Nombre: mario, Edad: 21
Todos los objetos se crean con los mismos datos por defecto, por lo que no es recomendable dejarlos así.
Constructor Parametrizado
Los constructores también pueden tomar parámetros para inicializar el objeto con valores específicos.
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
// Constructor Parametrizado
public Person(string name, int age)
{
Name = name;
Edad = age;
}
}
En este ejemplo, la clase Person tiene un constructor parametrizado que permite establecer Name y Age al crear una instancia de Person.
Person person = new Person("John", 30);
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}"); // Name: John, Age: 30
Constructores sobrecargados
Puede tener varios constructores en una clase, cada uno con diferentes parámetros. Esto se conoce como sobrecarga de constructores.
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
// Se deja vacío para acceder a las propiedades y métodos de la clase sin tener que crear un nuevo objeto.
public Person(){}
// Constructor parametrizado
public Person(string name)
{
Name = name;
Age = 0; }
// Constructor parametrizado con edad
public Person(string name, int age)
{
Name = name;
Edad = age;
}
}
En este ejemplo, la clase Person tiene tres constructores:
- Se deja vacío para acceder a las propiedades y métodos de la clase sin tener que crear un nuevo objeto.
- El segundo constructor inicializa Name con un valor especificado y Age a 0.
- El tercer constructor inicializa Name y Age con valores especificados.
Person instance = new Person();
Person person2 = new Person("Maria");
Person person3 = new Person("Carlos", 40);
Console.WriteLine($"Person2 - Name: {person2.Name}, Age: {person2.Age}"); // Nombre: María, Edad: 0
Console.WriteLine($"Persona3 - Nombre: {persona3.Nombre}, Edad: {persona3.Edad}"); // Nombre: Carlos, Edad: 40
Principios avanzados de POO
La POO en C# se sustenta en cuatro pilares fundamentales:
1. Abstracción
Modelar entidades reales mostrando solo los detalles relevantes.
abstract class Figura
{
public abstract double CalcularArea();
}
2. Encapsulamiento
Controlar el acceso a los datos internos mediante propiedades y modificadores de acceso.
public class CuentaBancaria
{
private decimal saldo;
public void Depositar(decimal monto) => saldo += monto;
public decimal ConsultarSaldo() => saldo;
}
3. Herencia
Permite que una clase herede atributos y métodos de otra.
public class Animal
{
public void Comer() => Console.WriteLine("El animal está comiendo");
}
public class Perro : Animal
{
public void Ladrar() => Console.WriteLine("Guau!");
}
4. Polimorfismo
Un mismo método puede tener comportamientos distintos según el contexto.
public class Figura
{
public virtual void Dibujar() => Console.WriteLine("Dibujar figura");
}
public class Circulo : Figura
{
public override void Dibujar() => Console.WriteLine("Dibujar círculo");
}
Clases abstractas, interfaces y modificadores de acceso
-
Clases abstractas
No pueden instanciarse directamente. Sirven como plantilla para otras clases.public abstract class Vehiculo
{
public abstract void Mover();
} -
Interfaces
Definen un contrato que las clases deben implementar.public interface IVehiculo
{
void Mover();
}
public class Coche : IVehiculo
{
public void Mover() => Console.WriteLine("El coche se mueve");
} -
Modificadores de acceso
Controlan la visibilidad de clases y miembros:public→ Accesible desde cualquier lugar.private→ Solo dentro de la clase.protected→ Accesible en la clase y sus derivadas.internal→ Accesible dentro del mismo proyecto.
- UML permite visualizar y planificar sistemas orientados a objetos.
- POO en C# se basa en clases y objetos que definen datos y comportamientos.
- Los pilares de POO son: abstracción, encapsulamiento, herencia y polimorfismo.
- C# soporta clases abstractas, interfaces y modificadores de acceso para estructurar el código de forma segura y reutilizable.