C# Academy · Lección

Comportamientos polimórficos

Use polimorfismo basado en interfaces: procese formas mixtas de manera uniforme, añada formas nuevas sin cambiar a quienes llaman y componga comportamientos pequeños.

Comportamientos polimórficos es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Descripción general del polimorfismo

Objetivo: Use el polimorfismo para mantener sencillos los componentes que realizan las llamadas.

Trabaje siempre con IShape
Combine muchas figuras en una sola lista
Añada figuras nuevas sin cambiar el código
Componga comportamientos pequeños (formateo, filtrado)

Una API para todas las figuras

Acepte la interfaz IShape en los ayudantes. El despacho en tiempo de ejecución selecciona la implementación adecuada.

using System;

public interface IShape
{
  double Area();
  double Perimeter();
}

public sealed class Rectangle : IShape
{
  private readonly double _w, _h;
  public Rectangle(double w, double h) { _w = w; _h = h; }
  public double Area() { return _w * _h; }
  public double Perimeter() { return 2 * (_w + _h); }
}

public sealed class Circle : IShape
{
  private readonly double _r;
  public Circle(double r) { _r = r; }
  public double Area() { return 3.14159 * _r * _r; }
  public double Perimeter() { return 2 * 3.14159 * _r; }
}

public class Program
{
  // One function works for any IShape (dynamic dispatch on overrides)
  static void PrintSummary(IShape s)
  {
    Console.WriteLine("A=" + s.Area() + " P=" + s.Perimeter());
  }

  public static void Main(string[] args)
  {
    PrintSummary(new Rectangle(3, 4));
    PrintSummary(new Circle(2));
  }
}

Procesamiento de una lista mixta

Almacene muchas figuras en una List<IShape>. La iteración sigue siendo sencilla, mientras que el comportamiento varía según la instancia.

using System;
using System.Collections.Generic;

public interface IShape { double Area(); double Perimeter(); }

public sealed class Rectangle : IShape
{
  private readonly double _w, _h;
  public Rectangle(double w, double h) { _w = w; _h = h; }
  public double Area() { return _w * _h; }
  public double Perimeter() { return 2 * (_w + _h); }
}

public sealed class Circle : IShape
{
  private readonly double _r;
  public Circle(double r) { _r = r; }
  public double Area() { return 3.14159 * _r * _r; }
  public double Perimeter() { return 2 * 3.14159 * _r; }
}

public class Program
{
  public static void Main(string[] args)
  {
    List<IShape> shapes = new List<IShape>();
    shapes.Add(new Rectangle(2, 5));
    shapes.Add(new Circle(1.5));
    shapes.Add(new Rectangle(1, 1));

    foreach (IShape s in shapes)
    {
      Console.WriteLine("A=" + s.Area());
    }
  }
}

Abierto a la extensión

El polimorfismo permite la extensión abierta: las figuras nuevas se integran sin editar los componentes que realizan las llamadas.

using System;

public interface IShape { double Area(); double Perimeter(); }

public sealed class Triangle : IShape
{
  private readonly double _a, _b, _c;
  public Triangle(double a, double b, double c) { _a = a; _b = b; _c = c; }
  public double Perimeter() { return _a + _b + _c; }
  public double Area()
  {
    double s = (_a + _b + _c) / 2.0;
    return Math.Sqrt(s * (s - _a) * (s - _b) * (s - _c));
  }
}

public class Program
{
  // Existing helper still works; no changes needed
  static void Show(IShape s) { Console.WriteLine("A=" + s.Area() + " P=" + s.Perimeter()); }

  public static void Main(string[] args)
  {
    Show(new Triangle(3, 4, 5)); // new type plugs in
  }
}

Composición de comportamientos (estrategia)

Componga comportamientos pequeños mediante interfaces pequeñas (como un formateador). Cambie las estrategias sin modificar la figura.

using System;

public interface IShape { double Area(); double Perimeter(); }

public sealed class Rectangle : IShape
{
  private readonly double _w, _h;
  public Rectangle(double w, double h) { _w = w; _h = h; }
  public double Area() { return _w * _h; }
  public double Perimeter() { return 2 * (_w + _h); }
}

// Small strategy interface for formatting
public interface IShapeFormatter
{
  string Format(IShape s);
}

public sealed class SimpleFormatter : IShapeFormatter
{
  public string Format(IShape s) { return "A=" + s.Area() + " P=" + s.Perimeter(); }
}

public class Program
{
  static void Print(IShape s, IShapeFormatter f)
  {
    Console.WriteLine(f.Format(s));
  }

  public static void Main(string[] args)
  {
    Print(new Rectangle(3, 2), new SimpleFormatter());
  }
}

Consejos sobre polimorfismo

Consejos:

Pase IShape a los ayudantes; evite las comprobaciones de tipos.
Mantenga los ayudantes pequeños y puros cuando sea posible.
Añada figuras nuevas libremente; no edite los componentes que realizan las llamadas.
Use interfaces de comportamiento pequeñas (formateo, filtrado) para ampliar las funcionalidades.

Ventaja de la interfaz

Comprobación rápida: ¿Cuál es la principal ventaja de programar contra la interfaz IShape en esta biblioteca?

Resumen

Resumen: Reciba parámetros de tipo IShape, procese listas mixtas y añada figuras sin modificar los componentes que realizan las llamadas. Componga comportamientos pequeños para el formateo o el filtrado y mantenga flexible el código.

Preguntas frecuentes

¿La lección «Comportamientos polimórficos» es gratis?

Sí — el texto completo de «Comportamientos polimórficos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Comportamientos polimórficos»?

Use polimorfismo basado en interfaces: procese formas mixtas de manera uniforme, añada formas nuevas sin cambiar a quienes llaman y componga comportamientos pequeños. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Comportamientos polimórficos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C# Academy