本身明白的Javascript继承的陆种办法,面向对象三大特点之1

简介

                                                                       
                                                                       
              20一柒年一月210日  于格Russ哥软件园  夜 贰1:4二

教授前要求了解的几点

继承

持续表示二个品种(子类)派生自(继承于)贰个基类型(父类),该项目将持有基类型的持有成员字段和函数(不包含构造函数和析构函数)。

注意:

  • 派生类继承基类的全体成员,不管是public、private、protected依然其它的,不管是静态的照旧非静态的;不过,即使派生类继承类基类全部的积极分子,基类却只得访问由public和protected修饰的成员(派生类继承了基类全体的字段,然则只可以访问基类中public和protected修饰的积极分子)

    1 class Person
    2 {
    3 private string name = “张三”;
    4 protected int age = 20;
    5 public bool gender = true;
    6
    7 public void ShowInfo_Person()
    8 {
    9 Console.WriteLine(this.name + “:” + this.age + “:” + this.gender);
    10 }
    11 }
    12
    13 class Chinese : Person
    14 {
    15 public void ShowInfo_Chinese()
    1陆 {
    一柒 Chinese chinese = new Chinese();
    1八 Console.WriteLine(chinese.age);
    1九 Console.WriteLine(chinese.gender);
    20 //Console.WriteLine(chinese.name);//由于基类中name用private修饰,所以在派生类中不恐怕访问
    二壹 }
    2二 }
    贰叁
    二四 class Program
    二5 {
    二6 static void Main(string[] args)
    27 {
    28 Chinese chinese = new Chinese();
    29 chinese.ShowInfo_Person();//输出结果:张3:20:True 此处通过派生类对象chinese能够调用基类中的ShowInfo_Person()方法,能够印证派生类也一连了private修饰的name字段
    30 Console.ReadKey();
    31 }
    3二 }

  • 派生类(子类)只可以有二个一贯基类(父类);可是后续是能够传递的,例如ClassB派生自ClassA,同时ClassC派生自ClassB,那么ClassC会继承ClassB和ClassA中声称的积极分子。

    1 class Animal
    2 {
    3 public void Method_Animal()
    4 {
    5 Console.WriteLine(“Animal:—————“);
    6 }
    7 }
    8
    9 class Dog : Animal
    10 {
    11 public void Method_Dog()
    12 {
    13 Console.WriteLine(“Dog:***“);
    14 }
    15 }
    16
    17 class ErHa : Dog
    18 {
    19 public void Method本身明白的Javascript继承的陆种办法,面向对象三大特点之1。_ErHa()
    20 {
    21 Console.WriteLine(“ErHa:……………”);
    22 }
    23 }
    24
    25 class Program
    26 {
    27 static void Main(string[] args)
    28 {
    29 ErHa eh = new ErHa();
    30 eh.Method_Animal();
    31 eh.Method_Dog();
    32 eh.Method_ErHa();
    33 Console.ReadKey();
    34 }
    35 }

  • C#不支持多重继承,派生类只好有3个直接基类,然而能够兑现两个接口,并由此落实八个接口达到多重继承的指标

    1 interface IAnimal
    2 {
    3 void Method_Animal();
    4 }
    5
    6 interface IDog
    7 {
    8 void Method_Dog();
    九 }
    拾 //达成多重继承
    11 class ErHa : IAnimal, IDog
    1二 {
    一3 public void Method_ErHa()
    14 {
    15 Console.WriteLine(“ErHa:……………”);
    16 }
    17
    18 public void Method_Animal()
    19 {
    20 Console.WriteLine(“Animal:**“);
    21 }
    22
    23 public void Method_Dog()
    24 {
    25 Console.WriteLine(“Dog:—————“);
    26 }
    27 }
    28
    29 class Program
    30 {
    31 static void Main(string[] args)
    32 {
    33 ErHa eh = new ErHa();
    34 eh.Method_Animal();
    35 eh.Method_Dog();
    36 eh.Method_ErHa();
    37 Console.ReadKey();
    38 }
    39 }

  • 布局不支持继承

  • 派生类是对基类的扩充,派生类能够对基类进行成员的增进、重写、覆盖操作

继承(封装、多态)是面向对象编制程序叁大特点之1,继承的挂念便是吐弃代码的冗余,完成更好的重用性。

     
 以前看过3个节目,个中有三个情节:2个小女孩对几本古文书籍熟读能背像《3字经》,《诗经》,《笠翁对韵》。主持人吃惊的他的老母,这么小让她接触文言文,小孩子不会觉得难而反感,为何以后还兴致勃勃。他母亲的答案里有一句话于今让我时刻不忘:“…小孩子的社会风气里从未难易概念的…”

  1. Javascript继承:继承机制并不曾鲜明规定,完全由开发者决定最合适的接轨方式
  2. 类的原型对象上的富有属性和方式都会被子类拥有
  3. this关键字:什么人调用那一个本性和章程this就指哪个人

  4. 对象冒充艺术贯彻持续(Object Masquerading)

构造函数

  • 派生类不恐怕继续基类的构造函数
  • 当调用派生类的构造函数时,暗许先调用基类的无参构造函数,当基类没有无参构造,须要派生类通过base关键字钦命要调用的基类构造函数

    一 class Person
    2 {
    3 public Person()
    四 {
    5 Console.WriteLine(“父类的无参构造函数被调用”);
    陆 }
    七 }

    9 class Student:Person
    十 {
    1一 public Student()
    12 {
    一三 Console.WriteLine(“子类的无参构造函数被调用”);
    1肆 }
    1五 }
    1六
    17 class Program
    18 {
    1九 static void Main(string[] args)
    20 {
    21 Student stu = new Student();
    22 Console.ReadKey();
    23 }
    24 }

 执行结果:

继续从字面上领悟,无外乎令人想到某人继承某人的一点事物,贰个给二个拿。这么些语义在生活中,就好像

       
是呀,一片白纸,你上什么样颜色,它就接受什么颜色。它没有啥去对待。就像是作者辈一般,没有接触过机器语言,汇编语言,甚至C语言,直接就是C#。全部大家超过55%人未有对C#至于直接面向对象思想方法出来而深感神奇的清醒。(后续待更)


亚洲必赢官网 1

 当基类中不存在无参的构造函数时,要求通过base关键字派生类内定其要调用的基类的构造函数

 1     class Person
 2     {
 3         public Person(string name)
 4         {
 5             Console.WriteLine(name);
 6         }
 7     }
 8 
 9     class Student : Person
10     {
11         public Student()
12         {
13             Console.WriteLine();
14         }
15     }
16 
17     class Program
18     {
19         static void Main(string[] args)
20         {
21             Student stu = new Student();
22             Console.ReadKey();
23         }
24     }

 以上代码执行时会出现以下错误:

家门延续资金财产,曾外祖父将财产继承给子女,儿女在将财产继承给后代,有个别东西得以持续有些的东西只持续给


  1. 指标冒充达成单继承

亚洲必赢官网 2

如果我们想要使派生类调用基类的有参构造函数,而不是无参构造函数,就能够在派生类中通过base为其要调用的基类构造函数

 1     class Person
 2     {
 3         public Person(string name)
 4         {
 5             Console.WriteLine("姓名:"+name);
 6         }
 7     }
 8 
 9     class Student : Person
10     {
11         public Student(string name, string num)
12             : base(name)
13         {
14             Console.WriteLine("学号:"+num);
15         }
16     }
17 
18     class Program
19     {
20         static void Main(string[] args)
21         {
22             Student stu = new Student("张三", "0002");
23             Console.ReadKey();
24         }
25     }

亚洲必赢官网,某人。映射到编程个中,其构思也大体如此。

(整理笔记)

亚洲必赢官网 3

接下去大家通过以下代码,驾驭一下子类对象的伊始化进程

 1     class Person
 2     {
 3         public string name = "默认值:张三";
 4         public string gender = "默认值:男";
 5         public Person(string name, string gender)
 6         {
 7             this.name = name;
 8             this.gender = gender;
 9         }
10     }
11 
12     class Student : Person
13     {
14         public string num = "默认值:0002";
15         public Student(string name, string gender, string num)
16             : base(name, gender)
17         {
18             this.num = num;
19         }
20     }
21 
22     class Program
23     {
24         static void Main(string[] args)
25         {
26             Student stu = new Student("李四", "女", "0004");
27             Console.WriteLine(stu.name);
28             Console.WriteLine(stu.gender);
29             Console.WriteLine(stu.num);
30             Console.ReadKey();
31         }
32     }

 当在Main方法中实例化Student的靶猴时,首先在内部存款和储蓄器中分配了空间,内部存款和储蓄器中的开端状态如下图:

亚洲必赢官网 4

 调用派生类的构造函数,首先会调用基类的构造函数,由于大家在派生类Student中通过base关键字钦点了派生类要调用的基类构造函数为public
Person(string name,string
gender),所以首先会用传入的参数替换掉基类中成员的私下认可值,执行到位后,内部存款和储蓄器中的意况如下:

亚洲必赢官网 5

 执行完钦定的基类构造函数后,执行派生类自个儿的构造函数,执行到位后,内部存款和储蓄器中的情形如下:

亚洲必赢官网 6

从那之后,派生类对象实例化达成。


面向对象编制程序:

function ClassA(sColor){
    this.name="Lily"
    this.color=sColor;
    this.sayColor=function () {
        console.log(this.color)
    }
}

function ClassB(sColor,sName) {
    //newMethod()之前定义同名属性和方法会被父类覆盖
    // this.name=sName;
    // this.sayColor=function () {
    //     alert(sColor);
    // }

    this.newMethod=ClassA;
    //调用方法后,相当于给B类增加了sColor属性和sayColor方法
    this.newMethod(sColor);

    //newMethod()之后同名方法会覆盖父类
    this.sayColor=function () {
            alert(sColor);
    }
    // 从对象上删除父类构造函数
    delete this.newMethod;

    this.name=sName;
    this.sayName=function () {
        console.log(this.name);
    }
}
var objA=new ClassA("blue");
var objB=new ClassB("red","John");
objA.sayColor(); // blue
objB.sayColor(); // red
objB.sayName(); // John

 通过示范引出继承的职能

一.构造艺术:

Man类前边的“()”,其实正是构造方法。只要你想创设类或组织的实例,必须调用它的构造方法,构造方法负责对类里面包车型地铁字段实行起首化。(初叶化
int 类型为0,bool类型为 false,char,string类型为“空”….)

亚洲必赢官网 7

概念:构造方法必须类重名; 构造方法未有重临值,但可以有参数;

亚洲必赢官网 8

构造方法能够有多少个重载;  不带参数的构造方法为暗许构造;

总计: 构造方法的原形是七个构造器,是为了类的实例化而产生;

           
构造方法是1种新鲜的章程,它从未再次来到值,它必须与类重名,它不得不在初叶化的时候
            被系统自动执行,外部无法调用;

          假诺将构造函数设置为private,则无法被外表实例化;

         
要是类里面有带参数的构造方法,想调暗中同意构造时,必须把暗中同意构造展现写出来;

相见小标题:

亚洲必赢官网 9

答案如下: 可以

亚洲必赢官网 10

子类中定义的品质和形式若是在调用this.newMethod()那行代码此前,那么子类同名属性和办法会被父类覆盖,反之会覆盖父类同名属性和章程,理由一点也不细略,原来的赋值被新值覆盖

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

二.析构主意:

析构方法:
析构方法用于析构类的实例,构造方法用于实例化,分配内部存款和储蓄器空间,而析构方法正
                     好与它反而,用于释放内存空间

亚洲必赢官网 11

亚洲必赢官网 12

小结:无法再布局中定义析构方法,只好对类使用析构方法;

            2个类只好有四个析构方法;

           不或者持续或重载析构方法;

            它们是被自动调用的;

           析构方法既没有修饰符,也不曾子数;

  1. 对象冒充达成多一连

亚洲必赢官网 13

3.面向对象程序设计:

           
面向进度:分析出消除难点所急需的手续,然后用函数把这几个步骤一步一步实现,使用
                               的时候三个2个壹回调用就足以了。

           
 面向对象:把构成事物分解成各样对象,创制对象后用对象调用各自方法以完成缓解问
                               题的指标

           特性:封装,继承,多态,(密封);

         
 OOP(面向对象编制程序)达到软件工程的多少个对象:重用性,灵活性,增添性;

从类图上得以见见苹果绿标识区域,八个类的定义出现了大批量的冗余(字段、属性、方法),那么在编辑代码时就会冒出大量的双重代码。

肆.面向对象的性状:

包裹:是达成面向对象程序设计的第二步,封装正是将数据也许函数等联谊在二个个的单元中
            (大家称之为类)

           
意义,在于保障依旧防患代码(数据)被我们不知不觉中损坏,在于高效的调整各类对象资
            源;

            正是对类成员的再次卷入,那样写更规范:
 Get方法,Set方法对字段的包装,属性对               字段的卷入

亚洲必赢官网 14

延续:继承用于创立可接纳,扩展和修改在别的类中定义的行为的新类。其成员被三番五次的类称
           
为“基类”,继承那几个成员的类称为“派生类”。派生类只好有3个一贯基类。但是,继承是
           
可以传递的。若是ClassB派生出ClassC,ClassA派生出ClassB,则ClassC会继承  
                  ClassB和ClassA中的成员;

透过在派生类名后边扩张冒号和基类名称,可以钦点基类

亚洲必赢官网 15

在成立子类的时候,必必要调用父类的构造方法,调用情势有二种:1,隐式调用2,显示调用
          (base)    隐式调用用了父类的无参构造器

亚洲必赢官网 16

(后续)

function ClassC(sColor,sName){
    this.newMethod=ClassA;
    this.newMethod(sColor);
    delete this.newMethod;
    this.newMethod=ClassB;
    this.newMethod(sColor,sName);
    delete this.newMethod;
}
var obj=new ClassC("green","ClassC");

obj.sayName(); //ClassC
obj.sayColor(); // green

试想一下,随着业务功效的扩张,或者会现出愈多类,那么冗余(重复的代码)会越多。比如出现同等会招致冗余的类:

可知ClassC同时持有ClassA和ClassB的性状
ClassA的同名属性和方法会被ClassB覆盖.同样因为后定义覆盖了先定义

Pig猪、Panda大杜洞尕、Sheep羊……等等。那些类同样会有平等的特征:名称、性别、年龄、奔跑(字段、属性、方法)。

2. call()方法达成持续

function sayColor(sPrefix,sSuffix){
    console.log(sPrefix+this.color+sSuffix);
}

var obj=new Object();
obj.color="blue";

//会调用sayColor方法
sayColor.call(obj,"The color is "," a very nice color indeed.");

//下面与对象冒充一起使用

function ClassB(sColor,sName) {
    // this.newMethod=ClassA;
    // this.newMethod(sColor);
    // delete this.newMethod;
    //call就是方法调用没啥特别地方,做了上面三条语句做的事
    //调用构造函数
    ClassA.call(this,sColor);

    this.name=sName;
    this.sayName=function () {
        console.log(this.name);
    }
}

3. apply()方法实现持续

function sayColor(sPrefix,sSuffix){
    console.log(sPrefix+this.color+sSuffix);
}

var obj=new Object();
obj.color="blue";

// 普通的方法调用
sayColor.apply(obj,new Array("The color is ", " a very nice color indeed."));

function ClassB(sColor,sName) {
    //this.newMethod = ClassA;
    //this.newMethod(color);
    //delete this.newMethod;
    //调用构造函数
    // ClassA.apply(this,arguments)
    ClassA.apply(this,new Array(sColor))
    this.name=sName;
    this.sayName=function () {
        console.log(this.name);
    }
}

var obj=new ClassB("red","Bill");
// 如果特意将ClassB的参数顺序调整ClassA不同,这时就不能用arguments,该使用ClassA.apply(this,new Array(sColor)),感兴趣自己试验一下
// ob.sayColor(); //Bill
obj.sayColor();

总括:call()和apply()让持续变得更舒畅女士,查看源码你会发现是Function的原型方法。

 如何消除此类冗余难题 ——
使用持续

4. 原型继承

function object(o) {
    function F() {}
    F.prototype=o;
    return new F();
}
var person = {
    name:"EvanChen",
    friends:["Shelby","Court","Van"]
};

var person1=object(person);
//先从person1对象查找name,没找到会去原型对象上查找
console.log(person1.name);

es5之后,规范了那种持续,成立对象使用Object.create()

//只传一个参数时
var person1=Object.create(person);
console.log(person1.name);

//传两个参数时
var prop={son:{age:10}};
var person1=Object.create(person,prop);

小结:Object.create传入的首先个参数属性会作为person1的原型属性。第一个参数属性会作为person1对象上的质量

一而再的构思:

伍. 原型链继承

function ClassA() {}
ClassA.prototype.color="blue";
ClassA.prototype.sayColor=function () {
    console.log(this.color);
}
function ClassB() {

}

ClassB.prototype=new ClassA();

var obj=new ClassB();
obj.sayColor(); //blue
console.log(obj.color); //blue

可知ClassB同时全体了ClassA的性质可方法

上面为ClassB添加越多原型方法

...
ClassB.prototype=new ClassA();

//下面的属性和方法是在赋值ClassA为新原型之后添加的属性和方法
ClassB.prototype.name="";
ClassB.prototype.sayName=function () {
    console.log(this.name);
}

var classB=new ClassB();
classB.color="red";
classB.name="John";
classB.sayColor(); //red
classB.sayName(); // John

尤其建议:

  1. ClassB原型对象上丰裕的新的属性和办法,请务必添加在ClassB.prototype=new
    ClassA()之后。因为原型已经指向ClassA,旧原型对象被灭绝
  2. 经过修改类的原型对象方式不能落实多延续,因为对象的原型对象仅有二个
  3. 对象和对象的原型上有同名属性或格局,优先会动用对象自作者,假诺指标上无此属性,才会选用原型对象上同名属性和办法

当大家定义了八个类,那多少个类都存在重新的成员(共性)。大家得以将这几个重新的积极分子单独的领到封装到2个类中,作为那几个富有相同特征类的父类。

六. 错落构造函数和原型链方式完毕持续

function ClassA(sColor) {
    this.color=sColor;
}
ClassA.prototype.sayColor=function () {
    console.log(this.color);
}

function ClassB(sColor,sName) {
    ClassA.call(this,sColor);
    this.name=sName;
}

ClassB.prototype=new ClassA();
//为ClassB添加新原型方法
ClassB.prototype.sayName=function () {
    console.log(this.name);
}

var classA=new ClassA("purple");
var classB=new ClassB("red","John");

classA.sayColor(); // purple
classB.sayColor(); // red
classB.sayName(); // John

错落继承结合了构造函数创立各种对象拥有各自一份属性和原型方法被抱有指标共享的独到之处

何以简单吗,喜欢的话,帮助点个赞O(∩_∩)O谢谢!

将此记挂作用于上述的多少个类

领到共性:可以直观察出重复的具备共性的类型有:一.字段和性质(年龄、姓名、性别)、二.主意(奔跑)。

卷入到一个类:何以定义这些类?Cat猫、Dog狗、Cattle牛有综上说述共同的性情,正是他们都以动物,故可以抽象概念二个Animal动物类。

亚洲必赢官网 17

 

怎样在代码中贯彻持续

亚洲必赢官网 18

    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("耕田。。。");
        }
    }

经过五个简单易行的  :(冒号)达成了持续关系。

贯彻持续后发生了七个剧中人物:一.子类(派生类)、二.父类(基类)

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

 

福寿无疆持续后的涉嫌如下图:

亚洲必赢官网 19

贯彻一而再后各类子类仅保留了友好特有的天性,大大减弱了冗余。

 

持续后的能力

子类的共性成员都被父类提取了,那么子类要接纳怎么做?

子类继承父类后,将会隐式继承父类的有所成员,但不包含构造函数。

在延续后,访问其父类成员,会受到访问修饰符的限定。故,修饰为private的村办成员不会造访到。

 

此起彼伏的性状

一.持续的单根性:

  2个子类只好有三个父类,就好比一人只有一个爹爹。

2.接续的传递性:  

   例如, ClassC 派生自 ClassB,并且 ClassB 派生自 ClassA,则 ClassC
会继承在 ClassB 和 ClassA 中宣示的分子。

依次顺序能够持续向上取。

图例:

亚洲必赢官网 20


 持续被后的心腹 ——
子类和父类的构造函数(难点)

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

 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     }

 

尝试运维:

亚洲必赢官网 21

缘何会唤起报那一个指鹿为马?意思说父类无法未有2个无参的构造函数。

学过构造函数的相应都会驾驭,类在没有点名其余构造函数的景况下,程序私下认可会指派三个无参的构造函数。

上述的事例由于大家手动添加的百般构造函数,暗中认可的构造函数就被解除掉了。

在暂时不知道原因的动静下,我们品尝补全这些无参的构造函数,在进展转变代码,此时编写翻译通过未有报错。

 

遵照此特征大家得以猜度子类和父类的构造函数一定有关联,但一定不是继承关系

 亚洲必赢官网 22

品尝调用刚刚定义的父类无参构造函数,在调用列表并不曾出示,只呈现了类自己的一个无参构造函数。

证实了子类不能够继续父类的构造函数。

 

经过调节和测试代码监视子类实例化对象的历程,看它到底和父类的构造函数发生了怎么。

经过调试发以后开创子类对象时的代码执行逻辑如下:

亚洲必赢官网 23

子类会首先去私下认可执行父类的无参构造函数,然后在执行本身的构造函数

那条结论就很好的诠释了,为何在上述例子为何相会世的荒谬。可是子类又为啥要先去执行父类的构造函数?

解释:

因为子类继承了父类的成员,那壹项描述只可以申明子类拥有的义务,并不代表子类去实施了。

在规则上要选用类的积极分子,必要求由此类的实例对象去调用。所以子类要调用到父类的分子,就必须去通过调用

父类的构造函数,在子类的中间创制贰个父类的对象,以便本身去调用父类的分子。

 

总结:

子类始终要利用父类的1个构造函数在友好之中成立3个父类对象,为了调用父类的积极分子。

子类暗许调用父类的无参构造函数,所以在展现编写一个有参构造函数时造成父类未有了无参构造函数,从而编写翻译出错。


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

 亚洲必赢官网 24

作用1:

增加代码重用性,子类无需在类中定义,直接利用父类的。

作用2:

上述例子讲过子类在实例化对象时会调用父类的默认无参构造函数,因为子类的指标正是通过父类构造函数创建多个对象。

经过如此突显的调用,那么在父类有未有无参构造函数都没什么关联了。


子类中留存和父类中1律的分子

示例:

亚洲必赢官网 25

依照VS给大家提醒的新闻,大家得以观望,当代码中设有子类的成员和父类的成员壹致的时候,子类的分子将父类的分子隐藏了。

暗藏过后子类将无法访问到父类的积极分子。假如是刻意为之,大家能够运用new
关键字显得的辨证,从而坚实可读性。

指定new关键字:

 亚洲必赢官网 26

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


 其它注意点

在C#中,全部的类都直接或直接的后续自object类(当大家定义二个类的时候,假诺未有给该类钦点继承2个类,那么那个类就持续了object类)。

 

网站地图xml地图