C#——面向对象——继承——虚方法和多态

一个设计原则：依赖倒置原则

什么是依赖倒置原则呢？

就是，程序设计要依赖于抽象类，而不是依赖于具体类。倒置倒置就是要倒退到源头，倒退到抽象类那儿。

坚持依赖倒置原则的好处是什么呢？（是一种解耦的方式）

1.增大程序的扩展性

2.提高开发效率

为什么基类引用能指向派生类呢？

因为派生类中包含有基类部分和派生类部分，指向派生类的基类引用只能访问派生类中的基类部分。

派生类中隐藏方法是否生效取决于基类引用是否指向派生类对象，如果指向派生类对象，那么隐藏方法不生效。

基类引用指向派生类有什么好处呢？

可以实现所有的基类都放在同一个容器中。

为什么所有的基类都要放在同一个容器（比如数组）中？

为了提高效率。

namespace xufangfa
{
    public class Pet
    {
        public string Name;
        virtual public void PrintName()
        {
            Console.WriteLine("Pet's name is" + Name);
        }
        virtual public void Speak()
        {
            Console.WriteLine(Name + "is speaking");
        }
    }
    public class Dog : Pet
    {
        override public void PrintName()
        {
            Console.WriteLine("宠物的名字是" + Name);
        }
        override public void Speak()
        {
            Console.WriteLine(Name + "wangwang");
        }
    }
    public class Cat : Pet
    {
        override public void PrintName()
        {
            Console.WriteLine("宠物的名字是" + Name);
        }
        override public void Speak()
        {
            Console.WriteLine(Name + "miaomiao");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Pet dog = new Dog();
            dog.Name = "黑啤";
            dog.PrintName();
            dog.Speak();

            Pet cat = new Cat();
            cat.Name = "TOM";
            cat.PrintName();
            cat.Speak();
        }
    }
}

namespace xufangfa
{
    public class Pet
    {
        public string Name;
        virtual 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;
        }
        override public void PrintName()
        {
            Console.WriteLine("宠物的名字是" + Name);
        }
        override public void Speak()
        {
            Console.WriteLine(Name + "wangwang");
        }
    }
    public class Cat : Pet
    { 
        第一步：加构造方法
  public Cat(string name) { Name = name; } override public void PrintName() { Console.WriteLine("宠物的名字是" + Name); } override public void Speak() { Console.WriteLine(Name + "miaomiao"); } } class
 Program { static void Main(string[] args) {

第二步：用基类引用创建数组，并创建派生类对象

 Pet[] pets = new Pet[] {new Dog("黑啤"),new Cat("TOM")};

第三步：用for循环调方法

 for(int i = 0; i < pets.Length; i++) { pets[i].Speak(); pets[i].PrintName(); } } }}








怎样实现子类的差异性？
因为基类引用指向子类对象了，所以派生类中new的对象就无效了。
为了实现派生类的差异化，就引入新的东西了——
1虚方法（virtual修饰的方法）
基类中的虚方法在派生类中使用override进行重写。
2多态（是一个过程）
通过指向派生类的基类引用，调用虚函数，会根据引用所指向派生类的实际类型，调用派生类中的同名重写函数，便是多态。







虚方法的注意事项
1基类方法不能是private
2不能重写非虚方法，如静态方法
3能被virtual（基类）和override（派生类）修饰的有：方法、属性、索引器、事件