C#自学笔记总结

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、变量：
声明变量的语法：
变量类型变量名; 变量名=值;
变量类型变量名=值；

在使用变量的时候要注意：
变量一定要先声明，再赋值，最后使用
例子：

变量的特点：
1、不能够被重复的声明
2、可以被重复的赋值

c#中常用的变量类型
int：整数类型，只能够存放整数负二十多亿正二十多亿
double:小数类型，既可以存放小数，也可以存放整数比int的范围大的多精度在15到16位精确程度说白了小数点后面的位数
string:字符串类型。
char ：字符类型最多能存储一个字符，最少也只能存储一个字符
decimal：金钱类型精度比double的精度还要高 25-26 100000000000

变量的命名：一定要有意义
命名规则： 1 必须以“字母”或_或@符号开头.--不要以数字开头
2 后面可以跟任意“字母”、数字、下划线. 注意: 1）你起的变量名不要与c#系统中的关键字重复. 2）在c#中,大小写是敏感的. 3)同一个变量名不允许重复定义(先这么认为,不严谨)

什么叫做关键字？凡是你写出来之后发现它变成蓝色的，都是关键字关键字就是这个单词 vs已经用了，你就不能再用了

咱们给变量起名字要符合两个规范
1、Pascal：要求你的变量名的首单词的首字母要大写，其余字母都小写 HighSchool 给方法或者类命名
2、Camal：要求首单词的首字母小写，其余首单词字母大写。 highSchool 给变量起名字
camel:首单词小写
bufTracker
myFloat
someVariable

pascal:每个单词首字母都大写
CreateProcess
QueryInterface
SendMessage

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

二、赋值运算符和赋值表达式

=：不是等于的意思，它表示把等号右边的值，赋值给等号左边的变量。

由=号连接的表达式叫做赋值表达式

注意：每个表达式都可以求解出一个值来，对于赋值表达式，我们就认为，等号左边的变量的值就是整个赋值表达式的值。

+号：

如果加号两边有一边是字符串的话，那么这个加号就不再起到相加的作用，而是连接的作用。

报错：语法出现了问题，程序根本不会运行

异常：语法没有问题，但是在程序运行的过程当中出现了错误。就是咱们俗称的bug

占位符：

先挖个坑再填个坑

注意：

1）、占位符一定要从0开始依次递增不许跳跃。

2）、多填坑不会有结果，少填坑会出异常。

3）、按照挖坑的顺序输出

例子:

Console.WriteLine("第一个{0},第二个{1}",1,2); //输出：第一个1,第二个2

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

三、c#中的转义符

转义符就是'\'加上一个特殊的字符，组成了一个具有特殊意义的字符。

\" 表示为一个"

\b 表示退格放在字符串的两端没有效果

\n 表示换行

\t 对其 tab键

\\ 表示为\

@符号

1）、取消\在字符串中的转义作用，使它单纯的表示为\

2)、将字符串原样输出

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

四、运算符

算术运算符：

+ - * / %

由算术运算符连接的表达式叫做算术表达式

在算术表达式中参与运算的操作数的类型必须一致，也必须和结果的类型一致。

如果不一致的话，满足下列条件，会自动发生转换。

1）、类型必须相兼容都是数字

2）、小的转大的

如果是大的变小的话必须使用强制类型转换

语法：

(待转换的类型)要转换的值； 303.6---303 double ---int

int result=(int)303.6;

发生强制类型转换结果会丢失精度

int类型---》double类型 int类型变量*1.0

保留两位小数使用占位符的方式输出在占位符的后面加上：0.00..你想要的位数

对于不兼容的类型间的转换我们使用 Convert这个转换工厂

使用Convert进行转换必须要满足一个条件：面儿上必须过得去。

不管咱们是向控制台输出的，还是从控制台接受的都是字符串类型。

1、一切类型都可以转换成字符串类型 ToString() "123abv"

例子：

2.5.ToString()//输出2.5

详细用法：（含参数）

http://www.cnblogs.com/huangting2009/archive/2009/02/09/1386596.html

2、算术运算符 ++ -- + - * / %

++又分为前加加和后加加 -- 分为前减减和后减减

不管是前加加还是后加加，结果就是变量的值都加了1

不管是前减减还是后减减，结果就是变量的值都减了1

前加加和后加加的区别：

相同点：

不管是前加加还是后加加，结果就是变量的值都加了1

不同点：如果是前加加，那么首先给这个变量的值自身加一，然后再参与运算。

如果是后加加，那么首先拿原值参与运算，运算完成后，自身加一。

在一个表达式中，如果既有一元运算符也有二元运算符首先计算一元运算符，然后再算二元运算符。

因为一元运算符的优先级要高于二元运算符。

一元运算符：指的就是只需要一个操作数就能完成的运算 ++ --

二元运算符：指的就是至少需要两个操作数才能完成的运算。

复合赋值运算符

+= int number=10; number+=10; number=number+10;

-= number-=10; number=number-10;

*= number*=10; number=number*10;

/= number/=10; number=number/10;

%= number%=10; number=number%10;

关系运算符：是用来描述两个事物之间的关系

> < >= <= == !=

由关系运算符连接的表达式叫做关系表达式

逻辑运算符：

逻辑与 &&

逻辑或 ||

逻辑非！

又逻辑运算符连接的表达式叫做逻辑表达式

我们要求逻辑表达式的的两边都要放关系表达式或者bool类型的值

& && | ||

表达式1&&表达式2 如果表达式1为false，则第二个表达式就不再计算了

表达式1||表达式2 如果表达式1为true，则第二个表达式也不再计算了

表达式1&表达式2 两边表达式都要计算

表达式1|表达式2 两边表达式都要计算

& | 这两个逻辑运算符已很少在用，&& || 这两个逻辑运算符用的比较多

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

五、选择结构语句

顺序结构：从上到下一行一行的执行代码不会发生跳跃

判断结构： if if -else

选择结构：if else-ifswitch-case

循环结构：while do-while for

if结构语法：

if(关系表达式或者bool类型的值)

{

代码；

}

执行过程：程序运行到if处，首先判断if后面小括号中的条件，如果条件成立的话，则执行if所带的大括号中的代码。

如果条件不成立的话，则不执行，直接跳过if结构。

特点：有可能一条代码都不会执行。

if-else 语法：

if(关系表达式或者bool类型的值)

{

代码;

}

else

{

代码;

}

执行过程：程序运行到if处，首先判断if后面小括号中的条件是否成立，如果条件成立的话，则执行if所带的大括号中的代码。

执行完成后，跳出if-else结构。

如果if后面小括号中的条件不成立，则执行else中的代码，执行完成后，跳出if-else结构。

特点：最少都会执行一条代码。

if 和if-else的区别：

if用来判断单一的条件，而if-else用来判断两种条件。

if else if的语法

if(关系表达式或bool类型的值)

{

代码;

}

else if(关系表达式或bool类型的值)

{

代码;

}

else if(关系表达式或bool类型的值)

{

代码;

}

else if(关系表达式或bool类型的值)

{

代码;

}

else

{

代码;

}

执行过程：程序首先判断第一个if后面小括号中表达式的值，如果为true的话，则执行该if所带的大括号中的代码，执行完成后，

跳出if else-if结构。

如果该if中的表达式的值为false，也就是不成立，则继续向下判断if中的表达式，只要成立的话，就执行该if所带的大括号中的代码，

执行完成后，跳出if else-if结构，如果所有的if后面的小括号中的表达式都为false，则看该 if else-if结构中有没有else，如果有else的话，则执行else中的代码，如果没有的话，则跳出if else-if结构。什么都不做。

swicth-case：主要针对于多个定值的选择判断

语法：

switch(表达式/变量)

{

case 值1：代码;

break;

case 值2：代码;

break;

case 值3: 代码;

break;

.....

default:代码;

break;

}

执行过程：程序运行到switch处，首先计算小括号内表达式或者变量的值，然后拿这个值依次跟每个case后面

所带的值进行匹配，如果匹配成功，则执行该case中的代码，执行完成后，遇到break，跳出switch-case结构，

如果跟每个case的值都不匹配，就看，当前这个switch-case结构中是否有default，如果有default，则执行default

中的代码，执行完成后，遇到break，跳出当前switch-case结构，如果当前这个switch-case结果中，并没有default，

则什么都不做。

break:跳出switch-case结构。

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

五、异常捕获

try{} catch{}

使用的语法：哪可能出现异常，你就踹它一脚

执行过程：

如果try中的代码出现了异常，则不会继续向下运行，直接跳到catch中，执行catch中的代码

注意：

try和catch中间不允许写任何的代码。

例子：

try
{
Console.WriteLine("请输入整数数字");
int input = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("你刚刚输入的是{0}",input);
}
catch
{
Console.WriteLine("出错了，你输入的不是整数数字");
}
Console.ReadKey();

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

六、变量的作用域

就是你能够访问到这个变量的范围。

变量的作用域是从声明它的那个大括号开始，到第一个大括号结束。

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

七、循环结构语句

while循环的语法：

while(循环条件)

{

循环体;

}

执行过程：程序运行到while处，首先判断while后面小括号中的循环条件是否成立，如果成立的话，

则执行while所带的大括号中的循环体，如果循环条件不成立，则跳出while循环。

循环体执行完一遍后，再去判断循环条件是否成立，如果成立，则继续执行循环体，如果不成立，则跳出当前循环。

一般来说，每个循环中，总有那么一行代码，能够改变循环条件，使循环条件终有一天不再成立。

如果循环当中，没有没有那么一行代码，能够改变循环条件，也就是说，循环条件永远成立，我们

，管这种循环叫做死循环。

while(true)

{

死循环;

}

break:跳出switch-case结构。

跳出当前while循环。

do while循环

语法：

{

循环体;

}while(循环条件);

执行过程：程序从上向下运行，首先执行一遍do中的循环体，执行完一遍后，去判断循环条件是否成立，

如果成立的话，则继续执行do中的循环体，如果条件不成立的话，则不执行循环体。

特点：先执行，再判断

for循环

语法：

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

{

循环体;

}

表达式1：一般为定义循环次数的初始变量

表达式2：循环条件;

表达式3：改变循环条件的那个条件

执行过程：第一次开始执行的时候，首先执行表达式1，声明了一个循环的初始变量，然后执行表达式2，判断

循环条件是否成立，第一次执行循环的时候，并没有执行表达式3，执行完表达式2之后，开始执行循环体，

执行完循环体之后，开始执行表达式3，然后执行表达式2，判断循环条件是否成立，如果成立的话，则执行循环体，

如果不成立的话，则跳出for循环。

当咱们已经知道循环次数的时候使用for循环。

如果不知道循环次数，而知道循环条件是一个关系表达式或逻辑表达式的时候，只能使用while或者do-while循环。

break:

一般配合着if来使用，当满足某个条件的时候，才break跳出循环。

只能跳出break当前所在的那个循环，不能跳出所有的循环。

（例如：跳出当前整个for循环，而非当次for循环，如果外面有for循环，则只跳出里面的for循环）

例子：

for(var i=1;i<=10;i++)
{ if(i==6) break;
document.write(i);
}
//输出结果：12345

Continue语句：

立即结束本次循环，判断循环条件，如果成立，则进入下一次循环，否则退出循环

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

八、关于int.TryParse()方法：

例子：

把用户输入的数字转换成我们想要的数字类型，如何做？

可以用Convert.ToInt32("3");

还可以用int.Parse("3");

另外一个方法：

int num = 0;

int.TryParse("3",out num);

具体使用参见下面:

string str = "123abc"; //int number = Convert.ToInt32(str);//把字符串转换为数字 //int number = int.Parse(str);//跟上一行语句功能一样是把字符串转换为数字 //但是，Convert.ToInt32(str)其实调用的是int.Parse(str)方法， //所以int.Parse(str)的效率会高一点点 int number = ; bool b = int.TryParse(str,out number); Console.WriteLine(number); Console.WriteLine("转换结果{0}",b); Console.ReadKey();

bool b = int.TryParse(str, out number);

执行过程：

尝试着将一个字符串类型的变量转换成int类型，如果转换成功的话，首先返回一个true，则将转换成功后的那个int类型的值

放到out后面的那个int类型的变量中保存，如果转换失败的话，则返回一个false，并且将number赋值为0

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

九、三元表达式：语法

表达式1？表达式2：表达式3

执行过程：表达式1一般为关系表达式，如果表达式1为true，则表达式2的值就是整个三元表达式的值。

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

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

引申开来，求三数字的最大数：

//要求用户输入两个数字并且比较大小
Console.WriteLine("请输入第一个数字：");
int numberOne = Convert.ToInt32(Console.ReadLine());
//此处如果ReadLine改为Read,则读取的是Char字符而不是String字符串，
//并且用户输入字符的话会转为ASCII码的数字值
Console.WriteLine("请输入第二个数字:");
int numberTwo = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入第三个数字:");
int numberThree = Convert.ToInt32(Console.ReadLine()); //求三个数字谁最大
int max = (numberOne > numberTwo ? numberOne : numberTwo) > numberThree ? (numberOne > numberTwo ? numberOne : numberTwo) : numberThree;
Console.WriteLine("这两个数字中必较大的是{0}", max);
Console.ReadKey();

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

十、枚举类型

好处：就是方便咱们来写代码

语法:

[public] enum 枚举名

{

值1,

值2,

值3,

......

}

public:访问修饰符访问的权限公开的，公用的，没有访问权限，谁都能访问。

enum：声明枚举的关键字

枚举名：要符合命名规范

枚举类型可以跟int类型互相转换，每个枚举类型都可以用一个int类型来表示

将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用这个枚举。

枚举就是一个变量类型，int--double string decimal.
只是枚举声明、赋值、使用的方式跟那些普通的变量类型不一样。

枚举类型默认是跟int类型相互兼容的，所以可以通过强制类型转换的语法互相转换。
当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来。
枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用ToString().
如果将字符串转换成枚举类型则需要下面这样一行代码：
(要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),"要转换的字符串");
如果转换的字符串是数字，则就算枚举中没有，也会不会抛异常。
如果转换的字符串是文本，如果枚举中没有，则会抛出异常。

例子：

/// <summary>
/// 声明一个枚举
/// </summary>
public enum QQState
{
OnLine = ,
OffLine,
Leave,
QMe,
Busy
} public enum Sesons
{
春,
夏,
秋,
冬
}
static void Main(string[] args)
{
//int number = 10;
//QQState state = QQState.OnLine;
//int n = (int)state;
//Console.WriteLine(n);//输出:1,如果OnLine等俱不赋值，则从零开始依次递增
//Console.ReadKey();
#region 将枚举类型强转为int类型
//Console.WriteLine((int)QQState.OnLine);//输出:1
//Console.WriteLine((int)QQState.OffLine);//输出:2
//Console.WriteLine((int)QQState.Leave);//输出:3
//Console.WriteLine((int)QQState.QMe);//输出:4
//Console.WriteLine((int)QQState.Busy);//输出:5
#endregion
#region 将int类型强转为枚举类型
//int number = 10;
//QQState state = (QQState)number;
//Console.WriteLine(state);//输出10，如果number赋值1则显示OnLine,超出枚举内范围则直接显示赋值数值
//Console.ReadKey();
#endregion
#region 将枚举类型转换为字符串
//QQState state = QQState.OnLine;
//Console.WriteLine(state.ToString());
//Console.ReadKey();
//int number = 10;
//double d = 3.14;
#endregion
#region 字符串类型也可以转换为枚举类型
//string str = "10";
//QQState state = (QQState)Enum.Parse(typeof(QQState), str);
//Console.WriteLine(state);
//Console.ReadKey();
#endregion
#region 枚举练习
Console.WriteLine("请选择你的在线状态 1---在线 2--不在线 3--离开 4--Q我吧 5---忙碌");
string input = Console.ReadLine();
switch (input)
{
case "": QQState state = (QQState)Enum.Parse(typeof(QQState), input);
Console.WriteLine("您选择的在线状态是{0}", state);
break;
case "": QQState stateTwo = (QQState)Enum.Parse(typeof(QQState), input);
Console.WriteLine("您选择的在线状态是{0}", stateTwo);
break;
case "": QQState stateThree = (QQState)Enum.Parse(typeof(QQState), input);
Console.WriteLine("您选择的在线状态是{0}", stateThree);
break;
case "": QQState stateFour = (QQState)Enum.Parse(typeof(QQState), input);
Console.WriteLine("您选择的在线状态是{0}", stateFour);
break;
case "": QQState stateFive = (QQState)Enum.Parse(typeof(QQState), input);
Console.WriteLine("您选择的在线状态是{0}", stateFive);
break;
default: Console.WriteLine("请输入正确的数字");
break;
}
Console.ReadKey();
#endregion

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

十一、声明常量

声明常量的语法：

const 变量类型常量名=值;

常量一旦声明了，就不能被改变了。

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

十二、结构体

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

结构的语法：

[访问修饰符] struct 结构名

{

变量。。。/方法/属性

}

访问修饰符：public

struct：声明结构的关键字

例子：

public struct Person { public string Name; public int Age; public string Hobby; public int Popularity; public void SayHi() { // …. } }

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

十三、字段和变量本质的区别：

字段在程序运行的时候可以存储多个值，而变量，只能存一个值。

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

十四、数组：

当你需要一次性声明多个相同类型的变量的时候？

数组

声明数组的语法：

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

数组的长度如果固定了，那么就不能再改变了

声明数组的四种形式：

int[] nums=new int[10];只声明了数组的长度和类型，并没有给数组赋值

int[] nums={1,2,3,4,5,6,7,8,9,0}; 再声明数组的同时，及确定了数组的类型、长度以及数组中的元素的值

===================================================================================

int[] nums=new int[5]{1,2,3,4,5}; 注意：这个数组的长度是几，那么你元素的个数也得是几

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

最后两种不建议使用，容易出错或者繁琐

对错：

int[] nums = new int[3]{5,3,8}//个数和声明数必须一致

int[] nums = new int[5]{5,3,8}//错误

int[] nums = new int[]{5,3,8}//正确,可以省略数组个字

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

十五、冒泡排序法：

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

冒泡排序:将一个数组从大到小或者从小到大进行排序

数组从大到小：降序排列

从小到大：升序排列

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

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

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

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

第五趟：4 3 2 1 0 5 6 7 8 9 第五趟比较比较了5次 i=4 j=5

第六趟：3 2 1 0 4 5 6 7 8 9 第六趟比较比较了4次 i=5 j=4

第七趟：2 1 0 3 4 5 6 7 8 9 第七趟比较比较了3次 i=6 j=3

第八趟：1 0 2 3 4 5 6 7 8 9 第八趟比较比较了2次 i=7 j=2

第九趟：0 1 2 3 4 5 6 7 8 9 第九趟比较比较了1次 i=8 j=1

//外层循环控制比较的趟数 for(int i=;i<numbers.Length-;i++) { //两两比较交换 for(int j=;j<numbers.Length--i) { if(numbers[j]>numbers[j+]) { int temp=numbers[j]; numbers[j]=numbers[j+]; numbers[j+]=temp; } } }

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

十六、方法：

1、方法。目的：就是将一坨代码进行重用的一种机制。

语法：

[访问修饰符] static 返回值类型方法名([参数列表])

{

方法体;//

return 返回值

}

访问修饰符：访问的权限现阶段咱们都写成public

static：静态的。现阶段写的方法全都写成静态的。

返回值类型：如果这个方法没有返回值则写一个void，如果有返回值，则写对应的返回值的类型

方法名：必须要符合Pascal 每个单词的首字母都要大写。

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

方法写完后，还要在Main()方法中调用。

调用方法的语法：

类名.方法名();

注意：如果你写的方法跟Main()方法在同一个类中（Program）,那么在调用方法的时候，可以省略类名

直接写方法名。

return:

1、返回要返回的值

2、结束当前方法的运行

方法的功能一定要单一。

当方法要返回多个不同类型的值回来的时候，使用out参数。

使用out参数需要注意：

out参数在方法内必须要为其赋值，在方法外，可以不为其赋值。

out参数侧重于返回多个参数。

ref参数侧重于:将一个值带入一个方法内进行改变，改变完成后，再将这个值带出来。

使用ref参数需要注意：

ref参数在方法外必须为其赋值

1、方法的重载。
所谓方法的重载指的就是方法的名字相同，但是参数不同。
参数不同有两种情况：
1、如果参数的类型相同，那么参数的个数就不能相同。
2、如果参数的个数相同，那么参数的类型就不能相同。

params 的用法：

params 构造函数声明数组而不知道数组长度用的
在方法声明中的 params 关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params 关键字。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace ConsoleApplication7
{
class Program
{
public static void UseParams(params int[] list)
{
for (int i = ; i < list.Length; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
}
public static void UseParams2(params object[] list)
{
for (int i = ; i < list.Length; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
}
static void Main()
{
UseParams(, , );
UseParams2(, 'a', "test");
// An array of objects can also be passed, as long as
// the array type matches the method being called.
int[] myarray = new int[] { , , };
UseParams(myarray);
Console.ReadKey();
}
}
}

更多方法的用法：http://www.cnblogs.com/yank/archive/2012/09/12/2663793.html

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

十七、对象：

1、面向对象

面向过程：

不管是面向对象还是面向过程都是咱们日常生活中的思考方式

1、c语言(面向过程)

2、c# java （两个都是面向对象）

面向过程：把大象装进冰箱里

1、打开冰箱门

2、把大象放进去

3、关闭冰箱门

面向过程：注重的是过程，强调的是动作。

面向对象：

我去中关村买电脑

1、先搞清楚我要的配置

2、去买

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

总结：

咱们在日常生活中描述一个对象的时候，通过描述这个对象的特征和行为来描述这个对象。

在咱们面向对象的思想中。

这个对象的特征我们管它叫做属性。

这个对象的行为我们管它叫做方法。

对象一定是特指：

对象一定是真真正正存在的看得见的摸的着的。

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

十八、类：

我们在描述一些对象的时候发现，这些对象具有共同的属性和方法。

我们将这些具有共同属性共同方法的对象进行进一步的抽象，提取出了

类这个概念。

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

//类里面可以写什么呢？

字段、属性、方法、索引器 (不能在类里调用方法，方法的本体可以写在类里面，如果要调用方法，可以把调用方法写在方法里)

类中的成员，需要使用对象去调用(静态的除外)

类 ---》对象？

我们管创建对象的这个过程叫做类的实例化。

类中的成员，如果不写访问修饰符，默认为private

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

this的用法：

1、代表当前这个类的对象

2、显示的调用当前类的构造函数

显示的调用当前类的构造函数的例子：

public class Student
{
string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
char _gender;
public char Gender
{
get { return _gender; }
set {
if (value != '男' && value != '女')
{
_gender = '男';
}
else
{
_gender = value;
}
}
}
int _age; public int Age
{
get
{ if (_age < || _age > )
{
return _age = ;
}
else
{ return _age;
}
}
set { _age = value; }
} /// <summary>
/// 类的构造函数初始化对象用的
/// </summary>
/// <param name="name"></param>
/// <param name="age"></param>
/// <param name="gender"></param>
/// <param name="chinese"></param>
/// <param name="math"></param>
/// <param name="english"></param>
public Student(string name, int age, char gender, double chinese, double math, double english)
{
this.Name = name;
this.Age = age;
this.Gender = gender;
this.Chinese = chinese;
this.Math = math;
this.English = english;
} public Student(double chinese, double math, double english):this(null,,'\0',chinese,math,english)// 显示的调用当前类的构造函数
{ } public Student(string name, int age, char gender):this(name,age,gender,,,)
{ } public Student(string name, int age, char gender, double chinese):this(name,age,gender,chinese,,)
{ } public Student()
{ } public Student(double chinese)
{
if (chinese < || chinese > )
{
chinese = ;
}
this.Chinese = chinese;
} double _chinese; public double Chinese
{
get { return _chinese; }
set { _chinese = value; }
} double _math; public double Math
{
get { return _math; }
set { _math = value; }
} double _english; public double English
{
get { return _english; }
set { _english = value; }
}
// 一个打招呼的方法：介绍自己叫XX，今年几岁了。是男同学还是女同学。
public void SayHello()
{
Console.WriteLine("大家好，我叫{0},我几年{1}岁了,我是{2}生", this.Name, this.Age, this.Gender);
} //两个计算自己总分数和平均分的方法。{显示:我叫XX,这次考试总成绩为X分,平均成绩为X分} public void GetScore()
{
Console.WriteLine("我叫{0},我的总成绩为{1},我的平均成绩为{2:0.00}", this.Name, this.Chinese + this.Math + this.English, (this.Chinese + this.Math + this.English) / );
} }

属性的作用：属性快捷键（按Ctrl+R,E快捷键）

1、主要是保护字段，对字段的取值和赋值进行限定

属性本质上有两块内容组成，一块叫get，一块叫set，通过反编译会发现，这个get和set本质上都是一个方法。

既有get也有set的属性叫做可读可写属性，表示既可以给这个属性赋值，也可以给这个属性取值。

只有get的属性叫做只读属性，表示只能读取这个属性，而不能给这个属性赋值。

只有set的属性叫做只写属性，表示还能给这个属性赋值，而不能给这个属性取值。

需要记住的三个单词

fields：字段

Methods:方法

Properties:属性

在咱们类中字段就是女人（不对外）属性就是男人(对外)

类中的成员，如果不加访问修饰符，默认为private

构造函数：构造函数就是一个特殊的方法而已。

1)、构造函数的方法名跟类名一致

2)、构造函数没有返回值，并且连void也不能有

作用：初始化对象

注意：

在你写号了一个类之后，这个类会有一个默认的无参数的并且咱们看不见的构造函数

当咱们在类中写了一个新的无参数的构造函数之后，那个默认的无参数的构造函数就没了，就被干掉了

new到底做了什么事情？

1、在内存的堆中开辟空间

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

3、调用这个对象的构造函数

项目之间类的引用

如果在一个项目中，需要引用到其它项目的类，需要以下几个步骤：

1、添加引用

2、引用命名空间

什么是静态什么是非静态

区别：

1、在非静态类中能不能出现静态成员? 答：可以。

2、非静态成员和静态成员在调用上的一些区别。

答：

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

非静态成员在调用的时候，需要使用对象名.非静态成员名.

*：对象名不能点出来静态成员。

类名也不能点出来非静态成员。

3、静态类中能不能出现非静态成员?

答：不可以。静态类中不允许出现非静态的成员。

静态类中只能有静态的成员。

静态类不允许创建对象

静态方法中不能使用非静态的字段。而非静态的方法中既可以有静态字段，也可以有非静态字段。

静态和非静态的总结：

静态成员中，绝对不允许出现非静态的成员。并且在调用的时候，不能创建静态类的对象，只能使用类名.静态成员名;

非静态成员中，既可以有静态成员，也可以有非静态成员。在非静态成员中，既可以访问到静态成员，也可以访问到

非静态成员。

非静态类访问非静态成员需要使用对象名.非静态成员名

非静态类访问静态成员需要类名.静态成员名。

什么时候使用静态类，什么时候使用非静态类？

1、当你写的类需要被实例化的时候，只能使用非静态类。

2、我们一般把静态类作为工具类来使用。最常见的静态类就是咱们的Console类

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

十九、字符串:

1、字符串可以看做是char类型的只读数组，可以通过下标去访问字符串中的某一个元素，但是不能给这个元素赋值。因为她

是只读的。

2、

将字符串转换成char数组调用 ToCharArray()

将char数组转换成字符串调用new string(要转换的char数组);

例子：

//以下是错误代码
//string str = "abcdefg";
////char ch = str[2];
////ch = 'd';
//str[2] = 'd';
//Console.WriteLine(str[2]);
//Console.ReadKey();
//以上是错误代码，不能给字符串赋值，只能读取 string str = "abcdefg";
//就要将这个字符串中的c改变成d //首先要将这个字符串转换成char类型的数组
//字符串可以调用ToCharArray这个方法，将自己转换成char类型的数组
char[] chs = str.ToCharArray();
chs[] = 'd';
//for (int i = 0; i < chs.Length; i++)
//{
// Console.WriteLine(chs[i]);
//} //将字符数组转换成字符串
//用这个字符数组调用new string();
str = new string(chs);
Console.WriteLine(str);
Console.ReadKey();

1、所谓字符串的不可变性，指的就是字符串一旦声明了，它的值就不能再被改变了，

如果你改变了这个字符串的值，其实就是在堆中又重新开辟了一块空间。老值还在。

2、引用命名空间的快捷键：alt+shift+F10

3、string类型在进行重复的拼接赋值操作的时候，之所以速度慢，效率低，是因为它在内存的堆中不停的开辟空间，

而StringBuilder之所以速度快，效率高，是因为在整个的拼接、赋值操作中，它只是操作的一块内存，并没有再单独的

开辟新空间。

StringBuilder的实现和技巧：

string的替代解决方案就是StringBuilder的使用..它的使用也很简单System.Text.StringBuilder sb = new System.Text.StringBuilder();这样就初始化了一个StringBuilder ..之后我们可以通过Append()来追加字符串填充到sb中..在你初始化一个StringBuilder 之后,它会自动申请一个默认的StringBuilder 容量(默认值是16),这个容量是由Capacity来控制的.并且允许,我们根据需要来控制Capacity的大小,也可以通过Length来获取或设置StringBuilder 的长度..

先来看Length的用法：

System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append( "" );//添加一个字符串
sb.Length = ;//设置容量为3
Console.WriteLine( sb.ToString() );//这里输出:123 sb.Length = ;//重新设置容量为30
Console.WriteLine( sb.ToString() + ",结尾");//这里在原来字符串后面补齐空格,至到Length的为30
Console.WriteLine( sb.Length );//这里输出的长度为30

通过上面的代码,我们可以看出如果StringBuilder 中的字符长度小于Length的值,则StringBuilder 将会用空格硬填充StringBuilder ,以满足符合长度的设置..如果StringBuilder 中的字符长度大于Length的值,则StringBuilder 将会截取从第一位开始的Length个字符..而忽略超出的部分..

更多关于StringBuilder方法：http://lixianhuei.cnblogs.com/archive/2005/12/27/305708.html

4、字符串的属性 Length 获得该字符串的长度

5、将一个字符串转换成大写调用这个字符串的 ToUpper()方法。返回这个字符串的大写形式。

将一个字符串转换成小写，调用这个字符串的ToLower()方法。返回这个字符串的小写形式。

将一个字符串跟另一个字符串比较值是否相等，可以调用字符串的Equals这个方法，在括号中填入StringComparison.OrdinalIgnoreCase)

可以忽略大小写的比较。

6、分割字符串 Split() 将字符串按照指定的字符分割，返回一个字符串类型的数组

注意的地方：

Split(new char[]{'要分割的字符','要分割的字符','要分割的字符'},StringSplitOptions.RemoveEmptyEntries);

StringSplitOptions.RemoveEmptyEntries:移除这个字符串数组中的空项

例子：

string strNumber = "1 2 3 4 5 6 7 8 9";
string[] nums = strNumber.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);//去除空格符
for (int i = ; i < nums.Length; i++)//遍历输出nums数组中的所有元素：123456789
{
Console.Write(nums[i]);
}
Console.WriteLine();
Console.WriteLine(nums);//输出System.String[]
Console.ReadKey();

7、Replace 将一个老字符串替换成一个新的字符串

Contains 判断一个字符串中是否包含一个子字符串如果包含返回true 否则返回false

例子：

//字符串的替换
string str = "老字符";
str = str.Replace(str, "新字符");
Console.WriteLine(str);
Console.ReadKey(); //判断是否包含
string str = "今天天气好晴朗处处好风光";
if (str.Contains("天好"))
{
Console.WriteLine("包含");
}
else
{
Console.WriteLine("不包含");
}
Console.ReadKey();

8、SubString()截取字符串

例子：

substring() 用法
string a="aadsfdjkfgklfdglfd"
a.substring() //截取从第五位开始到以后的所有字符串
a.substring(,) //截取从第0到第5 之前含第5的所有字符串 string str = "老赵买的这个手机肯定是真的，钓丝都说是假的";
str = str.Substring(, );
Console.WriteLine(str);//输出:买的这个手
Console.ReadKey();

9、StartsWith()以....开始

EndsWith() 以.....结束

例子：

判断字符串的开头是否与指定的字符串相同。
比如：
string s = "aabbcc";
那么s.StartsWith("aabb")，返回true；
而
s.StartsWith("aabc")，返回false；

10、Index Of 查找字符或者字符串在一个字符串中出现的位置如果返回一个-1，表示当前字符串中找不到该字符或者字符串。

11、Last IndexOf 查找一个字符在字符串中最后一次出现的位置，只要找不到那个字符，就返回一个-1

例子：

IndexOf()
查找字串中指定字符或字串首次出现的位置,返首索引值，如：
str1.IndexOf("字")； //查找“字”在str1中的索引值（位置）
str1.IndexOf("字串")；//查找“字串”的第一个字符在str1中的索引值（位置）
str1.IndexOf("字",start,end)；//从str1第start+1个字符起，查找end个字符，查找“字”在字符串STR1中的位置[从第一个字符算起]注意:start+end不能大于str1的长度

indexof参数为string,在字符串中寻找参数字符串第一次出现的位置并返回该位置。如string
s="0123dfdfdf";int i=s.indexof("df");这时i==4。

indexof()
：在字符串中从前向后定位字符和字符串；所有的返回值都是指在字符串的绝对位置，如为空则为-
1

string
test="asdfjsdfjgkfasdsfsgfhgjgfjgdddd";

test.indexof(’d’)
=2            //从前向后定位 d 第一次出现的位置
   test.indexof(’d’,1)
=2           //从前向后定位 d 从第二个字符开始第一次出现的位置

test.IndexOf('d', 3) =6 //从前向后定位 d 从第四个字符开始第一次出现的位置
test.indexof(’d’,5,2) =6
//从前向后定位 d 从第5 位开始查，查2位，即从第5位到第7位；

lastindexof()
：在字符串中从后向前定位字符和字符串、用法和
indexof() 完全相同。

12、去掉字符串两端的字符，Trim()是去掉两端的 TrimEnd()是去掉字符串结尾的 TrimStart()是去掉字符串开始的

例子：

//trim();
void DelSpace()
{
string strWithSpace = " this is a string with space ";
string strWithoutSpace = strWithSpace.Trim();
Console.WriteLine(strWithoutSpace);
Console.ReadKey();
}

上面的程序的作用是将字符串strWithSpace前后的空格去掉，输出"this is a string with space"。

trimStart();

用于删除字符串前面的空格

以下是代码片段：
void DelSpace()
{
string strWithSpace = " this is a string with space ";
string strWithoutSpace = strWithSpace.TrimStart();
Console.WriteLine(strWithoutSpace);
Console.ReadKey();
}

上面的程序的作用是将字符串strWithSpace前面的空格去掉，输入"this is a string with space "

//trimEnd();
void DelSpace()
{
string strWithSpace = " this is a string with space ";
string strWithoutSpace = strWithSpace.TrimEnd();
Console.WriteLine(strWithoutSpace);
Console.ReadKey();
}

上面的程序输出" this is a string with space"

删除指定的字符

Trim()方法还可以删除指定的字符串

char[] trimChars = {" ","e","g"};
string strA = strA.trim(trimChars);

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

二十、类的继承等：

13、我们把这些具有相同属性和相同方法的类，进行进一步抽象的封装，提取出了父类这个概念

父类（基类），子类（派生类）

14、继承：减少代码的冗余说白了少写点代码

特性：

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

2、传递性：如果爹继承了爷爷，并且孙子继承了爹，那么孙子和爹都能使用到爷爷的东西。啃老族。

15、子类究竟从父类那里继承过来了什么？

子类从父类那里继承了属性和方法子类并没有继承父类的私有字段。

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

当你在父类中写了一个新的构造函数之后，默认的无参数的就没了，此时子类就

调不到那个父类中默认的无参数的构造函数了。

解决方法有两个：

1、在父类中，再加一个无参数的

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

例子：

class Program
{
static void Main(string[] args)
{
// Student s = new Student(); }
} public class Person
{
string _name; public string Name
{
get { return _name; }
set { _name = value; }
} int _age; public int Age
{
get { return _age; }
set { _age = value; }
} char _gender; public char Gender
{
get { return _gender; }
set { _gender = value; }
} public Person(string name, int age, char gender)
{
this.Name = name;
this.Age = age;
this.Gender = gender;
} public Person()
{ } public void CHLSS()
{
Console.WriteLine("作为一个人类，你还要回吃喝拉撒睡");
}
} public class Student : Person
{
int _id; public int Id
{
get { return _id; }
set { _id = value; }
} /// <summary>
/// 显示的调用父类的构造函数
/// </summary>
/// <param name="name"></param>
/// <param name="age"></param>
/// <param name="gender"></param>
/// <param name="id"></param>
public Student(string name, int age, char gender, int id)
: base(name, age, gender)
{ this.Id = id;
} public void Study()
{
Console.WriteLine("学生会学习");
}
}