C#就业班培训笔记.docx

C#就业班培训笔记.docx

《C#就业班培训笔记.docx》由会员分享，可在线阅读，更多相关《C#就业班培训笔记.docx（86页珍藏版）》请在冰豆网上搜索。

C#就业班培训笔记

第一天

1、基础加强的主要内容

->第一天：

面向对象

->第二、三天：

常用类库（字符串、集合、文件）

->第四天：

一点点理论、和正则表达式（匹配提取为主）

->第五天：

XML处理（半天，简单）与委托事件

->第六天：

反射

2、面向对象

Int？

Num=null；//可空类型

->什么是面向对象：

要求对象去做事

->使用代码写一个计算器

->面向过程：

1、输入数字和运算符；2、进行计算；3、得到结果

->对象对象：

1、找对象（工具new）；2、调用输入的方法；3、得到结果

->面向对象只是人们为了便于开发和维护而提出的一种观点（代码的组织形式）

->三大特征

->封装性：

打包，便于管理

诞生：

为了解决大型项目的维护与管理

->继承性：

拿来主义

什么是继承性：

将一个类库作为原始模板，在其上扩展另外的类库

带来的优势：

解决代码的冗余

特征：

单根性（C#和Java类语言的特征）、传递性

注意的问题：

构造方法的执行顺序：

里氏转换原则：

（多态实现的基础）

子类可以赋值给父类对象

父类对象可以强制转化为对应的子类对象

is与as运算符is（bool）判断转换是否成功

->多态性：

让一个对象表现出多种类型

对象在调用同一个方法的时候表现出来的多种状态

->重写基类方法实现多态：

父类统一调用，子类具体实现

->隐藏基类方法实现多态

->口诀：

new则隐藏（父子方法完全一样，包括参数），over重写；隐藏看类型，重写只管新（重写只管新的）

---------------------------------------------------------------------------------------------------------------------------------

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

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

3.抽象类不能被实例化

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

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

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

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

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

7.抽象类是有构造函数的。

虽然不能被实例化。

8、如果父类的抽象方法中有参数，那么。

继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。

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

======

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

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

-->接口

接口是一种规范。

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

为了多态。

接口不能被实例化（抽象类，静态函数，接口）。

也就是说，接口不能new（不能创建对象）

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

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

（不允许写具有方法体的函数）

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

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

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

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

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

classMyClass:

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

显示实现接口的目的：

解决方法的重名问题

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

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

classProgram

{

staticvoidMain（string[]args）

{

//显示实现接口就是为了解决方法的重名问题

IFlyablefly=newBird（）;

fly.Fly（）;

Birdbird=newBird（）;

bird.Fly（）;

Console.ReadKey（）;

}

}

publicclassBird:

IFlyable

{

publicvoidFly（）

{

Console.WriteLine（"鸟飞会"）;

}

///

voidIFlyable.Fly（）

{

Console.WriteLine（"我是接口的飞"）;

}

}

publicinterfaceIFlyable

{

voidFly（）;

}

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

---------------------------------------------------------------------------------------------------------------------------------

->构造方法

->this与base

->访问修饰符

3、什么是异常\

eg-

If（num==0）

{

ThrownewException（“出书不能为0”）;

}

->运行的时候出现的错误，或Bug（初学者可以这么理解）

->编写代码的预期条件与实际条件不稳合

->异常的机制是为了保证程序可以一直正常运行

Convert.ToInt32（"123"）;->1*100+2*10+3

Convert.ToInt32（"abc"）;->怎么做？

97*100+98*10+99

->如果异常不处理程序就会死掉

publicvoidFunc1（）

{

Func2（）;

}

Try//代码中尽量少用异常处理bool=

{

//可能出现异常的代码

//出现异常，其后的代码不再执行

//直接跳转到catch

}

catch（Exceptionex）

{

//写入日志，处理异常后的首尾工作

}

4、作业

->计算器（多个版本）

->PPT上的练习

5、长期的作业

->笔记

->代码分析（难点）

->1、该方法是谁调用的

->2、该方法中有几个局部变量，几个静态变量（全局）

->3、该方法需要几步执行完

->4、每一步，代码是如何执行的（要求说明意义）

->5、每一步执行中，每一个局部变量的值如何变化

第二天

4、接口语法

[访问修饰符]interfaceI接口名

{

接口成员

}

publicinterfaceIdable

{

voidDa（）;//默认就是public

}

//实现接口

abstractclassCCC:

Idable//继承自接口,实现接口

{

//假定没有接口存在，但是需要一个名字为Da，没有返回值，没有参数的方法

publicabstractvoidDa（）;

}

静态多用方法，少用静态字段。

用静态模拟全局

5、修饰符

->类型前

->访问修饰符：

【public（在所以程序集都可以访问）internal（默认）（只能在当前程序集中访问）】：

限制类型在当前程序集和外部程序集的访问的级别

->多态方面的修饰符：

abstractsealed（密封，不允许被继承）（eg-string）static（静态，与多态相反）

->特性（Attribute）：

用于反射和平台调用（代用其他代码）

->成员前

->访问修饰符

publicinternalprivate（默认）（当前项目的当前类中访问）protected（在子类和当前类可以访问）internalprotected（顺序可反过来）

->多态方面的修饰符

virtualabstractoverridesealedstatic

->特性

->外部实现

extern

enum->enumerate

6、this与base

voidfunc（）

{

int*p=malloc（1024）;

MyClassm=newMyClass（）;

}

后台有一个线程专门统计内存使用率

三大类库：

字符串类库，集合类库，文件操作类库

7、String

->构造方法

newstring（char[]）

newstring（char,int）

->常用属性

索引（Chars）str[3]

Length

->常用方法

增：

构造方法

stringInsert（intstartindex,stringvalue）;

stringstring.Join（stringsplitStr,string[]）;

stringReplace（string,string）;//"123".Replace（"2","2222"）;

运算符+

stringstring.Concat（string[]）;//string.Join（"",list）;

stringPadLeft（int,char）;

//在字符串的左边填充一定空格或字符char，直到字符长度为int所表示的长多一样为止

stringPadRight（int,char）;

删：

stringRemove（intstartIndex,intcount）;//"012345".Remove（3,2）;=>"0125"

stringSubstring（intstartIndex,intcount）;//"012345".Substring（3,2）;=>"34"

stringTrim（paramschar[]）;

stringTrimStart（）;

stringTrimEnd（）;

改

首先ToCharArray（）,在Join或Concat或构造函数

stringToUpper（）;

stringToLower（）;

查

boolContains（string）;

intIndexOf（char,int）;

intLastIndexOf（char,int）;//获得文件名：

"C:

\123\456\789.mp3";

intIndexOfAny（char[],int）;//找出字符串中所有的e和a

intLastIndexOfAny（...）;

boolStartsWith（string）;

boolEndsWith（string）;

其他

boolstring.IsNullOrEmpty（string）

string[]Split（char[],StringSplitOptions.RemoveEmptyEntries）;//entry

//"Ihaveadream".Split（''）;

boolEquals（string）;

boolstring.Equals（string,string）;

intstring.Compare（strings1,strings2）;

s1>s21

s1=s20

s1

stringstring.Format（string,object[]）;

8、StringBuilder

->字符串不可变，长期拼接字符串性能较低

->Stringbuilder

Append（string）;

AppendLine（string）;

AppendFormat（"{0}{1}{2}{3}",1,"23","ab",true）;

ToString（）;

string[]File.ReadAllLines（string,Encoding）;

作业

使用冒泡排序，升序排列一个数字数组，和一个字符串数组

第三天

1、答疑

->"A""a""b"=>"b">"A">"a"

MyCompare方法

比较规则由文化决定

一般中文规则与英文规则一致

->this调用成员是默认

classPerson

{

stringname;

publicvoidFunc（stringname）

{

Console.WriteLine（this.name=name）;

}

}

p.Func（"赵晓虎"）;

2、实际开发中，一般方法或API等使用的是数组作为规范，但是实际的使用都是使用集合

->List线性集合长度可变的数组

->增Add（）AddRange（）

->删Remove（T）RemoveAt（int）（Int是索引）

->改可以像数组一样修改//list[9]='123';

->查boolContains（T）

IndexOf（）

->遍历for

foreach（类型临时变量in集合）

{

使用临时变量进行处理

}

->模拟队列：

先进先出

list.Add（）进入

list[i]

list.ReamoveAt（0）

->模拟栈：

先进后出（杯子与奥利奥）

list.Add（）进入

list[list.Count-1]

list.RemoveAt（list.Count-1）

->Dictionary散列集合

->键值对

->为什么要使用这个集合：

为了快速查找

->常用方法

->增Add（键,值）

->删RemoveKey

->改索引dic["dictionary"]="词典";

->查索引

ContainsKey

->遍历（不常用）

foreach（KeyValuePairitemindic）

{

}

//键值对集合，没有顺序

3、文件

->文件是什么？

->就是一堆字节块

->windows环境下文本文件基本格式

->字符集的历史：

ascii->双字节->unicode（utf-16）->utf-8

->ANSI

->unicode

->unicodebigendim

->utf-8

->如何操作

Encoding:

处理字符集

->用什么类能做什么东西

->命名空间：

System.IO;//inputoutput

->FileStream文件流将文件以字节的方式进行读写

->构造方法：

newFileStream（文件路径,FileMode,FileAccess）;

FileMode：

Create、Append、Open

->读写方法：

->intReadByte（）;voidWriteByte（byte）;

->intRead（byte[]buffer,intoffset,intcount）;

voidWrite（byte[]buffer,intoffset,intcount）;

->了解

->voidFlush（）;//清空缓存，写入硬盘

->voidDispose（）;//清空非托管资源

->Position属性//文件处理，指针与文本文件书写一样是有位置的

->StreamReader与StreamWriter专门针对文本文件的读写操作

->读流：

newStreamReader（"文件路径",Encoding）;

->写流

newStreamWriter（"文件路径",boolisAppend,Encoding）;

->读的方法

stringReadLine（）;//读取文件中的一行

stringReadToEnd（）;//读取所有的内容

->写的方法

voidWrite（...）;//写入内容

voidWriteLine（...）;//写入一行文本

->File静态

AppendAllText

AppendAllLines

ReadAllText

ReadAllLines

WriteAllText

WriteAllLines

boolExist（）

->Directory静态

string[]GetFiles（string）//返回指定路径下的所有文件

string[]GetDirectories（string）//返回改路径下的所有子文件夹

boolExist（）

->Path处理路径

获得后缀名

获得文件名

获得没有后缀名的文件名

获得全路径

->FileInfoDirectoryInfoDriverInfo

第四天

1、答疑

->强制类型转换

intnum=10;

doubledNum=num;//double类型所占内存比int大

intnum1=（int）dNum;//确保数据的万无一失

//使用截断的办法

//简单的内存操作

->里氏转换原则

父类变量存子类对象，父类强制转化成对应的子类

myBase=newMySub（）;//对象存储在一个堆内存中,变量myBase在栈里

//引用类型的变量在32位计算机中只占4个字节

->装箱拆箱

装箱：

就是将值类型赋值给引用类型

拆箱：

将存储值类型的引用类型强制转换为对应的值类型

objecto=123;//123在栈里面，o指向堆中

->静态构造方法

classMyClass

{

staticintnum=10;//语法糖

}

classMyClass

{

staticintnum;

staticMyClass（）

{

num=10;

}

}

2、Dictionary效率非常高

->List慢的原因：

一个一个的遍历

->hash算法（哈希算法）

要求一个函数，可以将一个数字变成一个指定范围的数字