S2总结笔记

第一章:深入.NET框架

1..NET FrameWork两大组件是什么？

解析：.NET 框架类库（FCL：FrameWork Class Library）和公共语言运行时(CLR:common language Runtime)

2.CLR包含两部分：

解析：公共语言规范CLS(Common Language Specific) 通用类型系统CTS(Common  Type System)

3.c#语言要编程成可以被CPU解析执行的代码需要两次编译：

第一次编译：将C#语言通过c#编译器编译成MSIL中间代码

第二次编译：将MSIL代码通过即时编译器(JIT)编译成CPU可以解析执行的代码，或者成为（平台专用代码）

4.java程序要想被CPU解析执行也是需要两次编译

一次编译：将后缀名为java的文件通过java编译器编译成后缀名为.class(字节码)文件

第二次编译：将.class文件通过java虚拟机(jvm)编译成CPU可以解析的代码

5.CLR里面至少三部分：

CTS

CLS

JIT

类库：可以看成是一个承载了N个类的容器。

类库：System.Data.SqlClient    和数据库交互

System.Data:            DataSet

System.WinForms;        Winform应用必须类库

System.Collections.Generic;   泛型集合

System.Net;                网络操作，下载等操作

System.IO;               文件的读写，文件夹的读写。遍历等操作

System.Drawing;           绘制图形，和验证码

类库和命名空间？

解析：一个类库一般对应一个命名空间，也可以对应多个。

6.字段和属性区别？

解析：01.属性不能保存数据，真正保存数据的是字段

02.属性是可有可无的，字段是必须的。

03.如果字段只想让类内部访问，那么设置成private，如果想找一个中间者，

在Main方法中访问到Student类中的私有字段，那么属性可以是一种选择。

希望：推荐大家以后书写类的时候，字段和属性成对出现。

.属性无非就是有get和set两个访问器组成

第二章:深入C#数据类型

1.值类型和引用类型

值类型:int double string bool 枚举 浮点型

引用类型:System.Object string 自定义类 接口 数组

值类型（在栈上存储真实的值）和引用类型(堆和栈上都要分配空间)

2.关于数组的那些事儿

如果我们定义一个数组，并且赋值了

int[] nums={1,2};

nums当中保存 的是堆中的地址：例如:0x001

nums[0]：访问的是堆中的内容

3.封装的优点

第一:重用;

第二:不必关心具体的实现; （方法）

第三:面向对象三大特征之一;

第四,具有安全性!

4.结构体

1.结构体不用new,就可以直接对其属性赋值

2.结构体中可以有字段,属性和方法

3.结构体是值类型,类是引用类型

4.在结构体中不能给字段赋初值,但是类中可以

5.结构体中没有默认构造函数,但类中有默认构造函数

所有数据类型的父亲都是Object

所有的值类型直接的父亲是ValueType，爷爷是Object

5.构造函数

默认如果定义了一个类，系统会自动的生成一个和该类名称相同，并且没有返回值类型，

甚至连Void都没有的方法，该方法就称为构造函数

Student stu=new Student();

注意问题：值类型的直接父类都是ValueType，而ValueType又继承自Object

特殊的值类型：枚举和结构体

特殊的引用类型：数组和接口

6.拆箱和装箱

拆箱:

装箱:

7.值类型传递和引用类型传递

方法的参数是值类型和引用类型

注意：值传递和引用传递判定依据是有没有ref关键字

结论：

1.如果方法的参数类型本身就是引用类型，那么对参数值的修改会永久保存

例如：public void TP(SE se)

{

se.Count++;//真正的修改se对象的Count值

}

02.如果方法的参数类型本身是值类型，又没有ref修饰，那么对参数值的修改，不会永久保存()

03.如果方法的参数类型本身是值类型，但是有ref修饰，那么对象参数值的修改，也会永久保存。

值类型传递 ：不带ref的参数传递   SE se

引用类型传递：带ref的参数传递

第三章 使用集合组织相关数据

一、集合概念引入

集合：某些指定的对象(SE)集中在一起就是集合

数组：可以存储相同数据类型的一堆数据的容器

二、第一个集合ArrayList的使用

★1.引子：

用ArrayList进行赋值的时候，需要使用Add()

但是对集合中元素的修正可以使用下标，eg.list[0]=1给新值

但是在集合中元素个数为0的情况下，不能用Add()方法之外的其他手段给集合中添加元素

，原因因为_size是集合的一个属性， 真正存储元素个数为0的时候。_Size也是0.

int[] nums = { 1, 2, 3, 3, 4, 5 };

我想在2和3之间插入一个元素100

数组的局限性：由于给数组中添加元素，删除元素的时候，特别麻烦，所以我想找一个替代数组的工具，来帮我们实现数组所能实现的功能。集合应运而生

集合的优点：01.自动扩容 02.集合当中很多方法可以让我们更加便捷的来操作集合中数据。（必须掌握）

扩展：集合本质的讲解▲

00.使用ArrayList首先需要引入命名空间

01集合动态扩容原理：如果集合中元素个数为0，并没有开辟空间

02.默认如果集合中出现了第一个元素，那么集合的大小4，如果放入第5个元素，那么会扩容成8

03.如果在小括号中首次定义的时候指定了集合的长度，那么以后扩容的方式

变成初次指定数字大小的2倍；如果没有指定长度，那么遵循01的规范

三、集合中元素操作（添加，遍历，删除、常见错误）

1.常见属性：

Capacity：集合占用空间

Count：集合存储元素个数

2.常用方法：

添加：int Add(Object value) //添加一个对象到集合的末尾

遍历：通过foreach遍历

删除：Remove()、RemoveAt()和Clear()

*：注意事项：如果删除了集合中的某一个元素，那么集合的索引会自动维护

Remove()：删除内容

RemoveAt()：通过索引删除

Clear()：一次性移除集合中所有的元素

Contains():是否包含某个元素

3.ArrayList

删除方法，包含，

02.命名空间

同名类便于区分，加快检索硬盘上某个类的速度

Using System.Collections

Using System.Collections.Generic; //泛型命名，默认导入

03.var :隐式类型推断

最后一个问题：

int num=5;

04.HashTable

第一个：删除

没有RemoveAt()

第二个：

三个方案：根据key拿到value

只能拿到value

DictionayEntry

Foreach( DictionayEntry item in table)

{

item.Value

//命名空间.类名

}

第三个：HashTable是一种无序的双列集合。

第四个：ContainsKey（）

01.集合对于数组优点：

001.操作方便（新增，删除，查找方便）

002.自动扩容(刚开始可以不指定集合初始容量)

02.集合的实现原理

解析：集合在设计上还是使用数组实现的，只不过微软对两个相互copy的数组的执行效率进行了优化，所谓的自动扩容，无非是将新数组长度定义成旧数组长度的两倍后，再将新数组的前N项用旧数组的所有项填充而已。

4.集合初始化器,对象初始化器

ArrayList engineers = new ArrayList()

{

new SE(){Name = "周星星",Age = 26,

Gender = Gender.male,ID = "000",Popularity = 10},

new SE(){Name = "王贱贱",Age = 22,

Gender = Gender.female,ID = "111",Popularity = 20},

new SE(){Name = "周姐姐",Age = 30,

Gender = Gender.male,ID = "222",Popularity = 20}

};

5.HashTable

Hashtable 通常称为哈希表

根据键（Key）可以查找到相应的值 （Value）

1.HashTable注意事项

01.HashTable类型的集合只能用foreach循环遍历，因为没有索引

02.HashTable集合中元素是无序的（不会按照Add的顺序来展示元素内容）

03.HashTable中的key不能重复

04HashTabel没有RemoveAt()

2.对HashTable遍历三种方案：

1.：第一种方式，遍历所有的keys，通过key的值获取value

2.：第二种方式：遍历所有的value集合

3.：第三种方式，同时遍历key和value

Eg:

foreach (DictionaryEntry item in table)

{

Console.WriteLine(item.Key + "value==" + item.Value);

6.泛型集合List<T>（理解difficult，写起来easy）

泛型：就是为了约束ArrayList中元素类型，而制定的一个新的集合类型，该类型只能加入同一类型的多个元素，标识符<T>,可以看成是一个占位符,泛型是将运行时错误提前到了编译时

7.泛型集合Dictionary<K,V>

Dictionary<string,Person> dic=new Dictionary<string, Person>();

8..NET集合框架（集合扩展）

Queue（队列）：

Queue与Stack类似，主要区别是Queue类以先进先出(FIFO)的结构创建集合，即，元素进入集合的顺序与弹出顺序相同

队列图：

一、void Enqueue(object obj):将元素加入队列

二、object Dequeue():将队首元素从队列中删除

三、bool Contains(object obj):判断是否包含某元素

Stack（栈）：

Stack：System.Collections.Stack类表示对象的简单的后进先出非泛型集合。

栈图：

常用方法：

泛型方法

//方法定义

static void Swap<T>(ref T lhs, ref T rhs){    T temp;    temp = lhs;    lhs = rhs;    rhs = temp;}

//方法调用

public static void TestSwap(){    int a = 1;    int b = 2;     Swap<int>(ref a, ref b);    System.Console.WriteLine(a + " " + b);}

第四章 深入类的方法.构造函数

构造：方法名和类名相同，没有返回值

无参构造函数

带参构造函数

构造的生成：

注意：在C#中，当我们定义了一个类后，默认会生成一个与类名

同名的无参构造，但是如果我们自定义了任何一个带参构造，那么

系统不再帮助我们生成无参构造，在真实的开发中，推荐大家定义

两个构造函数，一个无参，一个带参。

2.方法重载

解析：在同一个类中，如果多个方法方法名称相同，但是参数列表(个数，顺序，类型）不同)的多个方法可以构成重载，和方法的返回值类型没有半毛钱关系

以下的两个方法可以构成方法重载

public void Say(string name,int age)
        {
           
        }
        
        public void Say(int age,string name)
        {
           
        }

第六章 继承

使用new实例化对象调用了构造函数

方法重载的特点:

在同一个类中，方法名相同该，参数里列表不同，和返回值类型无关

1.继承：在C#中，如果一个类后面通过冒号又跟了另外一个类，那么我们就称冒号前面的类

为子类，冒号后面的类为父类。这种书写类的方式放映出来的关系就称为类的继承关系。

子类：派生类

父类：基类或者超类

2.如果new一个子类对象，那么有如下执行流程

01.先定位到子类对应构造函数，没有执行子类的方法体

02.转向了父类的无参构造函数，执行父类构造方法体

03.转向了子类的方法体继续执行。

3.通过base调用父类构造函数注意点

解析：01.通过base调用父类构造函数只能书写在子类的构造后

02.通过base调用父类构造函数参数顺序和父类的构造参数一致

4.访问修饰符

public：在任何位置都可以访问，甚至是跨程序集都可以访问。

private：只能当前类的花括号中访问。

protected：只能在当前类，当前类的子类，子类的子类（孙子类）中可以访问。

5.继承的传递性

如果一个类B继承自类A，而类C又继承类Ｂ，那么类Ｃ也可以访问到类Ａ中非私有成员

6.new子类底层原理

1.走到子类构造,不进入构造体.

2.转向父类,进入父类构造执行.

3.转向子类构造,执行子类的构造体

4.转到Main内存构建对象.

5.遍历窗体上所有的控件，判断是不是文本框

foreach(Control c in this.Controls)

{

if(c is TextBox)

{

((TextBox)c).Text="";

}

}

6.继承的价值

01.模拟现实世界的关系

02.便于重用和扩展已彻底测试的代码，且无需修改

03.结构更清晰

14.实现多态三种方式：

方式一：通过虚方法实现多态

实现多态的步骤

01.在父类中通过virtual关键字定义一个虚方法

02.在子类中通过override关键字对父类中的虚方法进行重写

03.调用的时候，调用的是子类的方法

目前为止，我们学了两种：

第一种:虚方法实现多态

通过在普通类Person中用Virtual关键字定义虚方法SayHello（）,然后在子类Student中通过override关键字对父类的SayHello()方法进行重写。

如下：

Studnt类

Teacher类

在Main方法中调用

第七章 深入理解多态

1.里氏替换原则：在一个软件系统中，如果子类出现在父类出现的位置，而整个软件功能又没有影响，那么咱们称为里氏替换。

考试题：父类变量指向子类对象！！

2.里氏替换  是     设计原则的一种

七种设计原则   ，写成blogs。

3.Is 和as

Is 做类型判定，  要想进行父类对象    到子类  类型的转换，还得用 as

4.模拟员工回家-------->父类作为方法参数

Employee

--->GoHome(Traffic traffic)

Traffic  ---父类

--->Bicycle  （自行车）

--->Car

--->Tube

Program

--->Main

5.大话设计模式

简单工厂

单例

23种设计模式

两种方式实现多态：

普通类+  虚方法

抽象类+抽象方法

市面上所有教程 都会明确指出一个观点 ：抽象类不能实例化 。

一.实现面向对象的多态性有哪几种方法？

总共有3种，第一种，虚方法实现多态，  第二种：抽象方法实现多态  第三种：接口实现多态

目前为止，我们学了两种：

潜台词：不能直接使用如下代码实例化

Animal  animal=new Animal();//编译器报错

间接的通过子类构造，隐式   调用  父类构造的形态  来变相的在内存中 产生一个你肉眼不可见的对象。但是不幸的是  ，作为程序员的我们，无法拿到抽象类对象的引用（也就是栈上的变量名）。 第一种:虚方法实现多态

通过在普通类Person中用Virtual关键字定义虚方法SayHello（）,然后在子类Student中通过override关键字对父类的SayHello()方法进行重写。

如下：

Student类

Teacher类

在Main方法中调用

第二种：抽象方法实现多态

通过在抽象类Birds中定义抽象方法Fly(),然后在子类【燕子】中对抽象方法Fly()进行重写实现多态，重写方式和虚方法一样，也是使用override关键字

Birds类:

燕子类：

喜鹊类：

在Main中调用：

课堂笔记：

//01.定义一个抽象类,用abstract 修饰

//02.抽象方法不能有方法体，甚至连{}都不能有

//03.抽象方法只能存在于抽象类中，但是抽象类中可以有非抽象方法

//04.抽象类不能实例化

//05.抽象类中抽象方法只是用来规定方法的形式(参数，返回值)，约束子类方法的形式

//06.抽象类中的抽象成员必须在子类中全部实现，除非子类也是抽象类

//07.子类实现抽象方法的快捷键，Ctrl+.（没有输入法情况下 ）

//shift+alt+F10

//08.抽象类不能用static修饰,也不能是密封类（sealed）：如果是static，抽象就无法被继承，也就失去了抽象类

02.方法重载和方法重写的区别？

override：在不同的类中，一个方法用override关键字修饰，那么就对父类当中的同名方法进行了重写

重写的目的：就是为了实现多态，更进一步来说，就是为了统一调用

方法重载：overload:在同一个类中，多个方法名称相同，参数列表不同就可以构成重载，和返回值类型

没有半毛钱关系

第八章:可拓展标记语言XML

解析Xml文件

 XmlDocument myXml=new XmlDocument();
 myXml.Load("Engineer.xml");//读取指定的XML文档
 XnlNode engineer=myXml.DocumentElement;//读取XML的根节点
 foreach(XmlNode node in engineer.ChildNodes);//对子节点进行循环
 {
 //将每个节点的内容显示出来
 switch(node.Name)
 }