C# 继承、虚方法、方法重载和多态

继承：继承属于单继承，只能继承一个父类。

继承的一个结果是派生于基类的子类在方法和属性上有一定的重叠。

继承只能够同时继承与一个基类；可以同时继承一个基类和多个接口，但是基类必须放在第一个。(注：C#没有多继承，如果非得想用多继承形式，只能使用接口)

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

namespace ConsoleApplication1
{
    class Program
    {
        public class Aminal
        {
            public string Name;  // 定义宠物的名字
            public void PrintName()
            {
                Console.WriteLine("宠物的名字:" + Name);
            }
        }
        // Dog继承Aminal类
        public class Dog : Aminal
        {
            //
        }
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            dog.Name = "your name";
            dog.PrintName();
        }
    }
}

 如果需要重定义方法可以使用new关键字来隐藏父类(不用new关键字也可以，不过如果是用的是vs文本编译器会有警告)

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

namespace ConsoleApplication1
{
    class Program
    {
        public class Aminal
        {
            public string Name;  // 定义宠物的名字
            public void PrintName()
            {
                Console.WriteLine("宠物的名字:" + Name);
            }
        }
        // Dog继承Aminal类
        public class Dog : Aminal
        {
            // 隐藏父类的PrintName
            new public void PrintName()
            {
                Console.WriteLine("名字为:" + Name);
            }
        }
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            dog.Name = "your name";
            dog.PrintName();
            // 访问父类的PrintName方法
            ((Aminal)dog).PrintName();
            // 注：除了这种方法，如果想在Dog函数题里面访问父类可以使用base.<方法名>来访问
        }
    }
}

虚方法： 

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

namespace ConsoleApplication1
{
    class Program
    {
        public class Aminal
        {
            public Aminal(string name)
            {
                _name = name;
            }
            protected string _name;  // 定义宠物的名字
            // 定义虚方法
            virtual public void PrintName()
            {
                Console.WriteLine("宠物的名字:" + _name);
            }
        }
        // Dog继承Aminal类
        public class Dog : Aminal
        {
            public Dog(string name) : base(name)
            {
                // 调用父类构造函数
            }
            // 重写
            public override void PrintName()
            {
                // base.PrintName(); // 这个是调用父类的虚方法
                Console.WriteLine("这是重写方法,{0}", _name);
            }
        }
        // cat 方法
        public class Cat : Aminal
        {
            public Cat(string name) : base(name)
            {
                // 调用父类构造函数
            }
            public override void PrintName()
            {
                Console.WriteLine("阿猫叫:" + _name);
            }
        }
        static void Main(string[] args)
        {
            // 使用继承会显示或者隐式调用父类构造函数
            Aminal dog = new Dog("your name");
            dog.PrintName();
            Aminal cat = new Cat("your name2");
            cat.PrintName();
        }
    }
}

Public：公有属性，在类外可以随便访问。private：私有属性，在类外既不能够访问，也不能够修改。

Class1.cs

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

namespace ConsoleApplication1
{
    class Class1
    {
        // 定义私有属性
        private string _name;
        private int _age;
        public string Name
        {
            // 包含两个访问器
            get { return _name; }
            set { _name = value; }
        }
        //  使用快捷键Ctrl+R+E产生的接口
        public int Age
        {
            get
            {
                return _age;
            }

            set
            {
                // 对年龄进行判断
                if(value>10&&value<23)
                    _age = value;
            }
        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用类
            Class1 myname = new Class1();
            // 值得注意的是，单引号只能一个字符，双引号可以多个字符
            myname.Name = "namejr";
            myname.Age = 15;
            Console.WriteLine("我的名字是:" + myname.Name + "，年龄:" + myname.Age);
            Console.ReadKey();
        }
    }
}

什么是方法重载？

方法重载就是在同一个类中使用相同的函数名，但是使用的参数类型或者数量不一样。

值得注意的是：如果写了重载函数，原来的默认的重载函数(默认的函数按理说称为构造方法才会更合理，当然如果是重新自定义(不同于类名)的称为构造方法就不合适了)会被覆盖，如果还需要默认的无参重载函数，请务必重新写代码。

具体实例如下：

Class.1cs

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

namespace ConsoleApplication1
{
    class Class1
    {
        // 定义Sugar方法
        // 第一个使用string类型
        public void Sugar(string tang)
        {
            if (tang == "榴莲糖")
                Console.WriteLine("我最喜欢吃了!!!");
            else
                Console.WriteLine("滚你丫的!!!");
        }
        // 第二个使用int类型
        public void Sugar(int count)
        {
            if (count > 3)
                Console.WriteLine("吃糖太多对牙齿不好!!!");
            else
                Console.WriteLine("榴莲糖好好吃的呢!!!");
        }
        // 第三个数量不同
        public void Sugar(string tang, int count)
        {
            if (tang == "榴莲糖")
                Console.WriteLine("是不是很好吃呀，我还有哦!!!");
            else if (tang != "榴莲糖" && count < 3)
                Console.WriteLine("这个糖是不是不好吃，我有榴莲糖哦!!!");
            else
                Console.WriteLine("你吃糖太多了，不给了,除非榴莲糖.");
        }
    }
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用类
            Class1 myname = new Class1();
            myname.Sugar("榴莲糖");  // 调用第一个方法
            myname.Sugar(1);  // 使用第二个方法
            myname.Sugar("牛奶糖", 2);
            myname.Sugar("榴莲糖", 10);
            myname.Sugar("大白兔奶糖", 12);
        }
    }
}

多态：

多态性相对于继承可以更进一步，就是派生类型的变量可以赋值给基本类型的变量。

例如：父类:Aminal、子类Dog

Aminal adog = new Dog();

adog.shout();  // 调用的是Dog.shout方法