C# Learning Diary 23---Polymorphism: Operator overloading, method overloading, abstract classes, virtual methods

The definition of polymorphism in C# is: the same operation acts on instances of different classes, different classes perform different interpretations, and finally produce different execution results. In other words, one interface, multiple functions.

C# supports 2 forms of polymorphism: compile-time polymorphism, run-time polymorphism

Compile-time polymorphism:

Compile-time Polymorphism is achieved through overloading

Method overloading

You can have multiple definitions of the same function name in the same scope. Function definitions must differ from each other, either by the type of parameters in the parameter list or by the number of parameters. Function declarations that differ only in return type cannot be overloaded. Write an example

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class exchange  //定义一个exchange类  
    {//方法实现交换两参数数据  
        public void swap(int a, int b)  
        {  
            int temp;  
            temp = a;  
            a = b;  
            b = temp;  
            Console.WriteLine("{0},{1}",a,b);  
        }  
        public void swap(string a, string b)  
        {  
            string temp;  
            temp = a;  
            a = b;  
            b = temp;  
            Console.WriteLine("{0},{1}", a, b);  
        }  
  
    }  
    class program  
    {  
        static void Main(string[] args)  
        {  
            exchange exch = new exchange();  
            exch.swap(10, 20);  //调用 swap(int a,int b)方法  
            exch.swap("大", "小");  //调用 swap(string a,string b)方法  
          
        }  
    }  
}

Result:

Operator overloading

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class student  //定义student类  
    {  
        private int Chinese;  
        private int Math;  
        public void value(int a, int b)  //定义一个赋值的方法,以后学了构造方法就不这么麻烦了  
        {  
            Chinese = a;  
            Math = b;  
        }  
        public static student operator + (student a, student b) //运算符重载，实现相加功能  
        {  
            student stu = new student();  
            stu.Chinese = a.Chinese + b.Chinese;  
            stu.Math = a.Math + b.Math;  
            return stu;  
        }  
        public int getChinese()  //获取Chinese 的方法  
        {  
            return Chinese;  
        }  
        public int getMath()  //获取Math 的方法  
        {  
            return Math;  
        }  
    }  
    class program  
    {  
        static void Main(string[] args)  
        {  
            student a = new student();  
            student b = new student();  
            a.value(70,80);  
            b.value(40, 50);  
            student stu = a + b;  //70+40， 80+50  
            Console.WriteLine("a+b Chinese = {0}\na+b Math = {1}", stu.getChinese(), stu.getMath());  
              
        }  
    }  
}

Result:

Runtime polymorphism:

Runtime polymorphism means that it is not until the system is running that the actual operation is decided based on the actual situation. Runtime polymorphism in C# is implemented through abstract classes or Implemented using virtual methods.

Abstract classes and abstract methods

C# allows you to use the keyword abstract to create abstract classes or abstract methods. When a derived class inherits from the abstract class, the implementation is complete. Abstract classes contain abstract methods, which can be implemented by derived classes. Derived classes have more specialized functionality. Abstract classes cannot be instantiated.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{//创建抽象类和抽象方法  
   abstract class score  
    {  
       public abstract int Add();  
    }  
    //创建子类  
   class student : score  
   {  
       private int Chinese = 80;  
       private int Math = 90;  
       public override int Add()  //关键字 override 实例方法  
       {  
          int sum=Chinese+Math;  
           return sum;  
       }  
         
   }  
    class program  
    {  
        static void Main(string[] args)  
        {  
            student stu = new student();  
                
            Console.WriteLine(stu.Add() );  //结果 170  
             
        }  
    }  
}

Virtual methods

Virtual methods are declared using the keyword virtual. Virtual methods can have different implementations in different inherited classes. Calls to virtual methods occur at runtime.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
   class score  
    {  
       protected int Chinese = 80;  
       protected int Math = 90;  
       public virtual int Add()  //定义一个虚方法  
       {  
           int sum = Chinese + Math;  
           return sum;  
       }  
    }  
   //定义子类，实现方法  
   class student : score  
   {  
       public override int Add()  //关键字 override 实例方法，实现相减操作  
       {  
           int sub = Math - Chinese ;  
           return sub;  
       }  
         
   }  
    class program  
    {  
        static void Main(string[] args)  
        {  
            student stu = new student();  
                
            Console.WriteLine(stu.Add() );  //结果 10  
             
        }  
    }  
}

We can see that the method actually called at runtime is not a virtual method, but the method after the override instance.

The above is C# Learning Diary 23---Polymorphism Operator Overloading , method overloading, abstract classes, and virtual methods. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!