C#多态;父类引用指向子类对象;new和override的区别;new、abstract、virtual、override，sealed关键字区别和使用代码示例;c#类的初始化顺序

关于父类引用指向子类对象

例如: 有以下2个类

public  class  Father
        {
            public int age = 70;                       
            public static string name = "父亲";        
        }

        public class Son : Father
        {
            public int age = 30;                    
            public static string name = "儿子";    
            
        }

Father f=new Son();

这种用法叫做“父类引用指向子类对象,或者叫“父类指针指向子类对象”，指的是定义一个父类的引用，而它实际指向的是子类创建的对象。

好处是什么?

下面做几个测试,

第一种  ,父类变量,调用 属性  例如下面的  f.age   是一个父类的变量调用了属性,问题是这里的属性是父类的?还是子类的? 答案是父类的属性

class Program
    {
        static void Main(string[] args)
        {
            Father f=new Son();
            Console.WriteLine(f.age);   //这里输出的是父类的年龄?还是子类的年龄? 答案是父亲的年龄 70 ,因为这里的f是个父类类型,所以是调用父类的属性

            Son s = f as Son;
            Console.WriteLine(s.age);  //这里输出的父类的年龄?还是子类的年龄? 答案是子类的年龄 30

            Console.ReadKey();
        }

        public  class  Father
        {
            public int age = 70;                      //第4执行
            public static string name = "父亲";       //第3执行
        }

        public class Son : Father
        {
            public int age = 30;                    //第2执行
            public static string name = "儿子";    //第1执行
            
        }
    }

小结论(1): 当用父类的变量调用属性的时候,取决于声明的类型(“=”左边是什么类型),而不是后面实例化的类型

第二种 ,父类变量,调用 方法 (父类的方法和子类的方法  一模一样,子类并无重写)

public  class  Father
        {
            public int age = 70;                      //第4执行
            public static string name = "父亲";       //第3执行

            public void SayHi()
            {
                Console.WriteLine(string.Format("父亲说,年龄{0},名字是{1}",age,name));
            }

        }

        public class Son : Father
        {
            public int age = 30;                    //第2执行
            public static string name = "儿子";    //第1执行

            public void SayHi()
            {
                Console.WriteLine(string.Format("儿子说,年龄{0},名字是{1}", age, name));
            }
        }

 

static void Main(string[] args)
        {
            
            Father f = new Son();
            f.SayHi();   //这里调用的是父类的方法,因为f是父类,并且子类,压根就没有重写   父亲说,年龄是70,名字是父亲

            Son s = f as Son;
            s.SayHi();   //这里调用的是父类的方法?还是子类的方法?  答案是子类的方法,因为s是子类   儿子说,年龄是30,名字是儿子
            Console.ReadKey();
        }

小结论(2): 当子类和父类的方法完全相同时，调用的时候取决于声明的类型（“=”左边），而不是后面实例化的类型。

第三种 ,父类变量,调用 方法 (父类的方法和子类的方法 一模一样 ,但是父类的方法加 Virtual , 子类不重写)

小结论(3):如果父类有virtual虚方法,但是子类并没有重写的话,那么  同上面的小结论(2)一样,调用的时候,取决于声明的类型(“=”的左边),而不是实例化的类型

第四种 ,父类变量,调用 方法 (父类的方法和子类的方法 一模一样 ,但是父类的方法加 Virtual , 子类重写)

小结论(4):重写以后，调用哪个类的方法取决于实例化的类型（“=”右边）或者是转换后最终的类型

第五种 ,父类变量,调用 方法 (父类的方法和子类的方法 一模一样 ,但是父类的方法加 Virtual , 子类重写)

父类变量指向子类的实例,但是我们直接调用父类变量下的属性,会输出子类的属性?还是父类的属性?答案是父类的属性.

那如果再继续调用方法的话,是调用父类的方法?还是子类的方法?答案是,如果是虚方法,子类有重写,就调用子类的,子类没有重写,就调用父类的.

小结论(5) : 如果子类方法里面想调用父类的属性或者是方法,使用 base 关键字

 

结论:

1:当用父类的变量调用属性的时候,取决于声明的类型(“=”左边是什么类型),而不是后面实例化的类型

例如 输出 f.age 就是输出父类的属性 ,而不是子类的属性

2:当子类和父类的方法完全相同时，调用的时候取决于声明的类型（“=”左边），而不是后面实例化的类型。

也就是子类没有重写的时候. f.sayhi 就是调用的父类的sayhi ,而不是子类的sayhi

3 如果子类有重写(override)父类的方法,那么 父类变量调用方法的时候,就变成使用 子类的方法.

也就是子类有override的时候,f.sayhi 就是调用子类的sayhi

4:如果想在子类里面访问父类的属性或者是方法,使用 base 关键字

 

C#中new和override的区别;abstract

当父类里面有 virtual 方法的时候,子类可以使用 override 进行重写.  那么  f.sayhi  就变成调用子类的sayhi

不论父类的方法有没有virtual,子类都可以在同名的方法上加一个new表示这是子类自己的方法,那么父类的方法就会被隐藏起来, f.sayhi 就会变成 调用父类的sayhi,因为子类并没有override. 如果这个时候,把new去掉,效果也是一样的,f.sayhi 也是调用父类的sayhi, 判断是否调用子类的方法,就看子类是否有override重写.

//在C#中，override和new都会覆盖父类中的方法。那它们两者之前有什么区别呢？ //override是指“覆盖”，是指子类覆盖了父类的方法。子类的对象无法再访问父类中的该方法(当然了,在子类的方法中还是可以通过base访问到父类的方法的)。

//new是指“隐藏”，是指子类隐藏了父类的方法，当然，通过一定的转换，可以在子类的对象中访问父类的方法。

 

c#类的初始化顺序

子类的静态成员变量,子类的普通成员,父类的静态成员,父类的普通成员

namespace 类的初始化顺序
{
    class Program
    {
        static void Main(string[] args)
        {
            Father f=new Son();   
            Console.ReadKey();
        }

        public  class  Father
        {
                 public int age = 70;                            //第4执行
            public static string name = "父亲";       //第3执行
        }

        public class Son : Father
        {
                 public int age = 30;                         //第2执行
            public static string name = "儿子";    //第1执行
            
        }
    }
}

 

首次访问：(在此没有显示的写出类中的构造方法)
顺序：子类的静态字段==》子类静态构造==》子类非静态字段==》父类的静态字段==》父类的静态构造==》父类的非静态字段
==》父类的构造函数==》子类的构造函数
非首次访问：顺序是一样的，只不过少了中间静态字段和构造的过程
对于静态变量与静态构造函数而言, 无论对一个类创建多少个实例，它的静态成员都只有一个副本。 也就是说,静态变量与静态构造函数只初始化一次(在类第一次实例化时)