Pilares de la POO

¿A dónde vamos con todo esto?

Ya conoces la Abstracción y el Encapsulamiento (get / set). Ahora nos enfocaremos en Herencia y Polimorfismo. Estos pilares te permitirán escribir enormes simulaciones, videojuegos o aplicaciones reduciendo el código repetido casi a cero.

Herencia (`:`)

La herencia significa crear una "clase hija" que obtiene todas las propiedades y métodos de una "clase padre", logrando así reutilizar el comportamiento base sin tener que escribirlo de nuevo.

Herencia en Acción

CSHARP

  // Clase Padre General (Base) 
  class Animal  
  { 
      public string Nombre { get; set; } 
    
      public void Respirar() 
      { 
          Console.WriteLine("Respirando..."); 
      } 
  } 
    
  // Gato *es un* Animal (Clase hija o Derivada) 
  class Gato : Animal 
  { 
      public void Maullar() 
      { 
          Console.WriteLine("¡Miau!"); 
      } 
  } 
    
  class Program 
  { 
      static void Main() 
      { 
          Gato miGatito = new Gato(); 
           
          miGatito.Nombre = "Michi"; // Propiedad heredada de Animal 
          miGatito.Respirar(); // Método heredado de Animal 
           
          miGatito.Maullar();  // Su propio método 
      } 
  } 

Polimorfismo (`virtual` y `override`)

Ocurre cuando heredaste de la clase base un método, pero te das cuenta que es deficiente, así que la hija decide sobrescribirlo (rediseñarlo por su cuenta), logrando tener "múltiples formas" de ejecución bajo el mismo nombre.

Polimorfismo (Sobrescritura)

CSHARP

  // Clase Base 
  class Enemigo  
  { 
      // 'virtual' significa: "Las hijas pueden modificar este botón" 
      public virtual void Atacar()  
      { 
          Console.WriteLine("El enemigo da un golpe simple: -10 HP"); 
      } 
  } 
    
  class JefeFinal : Enemigo 
  { 
      // 'override' significa: "Lo siento papá, yo lo haré a mi manera" 
      public override void Atacar() 
      { 
          Console.WriteLine("El JEFE LANZA FUEGO: -100 HP y quema todo"); 
      } 
  } 

Interfaces (`I`)

Las Interfaces en C# son como contratos. Las llamas empezando con I obligan a una clase a decir: "Yo prometo firmar el contrato e implementar estos métodos". Es clave en arquitecturas de dependencias, y aunque no permite variables, dictará el comportamiento exacto que deba ser seguido.

Sintaxis de Interfaces

CSHARP

  // Es como un contrato que dice "quien use esto DEBE poder VOLAR" 
  interface IVolador 
  { 
      void Volar(); 
  } 
    
  // Un avión implementa el contrato 
  class Avion : IVolador 
  { 
      public void Volar() 
      { 
          Console.WriteLine("Motores encendidos. Volando por el cielo."); 
      } 
  } 
    
  // Un pato también 
  class Pato : IVolador 
  { 
      public void Volar() 
      { 
          Console.WriteLine("El pato mueve las alas."); 
      } 
  } 

¡Felicidades, has dominado los fundamentos de C#! 🎉

Desde escribir tu primer programa secuencial, evaluar lógicas con ciclos, agrupar datos, hasta aplicar buenas prácticas de ingeniería de software mediante Clases e Interfaces. Estás completamente capacitado para saltar a un Framework moderno (`ASP.NET Core`, `Unity`, `React con C# backend`) o afrontar nuestra sección del "Modo Desafío".

👨‍💻 Ejercicio Práctico

Misión: Herencia Heroica

Crea una clase base Personaje con un método virtual Atacar(). Luego, crea una clase hija Guerrero : Personaje que le haga override al ataque para hacerlo más fuerte.

👁️ Ver solución propuesta

Código

CSHARP

  class Personaje 
  { 
      public virtual void Atacar() 
      { 
          Console.WriteLine("Daño básico de 10 puntos."); 
      } 
  } 
    
  class Guerrero : Personaje 
  { 
      public override void Atacar() 
      { 
          Console.WriteLine("¡Golpe Aplastante! Daño de 50 puntos."); 
      } 
  } 
    
  class Program 
  { 
      static void Main() 
      { 
          Guerrero g = new Guerrero(); 
          g.Atacar(); // Imprime el golpe del Guerrero 
      } 
  } 

👨‍💻 Ejercicio Práctico 2

Misión: El polimorfismo musical

Crea clase base `Instrumento` con método virtual Tocar(). Herédala en Guitarra y hazle un override diciendo "¡Riff de Rock!".

👁️ Ver solución propuesta

Código

CSHARP

  class Instrumento  
  { 
      public virtual void Tocar() { Console.WriteLine("Suena algo"); }  
  } 
    
  class Guitarra : Instrumento 
  { 
      public override void Tocar() { Console.WriteLine("¡Riff de Rock!"); } 
  } 

👨‍💻 Ejercicio Práctico 3

Misión: Contrato Volador

Desarrolla una interfaz IVolador con el método Volar(). Haz que una clase Pato implemente la interfaz.

👁️ Ver solución propuesta

Código

CSHARP

  interface IVolador  
  { 
      void Volar(); 
  } 
    
  class Pato : IVolador  
  { 
      public void Volar() { 
          Console.WriteLine("El pato vuela"); 
      } 
  } 

👨‍💻 Ejercicio Práctico 4

Misión: Herencia de Propiedades

Una clase Vehiculo con propiedad `Llantas`. La clase Moto hereda de ella. En Main crea tu moto y asígnale `m.Llantas = 2`.

👁️ Ver solución propuesta

Código

CSHARP

  class Vehiculo 
  { 
      public int Llantas { get; set; } 
  } 
    
  class Moto : Vehiculo { } 
    
  // En Main 
  Moto m = new Moto(); 
  m.Llantas = 2; 

¡Bienvenido/a!

Contenido

📚 Elige un curso

10. Los Pilares de la POO

¿A dónde vamos con todo esto?

Herencia (`:`)

Polimorfismo (`virtual` y `override`)

Interfaces (`I`)

¡Felicidades, has dominado los fundamentos de C#! 🎉

👨‍💻 Ejercicio Práctico

👨‍💻 Ejercicio Práctico 2

👨‍💻 Ejercicio Práctico 3

👨‍💻 Ejercicio Práctico 4

Ponte a prueba

¡Hecho con mucho cariño! ☕