Virtuelle C#-Funktion

Wenn eine Instanzmethode mit dem Schlüsselwort virtual deklariert wird, ist diese Methode eine virtuelle Methode.
Der größte Unterschied zwischen virtuellen Methoden und nicht-virtuellen Methoden besteht darin, dass die Implementierung virtueller Methoden durch abgeleitete Klassen ersetzt werden kann. Dieser Ersatz wird durch Umschreiben der Methode erreicht (mehr dazu später)
Eigenschaften virtueller Methoden:
Statische, abstrakte oder Override-Modifikatoren sind vor virtuellen Methoden nicht zulässig
Virtuelle Methoden können nicht privat sein, daher kann der private Modifikator nicht verwendet werden
Ausführung virtueller Methoden:
Wir wissen, dass allgemeine Funktionen kompiliert werden Zur Kompilierungszeit wird es statisch in die ausführbare Datei kompiliert und seine relative Adresse ändert sich während der Ausführung des Programms nicht. Die relative Adresse der virtuellen Funktion ist unsicher on Die Laufzeitobjektinstanz wird verwendet, um die aufzurufende Funktion dynamisch zu bestimmen. Die während der Deklaration definierte Klasse wird als Deklarationsklasse bezeichnet, und die während der Ausführung instanziierte Klasse wird als Instanzklasse bezeichnet.
Zum Beispiel: A a =new B(); wobei A die Deklarationsklasse und B die Instanzklasse ist.
1. Beim Aufrufen einer Funktion eines Objekts prüft das System direkt die vom Objekt deklarierte Klasse, um festzustellen, ob es sich bei der aufgerufenen Funktion um eine virtuelle Funktion handelt ist keine virtuelle Funktion, dann führt es die Funktion direkt aus. Und wenn es sich um eine virtuelle Funktion handelt, führt sie die Funktion zu diesem Zeitpunkt nicht sofort aus, sondern beginnt mit der Überprüfung der Instanzklasse des Objekts.
3. In dieser Instanzklasse prüft er, ob es eine Methode zum Implementieren der virtuellen Funktion gibt oder ob sie in der Definition der Instanzklasse erneut implementiert wird (über das Schlüsselwort override). , werde ich nicht noch einmal danach suchen, sondern sofort die Methode der in der Instanzklasse implementierten virtuellen Funktion ausführen. Und wenn nicht, sucht das System weiter nach der übergeordneten Klasse der Instanzklasse
und wiederholt die Überprüfung in der Instanzklasse, bis es die erste übergeordnete Klasse findet, die die virtuelle Funktion bisher überlastet, und führt sie dann aus die überladene Funktion in der übergeordneten Klasse.
Beispiel 1:


Führen Sie a.Sum aus:
1. Überprüfen Sie zunächst die Deklarationsklasse A. 2. Überprüfen Sie, ob die Summe eine virtuelle Methode ist. 3. Überprüfen Sie die Instanzklasse A. Das Ergebnis ist die Frage selbst

4. Führen Sie die Methode aus, um Sum in der Instanzklasse A zu implementieren. 5. Geben Sie das Ergebnis aus. Ich bin A-Klasse, ich bin virtuelle sum()

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new A();   // 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,A是a的实例类   
             a.Sum();
             Console.Read();
        }
    }

Führen Sie a aus. Summe:
1. Überprüfen Sie zunächst die Deklarationsklasse A. 2. Überprüfen Sie, ob es sich um eine virtuelle Methode handelt. 3. Überprüfen Sie, ob die Instanzklasse B vorhanden ist. 4. Führen Sie die Methode aus Instanzklasse B 5. Geben Sie das Ergebnis aus. Ich bin B-Klasse, ich überschreibe sum().
Beispiel 3:

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public override void Sum() // 重新实现了虚函数   
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();  // 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,B是a的实例类              
             a.Sum();
             Console.Read();
        }
    }

Führen Sie a.Sum aus:
Überprüfen Sie zunächst die Deklarationsklasse A 2. Überprüfen Sie, ob es sich um eine virtuelle Methode handelt. 3. Überprüfen Sie die Instanzklasse C, keine überschriebene Methode. 4. Überprüfen Sie die übergeordnete Klasse B der Klasse C. Es gibt eine überschriebene Methode
. 5. Führen Sie die Sum-Methode aus die übergeordnete Klasse B 6. Geben Sie das Ergebnis aus. Ich bin B-Klasse, ich überschreibe sum():

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public override void Sum() // 重新实现了虚函数   
        {
            Console.WriteLine("I am B Class,I am override sum().");
        }  

    }
    class C : B
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new C();// 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,C是a的实例类              
             a.Sum();
             Console.Read();
        }
    }

Führen Sie a.Sum aus:
1 Klasse A 2. Überprüfen Sie, ob es sich um eine virtuelle Methode handelt. 3. Überprüfen Sie die Instanzklasse B ohne Überschreibung (beachten Sie hier, dass Sum() zwar in B implementiert ist, das Schlüsselwort override jedoch nicht verwendet wird und daher nicht als a betrachtet wird Umschreiben) 4. Gehen Sie zur übergeordneten Klasse A von Klasse B und dann für sich selbst. 5. Führen Sie die Sum-Methode in der übergeordneten Klasse A aus. 6. Geben Sie das Ergebnis aus. Ich bin A-Klasse, ich bin virtuelle sum() Was wäre, wenn in Beispiel 4 Klasse B deklariert wäre?

Führen Sie Sum() in Klasse B aus und geben Sie das Ergebnis aus. Ich bin B-Klasse, ich bin neu sum().

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public new void Sum() //覆盖父类里的同名函数，而不是重新实现  
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             A a=new B();
             a.Sum();
             Console.Read();
        }
    }

Kann ich abstrakte Funktionen verwenden, um virtuelle Funktionen in der Basisklasse zu überschreiben?

Die Antwort ist ja.

Können versiegelte Klassen virtuelle Funktionen haben?

class A
    {
        public virtual void Sum()
        {
            Console.WriteLine("I am A Class,I am virtual sum().");
        }
    }
    class B : A    
    {
        public new void Sum() //覆盖父类里的同名函数，而不是重新实现  
        {
            Console.WriteLine("I am B Class,I am new sum().");
        }  

    }
    class Program
    {
        static void Main(string[] args)
        {
             B b=new B();
             b.Sum();
             Console.Read();
        }
    }

Ja, die virtuellen Funktionen in der Basisklasse werden implizit in nicht virtuelle Funktionen konvertiert, aber die versiegelte Klasse selbst kann keine neuen virtuellen Funktionen hinzufügen

class A
    {
        public virtual void PrintFriends()
        {
            Console.WriteLine("A.PrintFriends()");   
        }  
    }
    abstract class B : A    
    {
        public abstract override void PrintFriends();   //使用override 修饰符，表示抽象重写了基类中该函数的实现
    }
    abstract class C : A
    {
        public abstract new void PrintFriends();        //使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现
    }