C#学习笔试

目录

一、         静态构造函数... 1

一、         流程控制... 1

1.      异常捕获... 1

2.      switch-case. 2

4.      break. 2

二、         复杂数据类型... 4

1.      变量类型... 4

2.      Camel  Pascal4

3.      运算符... 4

4.      c#中的语法结构... 4

5.      常量... 4

6.      枚举：... 5

7.      结构... 5

8.      数组... 6

9.      冒泡排序... 6

10.        方法... 7

11.        return. 7

12.        方法（参数、重载、递归）... 7

三、         面向对象... 8

1.      面向过程-----> 面向对象... 8

2.      类... 11

3.      属性... 11

4.      访问修饰符... 12

5.      初始化... 12

6.      静态和非静态的区别... 12

7.      构造函数... 12

8.      new关键字... 13

9.      this关键字... 13

10.        析构函数... 13

四、         面向对象2. 14

1.      命名空间... 14

2.      在一个项目中引用另一个项目的类... 14

3.      值类型和引用类型... 14

4.      字符串... 14

5.      继承：解决代码冗余问题！！... 15

6.      继承的特性... 16

7.      查看类图... 16

8.      object是所有类的基类。... 16

9.      new关键字... 16

五、         面向对象3. 16

1.      里氏转换... 16

2.16

3.      判断子父类之间是否可以转换... 16

4.      protected. 17

5.      ArrayList集合的长度问题... 17

6.      Hastable 键值对集合  字典  孙    sun---孙... 17

7.      编码格式... 17

8.      文本文件... 18

9.      path类：system.IO，专门用来操作路径的；... 18

10.        File类：System. IO.. 18

六、         面向对象四... 18

1.      绝对路径和相对路径... 18

2.      装箱、拆箱... 18

3.      将创建文件流对象的过程写在using当中，会自动的帮助我们释放流所占用的资源。     19

4.      实现多态的手段... 20

1)、虚方法：需要从所有类中选一个作为父类... 20

2)、抽象类：所有类中没有一个类可作为父类，只能抽象出一个类... 20

七、         面向对象五... 21

1.      c#中的访问修饰符... 21

2.      设计模式... 21

3.      简单工厂设计模式... 21

4.      值类型在复制的时候，传递的是这个值得本身。... 21

5.      序列化：就是将对象转换为二进制... 22

6.      partial部分类... 22

7.      sealed密封类... 22

8.      重写ToString方法：... 22

9.      接口... 22

八、         面向对象复习... 23

1.      new关键字... 23

2.      访问修饰符... 23

3.      常用的关键字... 24

4.      字符串... 24

5.      集合... 25

6.      装箱或者拆箱... 25

7.      结构和类的区别... 25

十、委托、XML. 25

1.      配置.net环境... 25

2.      单例模式... 25

3.      XML  可扩展标记语言 HTML. 26

4.      委托：delegate. 26

5.      进程类：using System.Diagnostics;27

6.      多线程... 27

7.      栈... 28

8.      队列... 29

9.      委托多线程... 29

 

一、      静态构造函数

例题：（剑指offer）

（1）      类中的静态成员，在第一次使用类的时候进行初始化；

（2）      静态构造函数：

静态构造函数不能手动调用，而是在第一次使用静态类或者静态成员的时候自动调用。所以不能为静态构造函数添加任何修饰符，默认为private；

因为静态构造函数是系统自动调用的，所以不需要也不能添加任何参数。

静态构造函数的特点：

1）   静态构造函数只能执行一次；

2）   在第一次使用静态类或者静态成员之前使用。

例题分析：在调用B的代码之前先执行静态构造函数，在执行静态构造函数之前先初始化静态成员变量；所以先打印a1,再打印a3;接下来执行B b=new B()；调用B的普通构造函数，先初始化成员变量，再执行构造函数，先打印a2,再打印a4，执行结果是：a1,a3,a2,a4。

 

接红皮7页

 

Struct和class的区别：struct是值类型，class是引用类型。值类型的实例在栈上分配内存，引用类型的实例在堆上分配内存。

 

一、      流程控制

1.       异常捕获

异常：在语法上没有错误，在程序运行过程中，由于某些原因程序出现了错误，不能再正常运行。所以在代码中需要在可能出现异常的位置使用try-catch来进行异常捕获。

语法：

try

{

可能会出现异常的代码

}

Catch

{

   出现异常后要执行的代码

{

执行过程：在try中的代码出错，后面的就不执行了，直接跳到catch中执行。

2.       switch-case

用于处理多条件的定值的判断。（对于存在范围的，可以转化为定值，比如成绩等级的判断，可根据成绩用%或者/来定值）

Switch(变量或表达式的值)

{

  Case值1：要执行的代码；

  Break;

  Case 值2：要执行的代码；

  Break；

Case 值3：要执行的代码；

Break；

…………

Default：要执行的代码；

Break；

}

}

执行过程：执行到switch处，首先将括号中变量或者表达式的值计算出来，与case中的值依次与case进行匹配，匹配成功执行，直接跳出switch-case结构，如果无case匹配，则执行default（可省略）。

3.        while   //知道循环的条件

while(循环条件)

{

循环体;

}

执行过程：先判断后执行。在使用之前先想好循环条件和循环体。

4.       break

(1)    跳出switch结构

(2)    跳出当前while循环

Break一般不单独使用，而是配好if使用，表示当满足

5.        do-while循环。

语法：

do

{

         循环体;

}while(循环条件);

执行过程:程序首先会执行do中的循环体，执行完成后，去判断do-while循环的循环条件，

如果成立，则继续执行do中的循环体，如果不成立，则跳出do-while循环。

特点：先循环，再判断，最少执行一遍循环体。

 

6.       *程序调试

1)、写完一段程序后，想看一下这段程序的执行过程。

2)、当你写完这段程序后，发现，程序并没有按照你想象的样子去执行。

调试方法：

1)、F11逐语句调试(单步调试)

2)、F10逐过程调试

3)、断点调试

 

7.      for循环    //知道循环的次数

语法:

for(表达式1;表达式2;表达式3)

{

         循环体;

}

表达式1一般为声明循环变量，记录循环的次数(int i=0;)

表达式2一般为循环条件(i<10)

表达式3一般为改变循环条件的代码，使循环条件终有一天不再成立(i++)。

执行过程：程序首先执行表达式1，声明了一个循环变量用来记录循环的次数，

然后执行表达式2，判断循环条件是否成立，如果表达式2返回的结果为true，

则执行循环体。当执行完循环体后，执行表达式3，然后执行表达式2继续判断循环条件是否成立，如果成立则继续执行循环体，如果不成立，则跳出for循环。

 

8.     类型转换

Convert.toInt32();   //面上得看得过去，转换失败则抛出异常

int.parse

int.tryparse(“123”,out number) //将”123”转化为数字，赋值给number，返回bool类型true；若转化失败，则把0赋值给number，返回false；

尝试着将一个字符串转换成int类型。

 

9.     三元表达式

语法:

表达式1?表达式2:表达式3;

表达式1一般为一个关系表达式。

如果表达式1的值为true，那么表达式2的值就是整个三元表达式的值。

如果表达式1的值为false，那么表达式3的值就是整个三元表达式的值。

注意：表达式2的结果类型必须跟表达式3的结果类型一致，并且也要跟整个三元表达式的结果类型一致。

 

10. Continue

跳出本次循环，进入下一循环。

 

11. 随机数产生

Random r=new Random();

Int number=r.Next(1,10);产生1-10的数

 

 

二、      复杂数据类型

1.     变量类型

int double string char bool decimal

变量的使用规则：先声明再赋值最后使用

int number;

number=10;

number=20;

Console.WriteLine(number);

 

2.     Camel  Pascal

 

3.     运算符

赋值运算符：=

复合赋值运算符：+= -= *= /= %=  sum+=age;  sum=sum+age;

算数运算符： + - * / % ++ --

关系运算符： > < >= <= == !=

逻辑运算符： && || !

 

4.     c#中的语法结构

分支结构：

if if-else

选择结构：

while do-while for

 

5.     常量

声明的常量的语法：

const 变量类型 变量名=值;

什么时候会用到常量？不会随意改变的量需要用常量，比如：π

 

6.     枚举：

确定数量、确定值的几个取值：东西南北、男女、上中下。

语法：

声明：[public] enum 枚举名

{

     值1,

     值2,

     值3,

     ........

}

例子：public enum Gender

{

   男，               //可以用男=1，将默认的int初值设为1

   女

}

赋值：Gender gender=Gender.男；

Public 访问修饰符，公开的公共的，那都可以访问；

enum枚举的关键字；

枚举名符合pascal命名规范。

将枚举声明到命名空间的下面，类的外面，表示这个命名空间里面都可以使用此枚举变量

枚举也是一个变量类型，只是声明、赋值和使用的方式不同。

 

枚举类型可以与int类型之间强制类型转换，他们之间是兼容的；

将string类型转换为枚举类型例外：

1）  先转化为int类型再转化为枚举类型：Convert.toInt32();int.parse(),int.tryParse();

2）  利用parse()：

如果要转换的为数字，超出范围也不会报异常；如果转换的为字符串，超出范围则抛出异常；

所有类型都可以转化为字符串类型，利用toString()

 

7.     结构

可以帮助我们一次性声明多个不同类型的变量。

语法：

[public] struct 结构名

{

         成员;//字段

}

变量与字段的区别：变量在程序运行期间只能存储一个值，而字段可以存储多个值。

在结构类型中，可以使用枚举类型；

 

8.     数组

一次性存储多个相同类型的变量。

语法：

数组类型[] 数组名=new 数组类型[数组长度];

 

如果需要访问数组的某一块元素，需要通过这个股元素的下标或者索引来访问；

***数组的长度一旦固定了，就不能再被改变了

 

9.     冒泡排序

：就是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。

int[] nums={9,8,7,6,5,4,3,2,1,0}; 0 1 2 3 45 6 7 8 9

第一趟比较：8 7 6 5 4 3 2 1 0 9 交换了9次     i=0  j=nums.Length-1-i

第二趟比较：7 6 5 4 3 2 1 0 8 9 交换了8次     i=1  j=nums.Length-1-i

第三趟比较：6 5 4 3 2 1 0 7 8 9 交换了7次     i=2  j=nums.Length-1-i

第四趟比较：5 4 3 2 1 0 6 7 8 9 交换了6次     i=3  j=nums.Length-1-i

第五趟比较：4 3 2 1 0 5 6 7 8 9 交换了5次

第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了4次

第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了3次

第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了2次

第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了1次

for(int i=0;i

{

         for(intj=0;j

         {

                   if(nums[j]>nums[j+1])

                   {

                            inttemp=nums[j];

                            nums[j]=nums[j+1];

                            nums[j+1]=temp;

                   }

         }

}

 

 

10. 方法

函数就是将一堆代码进行重用的一种机制。

函数的语法：

[public] static 返回值类型 方法名([参数列表])

{

         方法体；

}

public:访问修饰符，公开的，公共的，哪都可以访问。

static：静态的

返回值类型：如果不需要写返回值，写void

方法名：Pascal 每个单词的首字母都大些。其余字母小写

参数列表：完成这个方法所必须要提供给这个方法的条件。如果没有参数，小括号也不能省略。

 

方法写好后，如果想要被执行，必须要在Main()函数中调用。

方法的调用语法：

类名.方法名([参数]);

***在某些情况下，类名是可以省略的，如果你写的方法跟Main()函数同在一个类中，这个时候，类名可以省略。

 

11. return

1、在方法中返回要返回的值。

2、立即结束本次方法。

 

12. 方法（参数、重载、递归）

1、我们在Main()函数中，调用Test()函数，我们管Main()函数称之为调用者，

管Test()函数称之为被调用者。

如果被调用者想要得到调用者的值：

1)、传递参数。

2)、使用静态字段来模拟全局变量。

如果调用者想要得到被调用者的值：

1)、返回值

 

2、不管是实参还是形参，都是在内存中开辟了空间的。

 

3、方法的功能一定要单一。

GetMax(int n1,int n2)

方法中最忌讳的就是出现提示用户输入的字眼。

 

4、out、ref、params

1)、out参数。

如果你在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组。

但是，如果返回多个不同类型的值的时候，返回数组就不行了，那么这个时候，

我们可以考虑使用out参数。

out参数就侧重于在一个方法中可以返回多个不同类型的值。

比如tryPause()就是使用out参数，除了返回是否转化成功外，还返回转化结果

2)、ref参数

能够将一个变量带入一个方法中进行改变，改变完成后，再讲改变后的值带出方法。

ref参数要求在方法外必须为其赋值，而方法内可以不赋值。//out要求方法内必须赋值，方法外不一定。

 

3)、params可变参数

将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理。

params可变参数必须是形参列表中的最后一个元素。

 

5、方法的重载

概念：方法的重载指的就是方法的名称相同，但是参数不同。

参数不同，分为两种情况

1)、如果参数的个数相同，那么参数的类型就不能相同。

2)、如果参数的类型相同，那么参数的个数就不能相同。

***方法的重载跟返回值没有关系。

 

6、方法的递归

方法自己调用自己。

找出一个文件夹中所有的文件。

 

三、      面向对象

1.     面向过程----->面向对象

 

面向过程：面向的是完成这件事儿的过程，强调的是完成这件事儿的动作。

 

把大象塞进冰箱里

1、打开冰箱门

2、把大象塞进去，亲下大象的屁股

3、关闭冰箱门

 

孙全瘦小 矮  小屌丝

孙全踩着小板凳打开冰箱门

孙全找翟盼盼帮忙把大象塞进冰箱里，孙全踩着板凳去亲。

孙全踩着板凳关闭冰箱门

 

翟盼盼  190cm  非常大力气

1、翟自己就能打开冰箱门

2、翟自己将大象塞进冰箱里，翟可以自己亲一下。

3、翟自己关闭冰箱门

 

如果我们用面向过程的思想来解决这件事儿，当执行这件事的人的不同的时候，

我们需要为每个不同的人量身定做解决事情的方法。

 

 

面向对象：找个对象帮你做事儿。

把大象塞进冰箱里

我们把冰箱作为对象：

1、冰箱门可以被打开

2、大象可以被塞进冰箱里

3、冰箱门可以被关闭

 

孙全

孙全  1

孙全  2

孙全  3

 

翟盼盼

翟   1

翟  2

翟  3

 

面向对象：意在写出一个通用的代码，屏蔽差异。

 

 

关门

面向过程：关门

张三一脚把门踹紧了

李四轻轻的把门带上了

王五门没关严，留了个尾巴

 

面向对象：关门

门可以被关闭

 

我在黑板上画了一个菱形

将圆圈作为对象

圆圈可以被画在黑板上

 

将黑板作为对象

黑板可以被画圆

 

我在黑板上画了一个圆

张三上来的  哪尺子比这画了一个特别圆的圆

李四上来的随便一划拉

王五上来了  圆规画了一个圆

圆可以被画在黑板上

圆圈可以被画在黑板上

将圆圈作为对象：这个圆圈可以被画在黑板上。

黑板可以被画圆

黑板作为一个对象：可以被画圆圈  被画方块 被画正方向

根据需求，找被动的作为对象

 

试着描述孙全和颜XX的特征和行为

姓名：孙全

性别：男

身高：180cm

体重：70kg

年龄：22岁

吃喝拉撒睡一切正常健康

吃喝嫖赌抽

 

姓名：颜XX

性别：男

身高：180cm

体重：70KG

年龄：23岁

脑残身体一切健康

 

 

我们在代码中描述一个对象，通过描述这个对象的属性和方法

对象必须是看得见摸得着的

 

灯：属性和方法

属性：

外形：长的

亮度：500W

颜色：白色

牌子：XX

方法：发光

 

 

电风扇：属性、方法

外形：三个扇叶

颜色：白色

品牌：XX

方法：转动，扇风

 

 

我们把这些具有相同属性和相同方法的对象进行进一步的封装，抽象出来类这个概念。

类就是个模子，确定了对象应该具有的属性和方法。

对象是根据类创建出来的。

类就是一个盖大楼的图纸   对象 就是盖出来的大楼。

 

2.     类

语法：

[public] class 类名

{

         字段;

         属性;

         方法;

}

写好了一个类之后，我们需要创建这个类的对象，

那么，我们管创建这个类的对象过程称之为类的实例化。

使用关键字 new.

 

this:表示当前这个类的对象。

类是不占内存的，而对象是占内存的。

 

 

3.     属性

属性的作用就是保护字段、对字段的赋值和取值进行限定。

属性的本质就是两个方法，一个叫get()一个叫set()。

既有get()也有set()我们诚之为可读可写属性。

只有get()没有set()我们称之为只读属性

没有get()只有set()我们称之为只写属性

 

 

 

Field字段

Method方法

Property属性

 

 

****字段就是女人  属性才是男人。

 

4.     访问修饰符

public：公开的公共的，在哪都能访问。

private：私有的，只能在当前类的内部进行访问，出了这个类就访问不到了。

 

5.     初始化

当我们创建好一个类的对象后，需要给这个对象的每个属性去赋值。

我们管这个过程称之为对象的初始化。

 

6.     静态和非静态的区别

1)、在非静态类中，既可以有实例成员，也可以有静态成员。

2)、在调用实例成员的时候，需要使用对象名.实例成员;

    在调用静态成员的时候，需要使用类名.静态成员名;

总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。

           静态函数中，只能访问静态成员，不允许访问实例成员。

     实例函数中，既可以使用静态成员，也可以使用实例成员。

     静态类中只允许有静态成员，不允许出现实例成员。

 

使用：

1)、如果你想要你的类当做一个"工具类"去使用，这个时候可以考虑将类写成静态的。

2)、静态类在整个项目中资源共享。

只有在程序全部结束之后，静态类才会释放资源。

 

堆  栈  静态存储区域

 

释放资源。GC Garbage Collection垃圾回收器

 

7.     构造函数

作用：帮助我们初始化对象(给对象的每个属性依次的赋值)

构造函数是一个特殊的方法：

1)、构造函数没有返回值，连void也不能写。

2)、构造函数的名称必须跟类名一样。

 

创建对象的时候会执行构造函数

构造函数是可以有重载的。

***

类当中会有一个默认的无参数的构造函数，当你写一个新的构造函数之后，不管是有参数的还是

无参数的，那个默认的无参数的构造函数都被干掉了。

8.     new关键字

Person zsPerson=new Person();

new帮助我们做了3件事儿：

1)、在内存中开辟一块空间

2)、在开辟的空间中创建对象

3)、调用对象的构造函数进行初始化对象

 

 

9.     this关键字

1)、代表当前类的对象

2)、在类当中显示的调用本类的构造函数  :this

以避免代码冗余！不需要的参数设置为默认值；

 

10. 析构函数

~student()

{

  手动释放资源；在程序结束之后触发

}

 

四、      面向对象2

1.     命名空间

可以认为类是属于命名空间的。

如果在当前项目中没有这个类的命名空间，需要我们手动的导入这个类所在的

命名空间。

1)、用鼠标去点

2)、alt+shift+F10

3)、记住命名空间，手动的去引用

 

2.     在一个项目中引用另一个项目的类

1)、添加引用

2)、引用命名空间

 

3.     值类型和引用类型

区别：

1、值类型和引用类型在内存上存储的地方不一样。

2、在传递值类型和传递引用类型的时候，传递的方式不一样。

值类型我们称之为值传递，引用类型我们称之为引用传递。

我们学的值类型和引用类型：

值类型：int、double、bool、char、decimal、struct、enum

引用类型：string、自定义类、数组

存储：

值类型的值是存储在内存的栈当中。

引用类型的值是存储在内存的堆中。

 

4.     字符串

1)、字符串的不可变性

当你给一个字符串重新赋值之后，老值并没有销毁，而是重新开辟一块空间存储新值。

 

当程序结束后，GC扫描整个内存，如果发现有的空间没有被指向，则立即把它销毁。

 

2)、我们可以讲字符串看做是char类型的一个只读数组。(反转字符串时，即改变时，需要先转化为字符数组)

ToCharArray();将字符串转换为char数组

new string(char[] chs):能够将char数组转换为字符串

 

4、字符串提供的各种方法

1)、Length：获得当前字符串中字符的个数

2)、ToUpper():将字符转换成大写形式

3)、ToLower():将字符串转换成小写形式

4)、Equals(lessonTwo,StringComparison.OrdinalIgnoreCase):比较两个字符串，可以忽略大小写

5)、Split()：分割字符串，返回字符串类型的数组。

6)、Substring()：截取字符串。在截取的时候包含要截取的那个位置。

7)、IndexOf():判断某个字符串在字符串中第一次出现的位置，如果没有返回-1、值类型和引用类型在内存上存储的地方不一样。

//利用找不到返回-1,作为循环条件做题:indexof(“e”,i),返回从i开始第一次出现e的位置

8)、LastIndexOf()：判断某个字符串在字符串中最后一次出现的位置，如果没有同样返回-1

9)、StartsWith():判断以....开始

10)、EndsWith():判断以...结束

11)、Replace():将字符串中某个字符串替换成一个新的字符串

12)、Contains():判断某个字符串是否包含指定的字符串

13)、Trim():去掉字符串中前后的空格

14)、TrimEnd()：去掉字符串中结尾的空格

15)、TrimStart()：去掉字符串中前面的空格

16)、string.IsNullOrEmpty():判断一个字符串是否为空或者为null

17)、string.Join()：将数组按照指定的字符串连接，返回一个字符串。

//比如：string[] str={“诸葛亮”,”鸟叔”,”卡卡西”};

String s=string.Jion(“|”，str);str为要连接的数组

18)、s1.CompareTo(s2)，如果s1>s2,则返回1，相等返回0，小于返回-1；

数组的排序Array.Sort(array);     //数组的排序：Array.Sort(num);

数组的翻转Array.Reverse(array);

 

5.     继承：解决代码冗余问题！！

我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员，

单独的封装到一个类中，作为这些类的父类。

Student、Teacher、Driver  子类  派生类

Person                                        父类  基类

子类继承了父类，那么子类从父类那里继承过来了什么？

首先，子类继承了父类的属性和方法，但是子类并没有继承父类的私有字段。

问题：子类有没有继承父类的构造函数？

答：子类并没有继承父类的构造函数，但是。子类会默认的调用父类无参数的构造函数，

创建父类对象，让子类可以使用父类中的成员。

所以，如果在父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，

子类就调用不到了，所以子类会报错。

解决办法：

1)、在父类中重新写一个无参数的构造函数。

2)、在子类中显示的调用父类的构造函数，使用关键字:base()

 

 

 

6.     继承的特性

1、  继承的单根性：一个子类只能有一个父类。

2、  继承的传递性

 

7.     查看类图

8.     object是所有类的基类。

9.     new关键字

1)、创建对象

2)、隐藏从父类那里继承过来的同名成员。比如同名的方法

隐藏的后果就是子类调用不到父类的成员。

 

五、      面向对象3

1.     里氏转换

1)、子类可以赋值给父类

2)、如果父类中装的是子类对象，那么可以将这个父类强转为子类对象。

 

2.     

子类对象可以调用父类中的成员，但是父类对象永远都只能调用自己的成员。

 

3.     判断子父类之间是否可以转换

is：表示类型转换，如果能够转换成功，则返回一个true，否则返回一个false

as：表示类型转换，如果能够转换则返回对应的对象，否则返回一个null

 

4.     protected

受保护的：可以在当前类的内部以及该类的子类中访问。

 

5.     ArrayList集合的长度问题

每次集合中实际包含的元素个数(count)超过了可以包含的元素的个数(capcity)的时候，

集合就会向内存中申请多开辟一倍的空间，来保证集合的长度一直够用。

方法：

6.     Hastable 键值对集合  字典  孙    sun---孙 

在键值对集合当中，我们是根据键去找值的。

键值对对象[键]=值;

*****:键值对集合当中，键必须是唯一的，而值是可以重复的

foreach循环

 

7.     编码格式

产生乱码的原因就是因为你保存这个文件的编码格式跟你打开这个文件的编码格式不一样。

 

 

8.     文本文件

拖到txt文件中，还能看得懂的文件就是文本文件。

File类和int的最大值和最小值

9.     path类：system.IO，专门用来操作路径的；

10. File类：System.IO

 

六、      面向对象四

1.     绝对路径和相对路径

绝对路径：通过给定的这个路径直接能在我的电脑中找到这个文件。

相对路径：文件相对于应用程序的路径。

结论：

我们在开发中应该去尽量的使用相对路径。

 

2.     装箱、拆箱

装箱：就是将值类型转换为引用类型。

拆箱：将引用类型转换为值类型。

看两种类型是否发生了装箱或者拆箱，要看，这两种类型是否存在继承关系。

 

3.     将创建文件流对象的过程写在using当中，会自动的帮助我们释放流所占用的资源。

l  文件流filestream，（）（1）可操作所有的文件、（2）可操作大文件，更重要！！！

例题：多媒体文件的赋值

l  SteamReader/SteamWrite

4.     实现多态的手段

1)、虚方法：需要从所有类中选一个作为父类

步骤：

1、将父类的方法标记为虚方法 ，使用关键字 virtual，这个函数可以被子类重新写一个遍。

 

2)、抽象类：所有类中没有一个类可作为父类，只能抽象出一个类

当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。

特点：

1.抽象成员必须标记为abstract,并且不能有任何实现。

2.抽象成员必须在抽象类中。

3.抽象类不能被实例化

4.子类继承抽象类后，必须把父类中的所有抽象成员都重写。

（除非子类也是一个抽象类，则可以不重写）

5.抽象成员的访问修饰符不能是private

6.在抽象类中可以包含实例成员。

并且抽象类的实例成员可以不被子类实现

7.抽象类是有构造函数的。虽然不能被实例化。、

8、如果父类的抽象方法中有参数，那么。继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。

 

如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候也必须要传入返回值。

======

如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。

 

如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。

 

七、      面向对象五

1.     c#中的访问修饰符

public :公开的公共的

private：私有的，只能在当前类的内部访问

protected：受保护的，只能在当前类的内部以及该类的子类中访问。

internal：只能在当前项目中访问。在同一个项目中，internal和public的权限是一样。

protected internal：protected+internal

 

1)、能够修饰类的访问修饰符只有两个：public、internal。

2)、可访问性不一致。

子类的访问权限不能高于父类的访问权限，会暴漏父类的成员。

 

2.     设计模式

设计这个项目的一种方式。

3.     简单工厂设计模式

 

4.     值类型在复制的时候，传递的是这个值得本身。

   引用类型在复制的时候，传递的是对这个对象的引用。

  

5.     序列化：就是将对象转换为二进制

   反序列化：就是将二进制转换为对象

   作用：传输数据。

  序列化：

  1)、将这个类标记为可以被序列化的。

 

 

6.     partial部分类

 

7.     sealed密封类

不能够被其他类继承，但是可以继承于其他类。

8.     重写ToString方法：

 

9.     接口

//接口就是一个规范、能力

[public] interface I..able

{

         成员;

}

特点：

接口是一种规范。

只要一个类继承了一个接口，这个类就必须实现这个接口中所有的成员

 

为了多态。

接口不能被实例化。

也就是说，接口不能new(不能创建对象)

接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为public,不能修改。

 

（默认为public）

接口中的成员不能有任何实现（“光说不做”，只是定义了一组未实现的成员）。

接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。

 

接口与接口之间可以继承，并且可以多继承。

 

接口并不能去继承一个类，而类可以继承接口  （接口只能继承于接口，而类既可以继承接口，也可以继承类）

实现接口的子类必须实现该接口的全部成员。

 

一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A，并实现了接口IA,那么语法上A必须写在IA的前面。

 

class MyClass:A,IA{}，因为类是单继承的。

 

显示实现接口的目的：解决方法的重名问题

什么时候显示的去实现接口：

当继承的借口中的方法和参数一摸一样的时候，要是用显示的实现接口

 

当一个抽象类实现接口的时候，需要子类去实现接口。

 

 

八、       面向对象复习

1.     new关键字

1)、创建对象

2)、隐藏从父类那里继承过来的成员

 

2.     访问修饰符

public:公开的，公共的

private:私有的，只能在当前类的内部访问，类中成员们，如果不加访问修饰符，默认就是private，比如main函数省略访问修饰符时，默认为private。

procteced：受保护的，可以在当前类的内部访问，也可以在该类的子类中访问

internal：在当前项目中都可以访问。

Protected internal：

能够修饰类的访问修饰符只有两个，internal和public

 

3.     常用的关键字

this

1、作为当前类的对象，可以调用类中的成员。This.成员；

2、调用本类的其他的构造函数  在构造函数后加：this（参数）

base

调用父类的成员（在子类重写了父类成员时）

new

1、创建对象

2、隐藏父类的成员

virtual

标记一个方法是虚方法

abstract

抽象的

override

重写

interface

接口

partial

部分类

sealed

密封类：不允许被继承

return

1、在方法中返回要返回的值

2、立即结束本次方法

break

跳出当前循环

continue

结束本次循环，回到循环条件进行判断

static

静态的

struct

结构

enum

枚举

const

常量

 

4.     字符串

1、字符串的不可变性

2、字符串可以看做是char类型的只读数组

 

5.     集合

ArrayList

Hashtable

List

Dictionary

 

 

6.     装箱或者拆箱

装箱：就是将值类型转换为引用类型

拆箱:就是将引用类型转换为值类型。

值类型:bool int double char struct enum decimal

引用类型：string 数组集合 interface object 自定义类

拆箱或者装箱的两种类型必须具有继承关系

 

 

7.     结构和类的区别

1、类当中写了一个新的构造函数之后，默认的无参数的就被干掉了。

但是在结构中，写了一个新的构造函数之后，默认的那个无参数的还在。

在结构的构造函数当中，必须给所有的字段赋值，这样也就限制了结构中最多

只能有两个构造函数，一个是默认的无参数的构造函数，一个是全参数的构造函数。

 

2、结构的new关键字只干了一件事儿，就是调用结构的构造函数。

 

3、结构不能继承于类，而类也不能继承于结构。

结构不具备面向对象的特征。

而类才是面向对象的产物。

 

3、  如果不给结构创建对象的话，不允许调用结构中的非静态方法。

 

 

十、委托、XML

1.       配置.net环境

2.       单例模式

1）  将构造函数私有化；

2）  提供一个静态函数，返回一个对象

3）  创建一个单例；

3.       XML  可扩展标记语言 HTML

XML  存储数据；

注意：

1）  XML严格区分大小写；

2）  XML标签是成对出现的；

XML文档有且只能有一个根节点；

节点：

元素：

 

4.       委托：delegate

1）  为什么要用委托？

将方法做为参数传递给另一个方法；

2）  委托的概念

声明一个委托类型

委托所指向的函数必须和委托具有相同的签名；

3）  匿名函数

没有名字的函数

4）  使用委托求数组的最大值

使用委托求数组的最小值

5）  泛型委托

标准委托类型Func<>、Action<>（无返回，传入string）

6）  Lanmda表达式

7）  窗体传值//发布订阅模式（观察者模式）

8）  多播委托

5.       进程类：using System.Diagnostics;

6.       多线程

一个进程是由多个线程组成的

7.       栈

8.       队列

9.       委托多线程

Asp.net

1、聊天程序

socket编程，做一个聊天程序

IIS服务器

2、一般处理程序

网页的增添改查crud 、图片处理

4、  aspx页面的crud

asp.net的生命周期====》面试

4、异步的crud   Ajax

5、服务器段控件的crud

6、高级部分：