C#基础笔记五（继承、封装、多态）

面向对象的三大基本特征：继承、封装、多态

概念

继承

继承是面向对象程序设计中最重要的概念之一.

继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了 属于（IS-A） 关系。例如，哺乳动物 属于（IS-A） 动物，狗 属于（IS-A） 哺乳动物，因此狗 属于（IS-A） 动物。

封装

即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；

将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。
多态就是同一个接口，使用不同的实例而执行不同操作

概念完了，接下来是使用

//继承
       static void Main(string[] args)
        {
            MyClassB myClassB = new MyClassB();
            //调用从父类继承来的方法   结果 打印A
            myClassB.MyToString();
            //调用从自己的方法   结果 打印B
            myClassB.MyToString_B();
            Console.ReadKey();
        }
        //父类
        class MyClassA
        {
            public  void MyToString()
            {
                Console.WriteLine("打印A");
            }
        }
        //继承父类
        class MyClassB : MyClassA
        {
        		//定义自己的方法
            public void MyToString_B()
            {
                Console.WriteLine("打印B");
            }
        }

继承并重写父类方法

       static void Main(string[] args)
        {
            MyClassB myClassB = new MyClassB();
            myClassB.MyToString();//结果： 打印B
            Console.ReadKey();
        }
        class MyClassA
        {
        	//只有被virtual修饰的方法才能被子类重写
            public virtual void MyToString()
            {
                Console.WriteLine("打印A");
            }
        }
        class MyClassB : MyClassA
        {
            public override void MyToString()
            {
                Console.WriteLine("打印B");
            }

        }

通过继承重写实现多态

       static void Main(string[] args)
        {
            Polymorphism.GetMyClass(MyClassType.MyClass).MyToString();
            Polymorphism.GetMyClass(MyClassType.MyClassB).MyToString();
            Polymorphism.GetMyClass(MyClassType.MyClassC).MyToString();
            Console.ReadKey();
        }
        /// <summary>
        /// 定义中间类实现多态选择
        /// </summary>
        static class Polymorphism
        {
            public static MyClass GetMyClass(MyClassType classType)
            {
                switch (classType)
                {
                    case MyClassType.MyClass:
                        return new MyClass();
                    case MyClassType.MyClassB:
                        return new MyClassB();
                    case MyClassType.MyClassC:
                        return new MyClassC();
                }
                return null;
            }
        }

        //定义枚举
        enum MyClassType
        {
            MyClass,MyClassB,MyClassC
        }
        /// <summary>
        /// 基类
        /// </summary>
        class MyClass
        {
            public virtual void MyToString()
            {
                Console.WriteLine("打印A");
            }
        }
        /// <summary>
        /// 子类 继承基类
        /// </summary>
        class MyClassB : MyClass
        {
            public override void MyToString()
            {
                Console.WriteLine("打印B");
            }

        }
        /// <summary>
        /// 子类 继承基类
        /// </summary>
        class MyClassC : MyClass
        {
            public override void MyToString()
            {
                Console.WriteLine("打印C");
            }

        }

结果：

打印A
打印B
打印C

通过接口实现 实现多态

        static void Main(string[] args)
        {
            Polymorphism.GetMyClass(MyClassType.MyClass).MyToString();
            Polymorphism.GetMyClass(MyClassType.MyClassB).MyToString();
            Polymorphism.GetMyClass(MyClassType.MyClassC).MyToString();
            Console.ReadKey();
        }
        /// <summary>
        /// 定义中间类实现多态选择
        /// </summary>
        static class Polymorphism
        {
            public static IMyInterface GetMyClass(MyClassType classType)
            {
                switch (classType)
                {
                    case MyClassType.MyClass:
                        return new MyClass();
                    case MyClassType.MyClassB:
                        return new MyClassB();
                    case MyClassType.MyClassC:
                        return new MyClassC();
                }
                return null;
            }
        }
        /// <summary>
        /// 定义接口
        /// </summary>
        interface IMyInterface
        {
            /// <summary>
            /// 定义方法
            /// </summary>
            void MyToString();
        }
        //定义枚举
        enum MyClassType
        {
            MyClass,MyClassB,MyClassC
        }
        /// <summary>
        /// 接口实现类
        /// </summary>
        class MyClass:IMyInterface
        {
            public  void MyToString()
            {
                Console.WriteLine("打印A");
            }
        }
        /// <summary>
        /// 接口实现类
        /// </summary>
        class MyClassB : IMyInterface
        {
            public  void MyToString()
            {
                Console.WriteLine("打印B");
            }

        }
        /// <summary>
        /// 接口实现类
        /// </summary>
        class MyClassC : IMyInterface
        {
            public  void MyToString()
            {
                Console.WriteLine("打印C");
            }

        }

结果：

打印A
打印B
打印C