Polymorphism is the ability of the same behavior to have many different forms or forms of expression.
Polymorphism means multiple forms. In the object-oriented programming paradigm, polymorphism is often expressed as “one interface, multiple functions”.
Polymorphism can be static or dynamic. In static polymorphism, the response of a function occurs at compile time. In dynamic polymorphism, the response of a function occurs at run time.
In C #, every type is polymorphic because all types, including user-defined types, inherit from Object.
Polymorphism is the same interface that uses different instances to perform different operations, as shown in the figure:
In reality, for example, we press the F1 key:
If what currently pops up under the Flash interface is the help document forAS 3
If the current pop-up under Word is Word help
What pops up under Windows is Windows help and support.
The same event occurs on different objects and produces different results. At compile time, the connection mechanism between functions and objects is called early binding, also known as static binding. C# provides two techniques to achieve static polymorphism. They are: Function overload Operator overloading Operator overloading is discussed in the next section, and we will discuss function overloading next. You can have multiple definitions of the same function name within the same scope. The definitions of functions must be different from each other, either the type of parameters in the parameter list or the number of parameters. Only function declarations with different return types cannot beoverloaded. The following example demonstrates several of the same functions The following example demonstrates several of the same functions When the above code is compiled and executed, it produces the following results: C # allows you to use keywords Note that here are some rules for abstract classes: You cannot create an instance of an abstract class. You cannot declare an abstract method outside an abstract class. By placing keywords in front of the class definition The following program demonstrates an abstract class: When the above code is compiled and executed, it produces the following results: You can use virtual methods when there is a function defined in a class that needs to be implemented in an inherited class. The virtual method is to use keywords Virtual methods can have different implementations in different inherited classes. Calls to virtual methods occur at run time. Dynamic polymorphism is achieved through abstract classes and virtual methods. The following example creates the When the above code is compiled and executed, it produces the following results: The following program demonstrates how to use the virtual method When the above code is compiled and executed, it produces the following results: 1.36.1. Static polymorphism #
1.36.2. Function overload #
Add() used to add different number of parameters:Example #
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 { static void 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); } } }
print() for printing different data typesExample #
using System; namespace PolymorphismApplication { class Printdata { void print(int i) { Console.WriteLine("Output integer: {0}", i ); } void print(double f) { Console.WriteLine("Output Floating Point: {0}" , f); } void print(string s) { Console.WriteLine("String: {0}", s); } static void Main(string[] args) { Printdata p = new Printdata(); // Calling print to print integers p.print(1); // Calling print to print floating-point numbers p.print(1.23); // Calling print to print a string p.print("Hello Runoob"); Console.ReadKey(); } } }
Output integer: 1 Output floating-point type: 1.23 Output string: Hello Runoob
1.36.3. Dynamic polymorphism #
abstract create an abstract class that provides the implementation of some of the classes that provide the interface. When a derived class inherits from the abstract class, the implementation is complete. Abstract classes contain abstract methods, whichcan be implemented by derived classes. Derived classes have more professional functionality. sealed , you can declare a class as a sealed class When a class is declared as sealed ,which cannot be inherited. An abstract class cannot be declared as sealed .Example #
using System; namespace PolymorphismApplication { abstract class 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("Area of the Rectangle class："); return (width * length); } } class RectangleTester { static void Main(string[] args) { Rectangle r = new Rectangle(10, 7); double a = r.area(); Console.WriteLine("Area： {0}",a); Console.ReadKey(); } } }
Area of Rectangle class: Area: 70
virtual declared. Shape base classand creates derived classes such as Circle , Rectangle ,and Triangle . The Shape class provides a virtualmethod called Draw , which is rewritten in each derivedclass to draw the specified shape of the class.Example #
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; } // Virtual method public virtual void Draw() { Console.WriteLine("Execute drawing tasks for base classes"); } } class Circle : Shape { public override void Draw() { Console.WriteLine("Draw a circle"); base.Draw(); } } class Rectangle : Shape { public override void Draw() { Console.WriteLine("draw a rectangle"); base.Draw(); } } class Triangle : Shape { public override void Draw() { Console.WriteLine("draw a triangle"); base.Draw(); } } class Program { static void Main(string[] args) { // Create a List<Shape>object and add Circle, Triangle, and Rectangle to it var shapes = new List<Shape> { new Rectangle(), new Triangle(), new Circle() }; // Use a foreach loop to iterate over the derived classes of the list and call the Draw method on each Shape object within it foreach (var shape in shapes) { shape.Draw(); } Console.WriteLine("Press any key to exit。"); Console.ReadKey(); } }
Draw a rectangle Execute drawing tasks for base classes Draw a triangle Execute drawing tasks for base classes Draw a circle Execute drawing tasks for base classes Press any key to exit.
area() to calculate the area of images of different shapes:Example #
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("Area of parent class："); return 0; } } class Rectangle: Shape { public Rectangle( int a=0, int b=0): base(a, b) { } public override int area () { Console.WriteLine("Area of the Rectangle class："); return (width * height); } } class Triangle: Shape { public Triangle(int a = 0, int b = 0): base(a, b) { } public override int area() { Console.WriteLine("Area of the Triangle class："); return (width * height / 2); } } class Caller { public void CallArea(Shape sh) { int a; a = sh.area(); Console.WriteLine("Area： {0}", a); } } class Tester { static void 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(); } } }
Area of Rectangle class: Area: 70 Area of Triangle class: Area: 25