继承与派生

        封装，继承，多态是面向对象编程的三大特征。封装就是把客观事物封装成抽象的类，隐藏实时细节，使代码达到重用。

        继承现象：

                        与日常的事物也一样，面向对象的编程中，类与类之间可以存在这一定的关联。

                               继承是面向对象的一个重要的部分。继承使得程序员可以在一个已经存在的类A的基础上快速建立一个类B，而不是从头到尾的开始类B的全新定义。事实上我们只需要修改已有的类，就可以很方便的得到我们所需要的全新的类。

                               在机构化程序设计中，我们也可以在已有代码的基础上通过修改部分代码实现新的功能。面向对象程序设计中的继承是这种思路的进一步发展。

                               当我们在类A的基础上构建类B，称之为类B继承了类A，类A是类B的基类（Base Class，也叫父类），类B是类A的派生类（Derived Class，也叫子类）。

                               继承思路的一个重要特点就是，如果我们修改了基类，那么这些修改将自动被传递到其他派生类。这一特点极大的方便了我们的面向对象程序设计，能过有效提高软件项目的效率。

[访问修饰符] 派生类：基类名
{
       类的定义
}

                                   要实现类的继承，只需要在定义派生类的时候，在派生类类名后加上冒号，然后给出类的基类名

                              

 class Program
    {
        static void Main(string[] args)
        {
            Son son = new Son();
            son.x = 1;
            son.y = 5;
            son.FuncA();
            son.FuncB();
            Console.WriteLine("con.x={0},con.y={1}",son.x,son.y);
            Console.ReadKey();
        }
    }
    class Father
    {
        public int x;
        public void FuncA()
        {
            Console.WriteLine("这是类Father的方法成员FuncA（）");
        }
    }
    class Son : Father
    {
        public int y;
        public void FuncB()
        {
            Console.WriteLine("这是类Father的方法成员FuncB（）");
        }
    }

                                   程序输出结构：

                             

                              有上面的可以看出派生类Son继承了Father，可以调用类Father中定义的数据成员了跟方法FuncA()，还可以自己定义新的数据类型y跟方法FuncB()；

       隐形的基类成员：

                       当派生类从基类继承时，不一定希望派生类继承基类的全部成员，这是需要对基类的每个成员都进行剂型控制，我们使用不同访问修饰符表明是否允许基类成员被派生类继承。

                              基本原则如下：

                                                      如果基类成员使用public修饰符，则该成员能够被派生类继承，且类定义之外能访问。

                                                      如果基类成员使用protected修饰符，则该成员能够被派生类继承，但不能在类定义之外访问。

                                                      如果基类成员使用private修饰符，则该成员不能被派生类继承，且不能在类定义之外访问。

       派生类的构造方法：

                        继承需要解决的另一个问题就是构造函数的问题，虽然基类的构造函数通常是public的，但是派生类并不继承基类的构造函数。就是派生类有自己的构造函数，如果成员是从基类继承来的，则沿继承关系向上，根据需要自动调用基类的构造函数的相关部分初始化成员。如果派生类只是简单继承基类构造函数的全部内容，则有可能出现这种情况，基类存在一个private成员，该成员未被派生类继承，但派生类的构造函数在继承自基类，其中存在语句要对private成员进行初始化，这意味着在派生类中，构造函数要初始化在派生类中不存在的成员。

          TIPS：   上边的代码，基类和派生类都是用了自动生成的构造函数

          

class Program
    {
        static void Main(string[] args)
        {
            Son son = new Son(10,20);
         
            Console.WriteLine("con.x={0},con.y={1}",son.x,son.y);
            Console.ReadKey();
        }
    }
    class Father
    {
        public int x;
        public Father(int a)
        {
            x = a;
        }
    }
    class Son : Father
    {
        public int y;
        public Son(int a,int b):base(a)
        {
            y = b;
        }
    }

                程序输出结果为：

                  

                 构造函数处理的基本原则与前面相同，但是需要注意，派生类的构造函数函数头如下：

 public Son(int a,int b):base(a)

                   在构造函数参数列表后增加冒号，然后使用base(a)将派生类构造函数的第一个参数a传递给基类的构造函数。这是因为基类中不存在无参数的构造函数，基类构造函数需要一个整型参数。

                在处理继承过程中的构造函数时，如果需要调用基类的构造函数，且基类构造函数有参数，则必须在定义派生类构造函数时向基类构造函数传递参数，传递参数类型和个数应与基类构造函数一致。