Tutorial básico de C#

Tutorial avanzado de C#

C# orientado a objetos (OOP)

Sobrecarga de operadores de C#Herencia de C#

Polimorfismo de C#

El polimorfismo es la capacidad de que el mismo comportamiento tenga múltiples表现形式 o formas diferentes.

El polimorfismoSignifica que hay múltiples formas. En el paradigma de programación orientada a objetos, el polimorfismo a menudo se manifiesta como "un interfaz, múltiples funciones".

El polimorfismo puede ser estático o dinámico. EnEl polimorfismo estáticoEn, la respuesta de la función ocurre en tiempo de compilación. Enpolimorfismo dinámicoEn, la respuesta de la función ocurre en tiempo de ejecución.

En C#, cada tipo es polimórfico, porque todos los tipos, incluyendo los tipos definidos por el usuario, heredan de Object.

El polimorfismo es el mismo interfaz, utiliza diferentes ejemplos para ejecutar diferentes operaciones, como se muestra en la figura:

En la realidad, por ejemplo, cuando presionamos F1 La acción de tecla:

Si se abre bajo la interfaz de Flash, será AS 3 La documentación de ayuda;
Si se abre bajo Word, será la ayuda de Word;
Bajo Windows, se abrirá la ayuda y soporte de Windows.

El mismo evento que ocurre en diferentes objetos produce resultados diferentes.

El polimorfismo estático

En tiempo de compilación, el mecanismo de conexión entre funciones y objetos se llama vínculo temprano, también conocido como vínculo estático. C# ofrece dos técnicas para implementar la polimorfismo estático. Estas son:

sobre carga de funciones
La sobrecarga de operadores

La sobrecarga de operadores se discutirá en el siguiente capítulo, y a continuación, discutiremos la sobrecarga de funciones.

sobre carga de funciones

Puede haber múltiples definiciones del mismo nombre de función en el mismo ámbito. Las definiciones de las funciones deben ser diferentes entre sí, ya sea por tipos de parámetros diferentes en la lista de parámetros o por diferentes cantidades de parámetros. No se puede sobrecargar una declaración de función que solo difiera en el tipo de retorno.

El siguiente ejemplo muestra varios métodos idénticos Add()para manejar la suma de diferentes cantidades de parámetros:

Ejemplo

using System;
namespace PolymorphismApplication
{}}
　　　　public class TestData　　
　　　　{}}　　
　　　　　　　　public int Add(int a, int b, int c)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　return a　+　b　+　c;　　
　　　　　　　　}　　
　　　　　　　　public int Add(int a, int b)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　return a　+　b;　　
　　　　　　　　}　　
　　　　}　　
　　　　class Program　　
　　　　{}}　　
　　　　　　　　void static Main(string[] args)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　TestData dataClass = new TestData();
　　　　　　　　　　　　int add1　= dataClass.Add(1,　2);　　
　　　　　　　　　　　　int add2　= dataClass.Add(1,　2,　3);
　　　　　　　　　　　　Console.WriteLine("add1　:"　+　add1);
　　　　　　　　　　　　Console.WriteLine("add2　:"　+　add2);　　
　　　　　　　　}　　
　　　　}　　
}

El siguiente ejemplo muestra varios métodos idénticos print()para imprimir diferentes tipos de datos:

Ejemplo

using System;
namespace PolymorphismApplication
{}}
　　　class Printdata
　　　{}}
　　　　　　void print(int i)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("salida de tipo entero: {0}" , i );
　　　　　　}
　　　　　　void print(double f)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("salida de tipo flotante: {0}" , f);
　　　　　　}
　　　　　　void print(string s)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("salida de cadena: {0}", s);
　　　　　　}
　　　　　　void static Main(string[] args)
　　　　　　{}}
　　　　　　　　　Printdata p = new Printdata();
　　　　　　　　　//　invocar print para imprimir un entero
　　　　　　　　　p.print(1);
　　　　　　　　　//　invocar print para imprimir un número flotante
　　　　　　　　　p.print(1.23);
　　　　　　　　　//　invocar print para imprimir una cadena
　　　　　　　　　p.print("Hello w3codebox");
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Cuando el código anterior se compila y ejecuta, producirá los siguientes resultados:

salida de tipo entero:　1
salida de tipo flotante:　1.23
salida de cadena: Hello w3codebox

polimorfismo dinámico

C# le permite usar la palabra clave abstract clase abstracta para proporcionar la implementación de parte de una clase que ofrece una interfaz. Cuando una clase derivada hereda de esta clase abstracta, la implementación se completa.clase abstractaque contienen métodos abstractos, que pueden ser implementados por las clases derivadas. Las clases derivadas tienen funcionalidades más especializadas.

Tenga en cuenta las siguientes reglas sobre las clases abstractas:

No se puede crear una instancia de una clase abstracta.
No se puede declarar un método abstracto fuera de una clase abstracta.
colocando la palabra clave sealed, se puede declarar una clase comoclase sellada. Cuando se declara una clase como sealed no puede ser heredada. La clase abstracta no puede ser declarada como sealed.

El siguiente programa muestra una clase abstracta:

Ejemplo

using System;
namespace PolymorphismApplication
{}}
　　　clase abstracta Shape
　　　{}}
　　　　　　　abstract public int area();
　　　}
　　　class Rectangle: Shape
　　　{}}
　　　　　　private int length;
　　　　　　private int width;
　　　　　　public Rectangle(int a=0, int b=0)
　　　　　　{}}
　　　　　　　　　length = a;
　　　　　　　　　width = b;
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}　
　　　　　　　　　Console.WriteLine("Área de la clase Rectangle:");
　　　　　　　　　return (width　*　length);　
　　　　　　}
　　　}
　　　class RectangleTester
　　　{}}
　　　　　　void static Main(string[] args)
　　　　　　{}}
　　　　　　　　　Rectangle r = new Rectangle(10,　7);
　　　　　　　　　double a = r.area();
　　　　　　　　　Console.WriteLine("Área: {0}", a);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Cuando el código anterior se compila y ejecuta, producirá los siguientes resultados:

Área de la clase Rectangle:
Área:　70

Cuando hay una función definida en una clase que necesita ser implementada en la clase heredada, se puede utilizarMétodo virtual.

Los métodos virtuales se utilizan con la palabra clave virtual declarado.

Los métodos virtuales pueden tener diferentes implementaciones en diferentes clases heredadas.

la llamada al método virtual ocurre en tiempo de ejecución.

La polimorfismo dinámico se realiza a través de clase abstracta y Método virtual implementado.

El siguiente ejemplo crea la clase base Shape, y crea clases derivadas Circle, Rectangle, Triangle, la clase Shape proporciona un método virtual llamado Draw, que se sobrescribe en cada clase derivada para dibujar la forma específica de la clase.

Ejemplo

using System;
using System.Collections.Generic;
public class Shape
{}}
　　　　public int X { get; private set; }
　　　　public int Y { get; private set; }
　　　　public int Height { get; set; }
　　　　public int Width { get; set; }
　　　
　　　　//　Método virtual
　　　　public virtual void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Ejecutar la tarea de dibujo de la clase base");
　　　　}
}
class Circle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Dibujar un círculo");
　　　　　　　　base.Draw();
　　　　}
}
class Rectangle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Dibujar un rectángulo");
　　　　　　　　base.Draw();
　　　　}
}
class Triangle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Dibujar un triángulo");
　　　　　　　　base.Draw();
　　　　}
}
class Program
{}}
　　　　void static Main(string[] args)
　　　　{}}
　　　　　　　　//　Crear un objeto List<Shape> y agregar Circle, Triangle y Rectangle a él
　　　　　　　　var shapes = new List<Shape>
　　　　　　　　{}}
　　　　　　　　　　　　new Rectangle(),
　　　　　　　　　　　　new Triangle(),
　　　　　　　　　　　　new Circle()
　　　　　　　　};
　　　　　　　　//　Se utiliza un ciclo foreach para recorrer la lista de subclases y llamar al método Draw de cada objeto Shape　
　　　　　　　　foreach (var shape in shapes)
　　　　　　　　{}}
　　　　　　　　　　　　shape.Draw();
　　　　　　　　}
　　　　　　　　Console.WriteLine("Presione cualquier tecla para salir.");
　　　　　　　　Console.ReadKey();
　　　　}
}

Cuando el código anterior se compila y ejecuta, producirá los siguientes resultados:

Dibujar un rectángulo
Ejecutar la tarea de dibujo de la clase base
Dibujar un triángulo
Ejecutar la tarea de dibujo de la clase base
Dibujar un círculo
Ejecutar la tarea de dibujo de la clase base
Presione cualquier tecla para salir.

El siguiente programa demuestra cómo calcular el área de diferentes figuras geométricas a través del método virtual area():

Ejemplo

using System;
namespace PolymorphismApplication
{}}
　　　class Shape　
　　　{}}
　　　　　　protected int width, height;
　　　　　　public Shape(int a = 0, int b = 0)
　　　　　　{}}
　　　　　　　　　width = a;
　　　　　　　　　height = b;
　　　　　　}
　　　　　　public virtual int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Área de la clase padre:");
　　　　　　　　　return 0;
　　　　　　}
　　　}
　　　class Rectangle: Shape
　　　{}}
　　　　　　public Rectangle(int a = 0, int b = 0): base(a, b)
　　　　　　{}}
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Área de la clase Rectangle:");
　　　　　　　　　return (width　*　height);　
　　　　　　}
　　　}
　　　class Triangle: Shape
　　　{}}
　　　　　　public Triangle(int a = 0, int b = 0): base(a, b)
　　　　　　{}}
　　　　　　
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Área de la clase Triangle:");
　　　　　　　　　return (width　*　height　/　2);　
　　　　　　}
　　　}
　　　class Caller
　　　{}}
　　　　　　public void CallArea(Shape sh)
　　　　　　{}}
　　　　　　　　　int a;
　　　　　　　　　a = sh.area();
　　　　　　　　　Console.WriteLine("Área: {0}", a);
　　　　　　}
　　　}　　
　　　class Tester
　　　{}}
　　　　　　
　　　　　　void static Main(string[] args)
　　　　　　{}}
　　　　　　　　　Caller c = new Caller();
　　　　　　　　　Rectangle r = new Rectangle(10,　7);
　　　　　　　　　Triangle t = new Triangle(10,　5);
　　　　　　　　　c.CallArea(r);
　　　　　　　　　c.CallArea(t);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Cuando el código anterior se compila y ejecuta, producirá los siguientes resultados:

Área de la clase Rectangle:
Área:70
Área de la clase Triangle:
Área:25

Sobrecarga de operadores de C#Herencia de C#