C# 二十七、虚成员virtual+this+base+new

虚成员

关键字：重写父类中的成员，用virtual修饰；子类中对应override修饰。

注意：   

1、字段不能是虚拟的，只有方法、属性、事件和索引器才可以是虚拟的；   

2、如果在子类重写父类的虚方法中，用base“.”调用父类虚方法，可以续写此方法；

3、无论在子类和最初声明虚拟成员的类之间已声明多少个类，虚拟成员都将永远为虚拟成员；

4、如果类A声明了一个虚拟成员，类B从类A派生，类C从类B派生 则类C继承该虚拟成员，并且可以选择重写它，而不管类B是否为该成员声明了重写。

5、派生类可以通过将重写声明为sealed来停止虚拟继承。

代码示例：

    class Father
    {
        public virtual void Function()
        {
            Console.WriteLine("Father");
        }
    }

    class SonA:Father
    {
        public override void Function()
        {
            Console.WriteLine("SonA");
        }
    }

    class SonB:Father
    {
        public override void Function()
        {
            Console.WriteLine("SonB");
        }
    }

    class Gson:SonA
    {
        public override void Function()
        {
            Console.WriteLine("Gson");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Father father = new Father();
            SonA sonA = new SonA();
            SonB sonB = new SonB();
            Gson gson = new Gson();

            father.Function();
            sonA.Function();
            sonB.Function();
            gson.Function();

            Console.ReadKey();
        }
    }

--->
Father
SonA
SonB
Gson

this

引用类的当前实例。

代码示例：

    class Class1
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

       public Class1(string _name,int _age)
        {
            this._name = _name;
            this._age = _age;
        }
    }

    class Program
    {        
        static void Main(string[] args)
        {
            Class1 class1 = new Class1("jpf",28);
            Console.WriteLine(class1.Name);
            Console.WriteLine(class1.Age);

            Console.ReadKey();
        }
    }

--->
jpf
28

base

代表基类，使用base可以调用基类的构造函数、属性和方法等。

如果没有在子类中显示声明调用父类的构造函数，会默认调用父类中的无参构造函数。

代码示例：

    class Class1
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public Class1(string _name, int _age)
        {
            this._name = _name;
            this._age = _age;
        }

        public virtual void Function()
        {
            Console.WriteLine(1);
        }
    }

    class Class2:Class1
    {
        public override void Function()
        {
            base.Function();
            Console.WriteLine(2);
        }

        public Class2(string _name, int _age) : base(_name, _age)
        {

        }
    }

    class Program
    {        
        static void Main(string[] args)
        {
            Class1 class1 = new Class1("jpfa",24);
            Console.WriteLine("姓名：{0}，年龄：{1}",class1.Name,class1.Age);
            class1.Function();

            Class2 class2 = new Class2("jpfb", 25);
            Console.WriteLine("姓名：{0}，年龄：{1}", class2.Name, class2.Age);
            class2.Function();

            Console.ReadKey();
        }
    }

--->
姓名：jpfa，年龄：24
1
姓名：jpfb，年龄：25
1
2

静态成员方法中不能使用base与this关键字。

new

子类中重写父类中继承过来的某个方法，但不是把父类的方法替换掉，而是隐藏起来，要用关键字new。

隐藏方法调用：如果使用子类声明的对象，会调用子类的方法；如果使用父类声明的对象，会调用父类的方法。

代码示例：

    class Class1
    {
        public void Function()
        {
            Console.WriteLine(1);
        }
    }

    class Class2:Class1
    {
        public new void Function()
        {
            Console.WriteLine(2);
        }
    }

    class Program
    {        
        static void Main(string[] args)
        {
            Class1 class1 = new Class1();
            class1.Function();

            Class2 class2 = new Class2();
            class2.Function();

            Class1 class3 = new Class2();
            class3.Function();


            Console.ReadKey();
        }
    }

--->
1
2
1