前述C#承袭

简介

接轨(封装、多态)是面向对象编制程序3大特征之1,承袭的切磋就是扬弃代码的冗余,完结越来越好的重用性。

持续从字面上精晓,无外乎让人想到某人承袭某人的一些事物,3个给2个拿。那些语义在生活中,就如

家门三番五次资金财产,曾外祖父将财产承接给男女,儿女在将财产承接给子孙,有个别东西得以持续有些的东西只持续给

某人。映射到编程个中,其思想也轮廓如此。


 由此演示引出承接的效应

在代码中定义个多个类:Cat猫、Dog狗、Cattle牛。

图片 1

从类图上能够看来郎窑红标志区域,三个类的概念出现了大批量的冗余(字段、属性、方法),那么在编辑代码时就能够油然则生大量的再一次代码。

试想一下,随着专业职能的恢弘,或然会师世越多类,那么冗余(重复的代码)会越来越多。举例现身雷同会导致冗余的类:

Pig猪、Panda华熊、Sheep羊……等等。那个类同样会有同样的表征:名称、性别、年龄、奔跑(字段、属性、方法)。


 怎么着减轻此类冗余难题 ——
使用持续

接轨的思虑:

当大家定义了四个类,那四个类都存在重新的成员(共性)。我们能够将那么些再度的积极分子单独的领到封装到二个类中,作为这一个具有一样特征类的父类。

将此思量作用于上述的两个类

领到共性:可以直观看出重复的全部共性的连串有:一.字段和总体性(年龄、姓名、性别)、2.艺术(奔跑)。

打包到一个类:何以定义这几个类?Cat猫、Dog狗、Cattle牛有家喻户晓共同的性状,正是他俩都以动物,故可以抽象概念一个Animal动物类。

图片 2

 

怎样在代码中落到实处持续

图片 3

    class Animal
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        private string gender;
        public string Gender
        {
            get { return gender; }
            set { gender = value; }
        }

        private int age;
        public int Age
        {
            get { return age; }
            set { age = value; }
        }

        public void Run()
        {
            Console.WriteLine("奔跑。。。");
        }

    }

    class Cat:Animal
    {   
        public void CatchMouse()
        {
            Console.WriteLine("抓老鼠。。。");
        }
    }

    class Dog:Animal
    {
        public void GuardHouse()
        {
            Console.WriteLine("看家护院。。。");
        }
    }

    class Cattle:Animal
    {
        public void Plowland()
        {
            Console.WriteLine("耕田。。。");
        }
    }

经过三个简易的  :(冒号)完结了继续关系。

兑现接二连三后发出了四个剧中人物:1.子类(派生类)、2.父类(基类)

代码中子类删除父类提取的重复性成员。

 

贯彻连续后的关系如下图:

图片 4

完成持续后各类子类仅保留了自个儿故意的表征,大大裁减了冗余。

 

雄起雌伏后的力量

子类的共性成员都被父类提取了,那么子类要使用如何做?

子类承接父类后,将会隐式承继父类的具备成员,但不包涵构造函数。

在雄起雌伏后,访问其父类成员,会遭逢访问修饰符的限制。故,修饰为private的私家成员不会造访到。

 

承袭的特点

一.承接的单根性:

  叁个子类只好有一个父类,就好比1位只有三个阿爸。

二.一连的传递性:  

   譬如, ClassC 派生自 ClassB,并且 ClassB 派生自 ClassA,则 ClassC
会承接在 ClassB 和 ClassA 中声称的积极分子。

次第顺序能够不停向上取。

图例:

图片 5


 雄起雌伏被后的隐衷 ——
子类和父类的构造函数(难点)

给父类编写了多个构造函数,示例代码如下:

 1     class Animal
 2     {
 3         public Animal(string name,string gender,int age)
 4         {
 5             this.Name = name;
 6             this.Gender = gender;
 7             this.Age = age;
 8         }
 9 
10         private string name;
11         public string Name
12         {
13             get { return name; }
14             set { name = value; }
15         }
16 
17         private string gender;
18         public string Gender
19         {
20             get { return gender; }
21             set { gender = value; }
22         }
23         
24         private int age;
25         public int Age
26         {
27             get { return age; }
28             set { age = value; }
29         }
30         
31         public void Run()
32         {
33             Console.WriteLine("奔跑。。。");
34         }
35 
36         private void ri()
37         { }
38 
39     }
40 
41     class Cat:Animal
42     {   
43         public void CatchMouse()
44         {
45             Console.WriteLine("抓老鼠。。。");
46         }
47     }
48 
49     class Dog:Animal
50     {
51         public void GuardHouse()
52         {
53             Console.WriteLine("看家护院。。。");
54         }
55     }
56 
57     class Cattle:Animal
58     {
59         public void Plowland()
60         {
61             Console.WriteLine("耕田。。。");
62         }
63     }

 

品尝运维:

图片 6

缘何会提醒报那些错误?意思说父类无法未有贰个无参的构造函数。

学过构造函数的应该都会理解,类在尚未点名别的构造函数的情事下,程序暗中认可会指派3个无参的构造函数。

上述的例证由于大家手动增加的丰硕构造函数,默许的构造函数就被排除掉了。

在一时不知底彻头彻尾的经过的气象下,大家品尝补全那么些无参的构造函数,在开始展览转移代码,此时编译通过未有报错。

 

基于此特征我们能够揣摸子类和父类的构造函数一定有关系,但毫无疑问不是两次三番关系

 图片 7

尝试调用刚刚定义的父类无参构造函数,在调用列表并未呈现,只展现了类自个儿的2个无参构造函数。

证实了子类无法再三再四父类的构造函数。

 

透过调节和测试代码监视子类实例化对象的长河,看它到底和父类的构造函数爆发了何等。

透过调整开掘在创设子类对象时的代码施行逻辑如下:

图片 8

子类会首先去暗中同意试行父类的无参构造函数,然后在实践自身的构造函数

那条结论就很好的解说了,为啥在上述例子为何会出现的错误。但是子类又为何要先去推行父类的构造函数?

解释:

因为子类承接了父类的积极分子,那壹项描述只可以表明子类具有的职责,并不意味子类去实行了。

在标准上要利用类的积极分子,必须求通过类的实例对象去调用。所以子类要调用到父类的分子,就务须去通过调用

父类的构造函数,在子类的中间创建2个父类的靶子,以便自个儿去调用父类的积极分子。

 

总结:

子类始终要选拔父类的3个构造函数在投机内部创制三个父类对象,为了调用父类的分子。

子类私下认可调用父类的无参构造函数,所以在浮现编写叁个有参构造函数时形成父类未有了无参构造函数,从而编写翻译出错。


 在子类中选用显示调用父类构造函数

 图片 9

作用1:

加强代码重用性,子类没有供给在类中定义,直接使用父类的。

作用2:

上述例子讲过子类在实例化对象时会调用父类的暗许无参构造函数,因为子类的指标正是经过父类构造函数创制二个对象。

透过如此展现的调用,那么在父类有未有无参构造函数都不妨关联了。


子类中存在和父类中平等的分子

示例:

图片 10

基于VS给我们提醒的新闻,大家得以看出,当代码中设有子类的成员和父类的成员1致的时候,子类的分子将父类的分子隐藏了。

躲藏过后子类将不可能访问到父类的积极分子。如若是刻意为之,大家能够利用new
关键字显得的印证,从而加强可读性。

指定new关键字:

 图片 11

此刻唤醒的波浪线已排除。


 别的注意点

在C#中,全部的类都一向或直接的继续自object类(当我们定义三个类的时候,假使未有给该类钦定传承一个类,那么这些类就继续了object类)。

 

相关文章