C#类中方法的执行顺序是什么

2024-04-02 19:04:59 384人浏览八月长安

摘要

有些中级开发小伙伴还是搞不太明白在继承父类以及不同场景实例化的情况下，父类和子类的各种方法的执行顺序到底是什么，下面通过场景的举例来重新认识下方法的执行顺序： (下面内容涉及到了C#

有些中级开发小伙伴还是搞不太明白在继承父类以及不同场景实例化的情况下，父类和子类的各种方法的执行顺序到底是什么，下面通过场景的举例来重新认识下方法的执行顺序：

(下面内容涉及到了C#中的继承，构造函数，虚方法，虚方法的重写，new关键字等知识点)

场景一

有子类继承，但是只实例化父类：只执行A对象，输出A对象的信息


class A
{     
    public A() => Console.WriteLine("A的构造函数");    
    public virtual void Fun() => Console.WriteLine("A的方法");    
}
class B : A
{
    public B() => Console.WriteLine("B的构造函数");    
    public void Fun() => Console.WriteLine("B的方法");    
}
class Program
{
    static void Main(string[] args)
    {
        A a = new A();
        a.Fun();
        Console.ReadLine();
    }
}

上述Main方法中在new A对象时，程序首先进入class A中，执行class A的构造函数A()，然后执行class A中的Fun()方法，故运行结果为：

场景二

实例化子类，子类和父类的构造函数的执行顺序：当执行B对象时，因为继承A对象，所以首先执行基类A的构造函数


class A
{   
    public A() => Console.WriteLine("A的构造函数");    
    public virtual void Fun()=>  Console.WriteLine("A的方法");    
}
class B : A
{
    public B() => Console.WriteLine("B的构造函数");   
    public void Fun() => Console.WriteLine("B的方法");    
}
class Program
{
    static void Main(string[] args)
    {
        B b = new B(); 
        b.Fun();
        Console.ReadKey();
    }
}

上述Main方法中在new B对象时，由于B继承A，先执行父类的构造函数，所以先执行A中的构造函数A()，然后在执行B中的构造函数B()，故运行结果为：

场景三

父类有虚方法，子类没有使用（override）关键字重写父类方法的时候，使用的是new关键字时：


class A
{   
    public A()=>  Console.WriteLine("A的构造函数");   
    public virtual void Fun() => Console.WriteLine("A的方法");
    
}
class B : A
{
    public B() => Console.WriteLine("B的构造函数");    
    //不写new时,该方法会抛出警告，但不是错误
    public new void Fun()=> Console.WriteLine("B的方法");    
}
class Program
{
    static void Main(string[] args)
    {
        A a = new B();
        a.Fun();
        Console.ReadKey();
    }
}

上述Main方法中先new B对象，先执行A中的构造函数A()，然后在执行B中的构造函数B()，最后调用class A的Fun()方法(没有重写父类方法)，故运行结果为：

场景四

父类有虚方法，当子类重写了（override）父类的方法时：


class A
{
    public A()=> Console.WriteLine("A的构造函数");    
    public virtual void Fun() =>  Console.WriteLine("A的方法");    
}
class B : A
{
    public B()=> Console.WriteLine("B的构造函数");    
    public override void Fun()=> Console.WriteLine("B的方法");    
}
static void Main(string[] args)
{
    A a = new B();
    a.Fun();
    Console.ReadKey();
}

上述Main方法同样是先new B对象，先执行A中的构造函数A()，然后在执行B中的构造函数B()，但是子方法中使用了override关键字“覆盖”，使得子类中方法覆盖了父类中的方法，无法再访问父类中原始方法。（要重写方法，父类方法必须有virtual关键字），所以其运行结果为：

场景五

基类是接口层，多重继承时：


interface I
{
    void Fun();
}
class A : I
{
    public A() => Console.WriteLine("A的构造函数");
    public virtual void Fun() => Console.WriteLine("A的方法");
}
class B : A
{
    public B() => Console.WriteLine("B的构造函数");
    //不写new时,该方法会抛出警告
    public new void Fun() =>Console.WriteLine("B的方法");   
}
static void Main(string[] args)
{
    B b = new B();
    b.Fun();
    ((A)b).Fun();
    ((I)b).Fun();
    Console.ReadKey();
}

打印结果：

场景六

当多重继承，子类重写override父类方法时：


interface I
{
    void Fun();
}

class A : I
{
    public A() => Console.WriteLine("A的构造函数");
    public virtual void Fun() => Console.WriteLine("A的方法");

}
class B : A
{
    public B() => Console.WriteLine("B的构造函数");    
    public override void Fun() =>Console.WriteLine("B的方法");   
}
static void Main(string[] args)
{
    B b = new B();
    b.Fun();
    ((A)b).Fun();
    ((I)b).Fun();
    Console.ReadKey();
}

打印结果：(对比场景5)

场景七

使用new重写父类方法，同时让每个子类都继承接口：


interface I
{
    void Fun();
}

class A : I
{
    public A() => Console.WriteLine("A的构造函数");
    public virtual void Fun() => Console.WriteLine("A的方法");

}
class B : A, I
{
    public B() => Console.WriteLine("B的构造函数");
    //不写new时,该方法会抛出警告
    public new void Fun() => Console.WriteLine("B的方法");
}
static void Main(string[] args)
{
    B b = new B();
    b.Fun();
    ((A)b).Fun();
    ((I)b).Fun();
    Console.ReadKey();
}

打印结果：