C#-Lerntagebuch 23 --- Polymorphismus: Operatorüberladung, Methodenüberladung, abstrakte Klassen, virtuelle Methoden

Die Definition von Polymorphismus in C# lautet: Dieselbe Operation wirkt auf Instanzen verschiedener Klassen, verschiedene Klassen interpretieren sie unterschiedlich und erzeugen schließlich unterschiedliche Ausführungsergebnisse. Mit anderen Worten: eine Schnittstelle, mehrere Funktionen.

C# unterstützt zwei Formen von Polymorphismus: Polymorphismus zur Kompilierungszeit, Polymorphismus zur Laufzeit

Polymorphismus zur Kompilierungszeit:

Polymorphismus zur Kompilierungszeit wird durch Überladung erreicht

Methodenüberladung

Sie können mehrere Definitionen desselben Funktionsnamens im selben Bereich haben. Funktionsdefinitionen müssen sich voneinander unterscheiden, entweder durch die Art der Parameter in der Parameterliste oder durch die Anzahl der Parameter. Funktionsdeklarationen, die sich nur im Rückgabetyp unterscheiden, können nicht überladen werden. Schreiben Sie ein Beispiel

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)方法  
          
        }  
    }  
}

Ergebnis:

Operatorüberladung

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());  
              
        }  
    }  
}

Ergebnis:

Laufzeitpolymorphismus:

Laufzeitpolymorphismus bedeutet, dass erst bei laufendem System entschieden wird, welche Operation basierend auf der tatsächlichen Situation implementiert werden soll. Laufzeitpolymorphismus in C# Wird durch abstrakte Klassen implementiert oder virtuelle Methoden.

Abstrakte Klassen und abstrakte Methoden

In C# können Sie das Schlüsselwort abstract verwenden, um abstrakte Klassen oder abstrakte Methoden zu erstellen. Wenn eine abgeleitete Klasse von der abstrakten Klasse erbt, ist die Implementierung abgeschlossen. Abstrakte Klassen enthalten abstrakte Methoden, die durch abgeleitete Klassen implementiert werden können. Abgeleitete Klassen verfügen über speziellere Funktionen. Abstrakte Klassen können nicht instanziiert werden,

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  
             
        }  
    }  
}

virtuelle Methoden

Virtuelle Methoden werden mit dem Schlüsselwort virtual deklariert. Virtuelle Methoden können in verschiedenen geerbten Klassen unterschiedliche Implementierungen haben. Aufrufe virtueller Methoden erfolgen zur Laufzeit.

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  
             
        }  
    }  
}

Wir können sehen, dass die tatsächlich zur Laufzeit aufgerufene Methode keine virtuelle Methode ist, sondern die Methode nach der Überschreibungsinstanz

Das Obige ist C# Learning Diary 23---Polymorphism For Weitere Informationen zu Operatorüberladung, Methodenüberladung, abstrakten Klassen und virtuellen Methoden finden Sie auf der chinesischen PHP-Website (www.php.cn) für weitere verwandte Inhalte!