C#学习（二）——构造函数、隐藏方法、虚方法

     C#也是面向对象编程的语言，也包含继承、封装、多态。

     C#中的继承语法结构如下：

class ChildClass:ParentClass
{
    ...
}

     C#中Object类是所有类的共同基类；单继承。

     编写一个继承demo：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExtendsClassTest
{
    public class Pet
    {
        public string name;
        public void printName()
        {
            Console.WriteLine("Pet's name is " + name);
        }
    }

    public class Dog:Pet
    {
    }
    class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            dog.name = "tom";
            dog.printName();
        }
    }
}

      c#中隐藏方法，目前我理解为相当于Java中方法的重写，代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExtendsClassTest
{
    public class Pet
    {
        public string name;
        public void printName()
        {
            Console.WriteLine("Pet's name is " + name);
        }
    }

    public class Dog:Pet
    {
        new public void printName()//最好加new关键字，否则会出现警告
        {
            Console.WriteLine("宠物的名字是 " + name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            dog.name = "tom";
            dog.printName();
        }
    }
}

     虚方法：声明为virtual的方法就是虚方法。基类的虚方法可以在派生类中使用override进行重写。个人目前理解为Java中的抽象方法,只是比抽象方法更低一点。

     多态：通过指向派生类的基类引用，调用虚函数，会根据引用所指向派生类的实际类型，调用派生类中的同名重写函数，便是多态。

     下面是虚方法实例代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExtendsClassTest
{
    public class Pet
    {
        public string name;
        public void printName()
        {
            Console.WriteLine("Pet's name is " + name);
        }
        virtual public void Speak()
        {
            Console.WriteLine(name + " is speaking");
        }
    }

    public class Dog:Pet
    {
        public Dog(string Name)
        {
            name = Name;
        }
        new public void printName()//最好加new关键字，否则会出现警告
        {
            Console.WriteLine("宠物的名字是 " + name);
        }
        override public void Speak()
        {
            Console.WriteLine(name + " is speaking:" + "wangwang");
        }
    }
    public class Cat:Pet
    {
        public Cat(string Name)
        {
            name = Name;
        }
        new public void printName()//最好加new关键字，否则会出现警告
        {
            Console.WriteLine("宠物的名字是 " + name);
        }
        override public void Speak()
        {
            Console.WriteLine(name + " is speaking:" + "miaomiao);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Pet[] pets = new Pet[]{new Dog("jack"),new Cat("Tom")};
            for(int i = 0; i < pets.Length;i++)
            {
                pets[i].Speak();
            }
        }
    }
}

     虚方法中一些知识点：重写虚方法必须具有相同的可访问性，且基类方法不能是private；不能重写static方法或者非虚方法；方法、属性、索引器、事件都可以声明为virtual或override。

     构造函数，C#中派生类调用基类的构造函数有显式和隐式，以下为显式和隐式语法：

public class MyBase
{
    ...
}

public class MyDerived:MyBase
{
    public MyDerived()//隐式调用基类的构造函数
    {
    }
    ...
}

public class MyDerived:MyBase
{
    public MyDerived():base()//显式调用基类的构造函数
    {
    }
    ...
}

     可以调用当前类的其它构造函数，代码语法如下：

public MyDerived(int age,string name):this(name)
{...}
public MyDerived(string name)
{...}

这里来使用显式重构一下之前虚方法的实例代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExtendsClassTest
{
    public class Pet
    {
        protected string _name;
        public Pet(string name)
        {
            _name = name;
        }
        public void printName()
        {
            Console.WriteLine("Pet's name is " + name);
        }
        virtual public void Speak()
        {
            Console.WriteLine(name + " is speaking");
        }
    }

    public class Dog:Pet
    {
        public Dog(string name):base(name)
        {
            
        }
        new public void printName()//最好加new关键字，否则会出现警告
        {
            Console.WriteLine("宠物的名字是 " + name);
        }
        override public void Speak()
        {
            Console.WriteLine(name + " is speaking:" + "wangwang");
        }
    }
    public class Cat:Pet
    {
        public Cat(string name):base(name)
        {
            
        }
        new public void printName()//最好加new关键字，否则会出现警告
        {
            Console.WriteLine("宠物的名字是 " + name);
        }
        override public void Speak()
        {
            Console.WriteLine(name + " is speaking:" + "miaomiao);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Pet[] pets = new Pet[]{new Dog("jack"),new Cat("Tom")};
            for(int i = 0; i < pets.Length;i++)
            {
                pets[i].Speak();
            }
        }
    }
}

     抽象方法，抽象方法比virtual更进一步，虚方法可以有函数体，但是抽象方法不能有函数体，只能在派生类中重写方法，关键字是abstract。

     抽象类，含有abstract的类就是抽象类，抽象类中的抽象方法在派生类中需要用override关键字。