c#笔记2

类型转换

1、几种类型转换？

隐式转换、显示转换

2、特点

隐式转换系统默认，有低到高（范围小到范围大，精度低到精度高，不会出错）

显示转换必须明确指定要转换的类型，而且有出错的可能，一般是溢出错误和格式不正确错误

 

嵌套

嵌套：就是一层里面还有一层。

if语句中间可以包含n个if语句这种情况就称为：“嵌套”

嵌套if语句执行的流程：

先执行外层的if如果成立则执行内层的if语句。如果里面还包含if语句则还是这样执行。

PS：一个if语句只能对应一个else语句，而且只和最近的else语句匹配。所以在写if语句时一定要注意括号，否则当if语句较多时很容易出现匹配不当的情况，这种情况不属于语法错误，属于语义错误。

小窍门：书写if语句时当if后面的布尔表达式写完后立即回车换行然后打上一对大括号，然后光标回去一格然后回车。如果发现括号不匹配了，那么请首先找到左边的折叠标识进行折叠，这样能够帮助我们快速的找到括号不匹配的问题。

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

嵌套if语句是当需要层层递进的判断时就使用if语句的嵌套

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

注意这里的并不是绝对的：

当出现嵌套if语句的逻辑时如果可以更加清晰话那么就改为多分支if语句

如果多分支if语句逻辑更加模糊的话那么就使用嵌套。

这样的事情称为：“代码优化”

什么是switch？

switch语句可以判断很多条件，适合从一组互斥的分支中选择一个分支执行。

语法说明

switch语句后面的表达式必须是一个变量

case 后面必须是常量，它的类型一定和switch表达式的类型一致。

default语句是可以省略的，如果有那么就只能有一个。

switch表达式的数据类型只能是：整数，字符，字符串，布尔，枚举

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

switch语句的贯穿用法：

多个条件不同，但是执行一样这种情况下我们就可以使用switch的“贯穿”

虽然使用if也可以做到但是如果要判断的条件仅仅是等于关系那么使用switch会更加清晰容易阅读

程序的三种结构：

1、顺序

2、选择（判断）

3、循环

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

什么是循环？

1、不断的重复进行--》循环

2、直到某条件不成立终止循环---》循环结束

3、如果条件永远成立则为“死循环”

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

两种情况：

1、先判断再执行（循环）

2、先执行一次再判断，条件为真则继续执行直到条件为假退出循环

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

C#中的四种循环语句

1、while(循环)

2、do...while（循环）

3、for（循环）

4、foreach（循环）

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

while循环是一种当型循环，就是当条件满足为真时执行循环，当条件不满足为假时退出循环。

while(布尔表达式)

{

      //循环体语句

}<----不用写分号结束

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

循环的核心是控制循环的次数，所以一般使用整数进行控制，例如：int i;

循环的三要素：

1、初始部分：从哪里开始

2、终止条件：到哪儿结束

3、迭代部分：循环语句体的执行

条件虽然不同判断是一样都是等于而且执行也是一样的那么就可以使用switch

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

多分支if语句与switch语句相同点：

1、都能实现多分支选择

2、多分支if语句和switch语句都能实现不需要层层递进判断的多分支

多分支if语句与switch语句不同点：

1、嵌套语句语法复杂、有代码冗余、结构容易混乱，但是层层递进逐步判断只能使用嵌套

2、switch语句语法简洁，但是只能判断相等关系，不能判断区间。

3、除了层层递进和相等关系就选择多分支if语句

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

注意：

switch语句中每个case后面的常量值必须唯一，否则语法错误

case后面必须跟上break退出case，如果不写就会出语法错误

使用贯穿case时在最后一个case后面写上break退出否则语法错误

default语句是可以省略的，如果有那么就只能有一个。

while循环语句其实最适合做次数不确定的循环，

但是却知道什么条件才终止循环的场景。

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

while中表达式可以逆向判断，也就是说可以进行取反的判断，使用关系运算符中的(!=)不等于运算可以进行取反的操作。

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

除非我们有意引入死循环，否则一定要在程序中避免死循环。

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

do...while循环是先执行一次循环体语句然后在判断循环条件是否为真。

使用场景：

当需要无论什么情况都要先执行语句然后在确定是否循环的情况下，使用do...while循环会更适合。

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

语法：

do{

   //循环体语句    

 

}while(布尔表达式); <---这里一定不要忘记了分号结束语句

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

do...while循环至少会执行一次。while循环可能一次都不执行

while是先判断再执行，do...while是先执行一次或多次再判断是否循环

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

死循环产生的必要条件:就是循环终止条件永不为假。

Console.

1、Clear<---清屏

2、WindowHeight<---设置黑屏幕的高度

3、WindowWidth<---设置黑屏幕的宽度

4、BufferHeight<---设置屏幕缓冲区的高度

5、BufferWidth<---设置屏幕缓冲区的宽度

6、ForegroundColor<---设置前景色

7、BackgroundColor<---设置背景色

8、Beep<---播放指定频率和时长的声音

9、SetCursorPosition<---设置屏幕光标的位置的方法（函数）

10、CursorLeft<---光标距离黑屏左边的多少字符

11、CursorTop<---光标距离黑屏顶部的多少字符

回顾

while和do...while区别？

1，while是先判断后执行，有可能一次都不循环

2，do...while是先执行一次循环，然后在判断是否执行循环，所以无论如何都会执行至少一次。

3，while和do...while都适合于不知道循环次数的循环

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

for语句？

for循环语句也叫“迭代语句”

名词解释：迭代

迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。

重复执行一系列运算步骤，从前面的量依次求出后面的量的过程。此过程的每一次结果，都是由对前一次所得结果施行相同的运算步骤得到的。例如利用迭代法*求某一数学问题的解。

对计算机特定程序中需要反复执行的子程序*(一组指令)，进行一次重复，即重复执行程序中的循环，直到满足某条件为止，亦称为迭代。

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

for语句也称为：计数器循环语句

for语法：

for（表达式1;表达式2;表达式3）

{

    循环语句

}

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

在同一个作用范围内不能声明相同变量名的变量，因为这样会产生二义性。编译器将不能识别。

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

for语句中三个表达式的作用：

表达式1作用是赋初值，仅在开始执行一次

表达式2每次都会执行，用于判断是否终止循环

表达式3作用是对表达式1的变量进行累加或递减，第一次不会执行，以后每次都会执行直到循环终止

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

for可以有四种表现形式

1，for (i = 1; i <= max; i++)  <---基本用法

2，int i=0;

for (; i <= max; i++) <---第二种

3, for (i = 1; i <= max; ){i++;} <---第三种

4，for (i = 1; ; i++) <---第四种

   {

      if (i <= max)

       {  //语句}

      else{break;}

   }

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

while、do...while、for相同点

1、都是循环语句，有固定的语法

2、都是有循环条件和循环体构成

3、循环的核心都是控制好循环的次数，次数又由三点决定：

 a、初始部分

 b、终止条件

 c、迭代部分

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

while、do...while、for不同点

1、while、do...while适合用于循环次数未知的情况，for循环适合循环次数确定的情况

2、while、do...while初始部分通常在开始之前就完成了，for循环则是在语法表达式的表达式1部分完成

3、while、do...while循环的迭代是在循环体中完成，for循环是在语法结构的表达式3部分完成，for循环是将三要素同时写在for后面的小括号中

4、while和for是先判断在执行，如果条件一开始就不成立，则循环一次都不执行。do...while先执行在判断，无论条件是否成立最少执行一次。

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

注意：

for语句中三个表达式，如果为空也必须使用;号进行站位。如果缺失则语法错误

 

C#中的循环语句学习了三种

1、while循环

2、do...while循环

3、for循环

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

while和do...while

用于不确定次数的循环

for用于确定次数的循环

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

for循环是属于最灵活的循环语句

因为for语句四种形式的用法，所以是非常灵活

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

1、输出实心矩形

思路：

首先将控制台屏幕看成一个平面的二维表格，

矩形是由行和列组成，那么我们可以使用循环语句进行输出，

首先循环行，为什么要先循环行，因为我们的习惯是从行开始，而每行都会包含列，因为行在习惯中是不确定的，列是确定的，因为人的视角宽度是有限的，横向阅读一定会有一个终点，但是纵向可以无限向下延伸。这也是当前所有网页、表格、文档的习惯。

这里要搞清楚的是行是向下是纵向的，列横向的。

然后在每行的基础上去循环列，同时输出，当每行中的列输出完成后，一定要换行。

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

2、输出空心矩形

空心矩形就是将实心矩形中间给挖出（输出空格取代*号）

思路：

在第一行时是全部输出

在最后一行也是全部输出

但是在第二行一直到倒数第二行都是第一列和最后一列输出*号，其他的都是空格

跳转语句

通俗的说就是从一个地方跳到另一个地方。

是属于流程控制语句中的一种，用于无条件的转移控制

C#中提供了四种跳转语句

1、continue：立即终止当前这一次循环，进入下一次循环。（仅用于各种循环语句，只能作用于包裹它的循环）

2、break：立即终止当前循环或退出switch语句（仅用于各种循环语句和switch语句，只能作用于包裹它的循环或switch）

3、goto：无条件跳转，可以跳转到任意指定标签位置。（可以构成循环效果）现代编程中是严禁使用

使用goto语句的地方一般是在受限设备中，例如：各种芯片中使用，因为芯片中的空间有限通常只有几k或几十k的空间

4、return：立即跳出当前（包裹return）函数，不会执行return后面的语句，函数也会立即终止执行。

return语句也是用于终止函数执行的语句

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

continue、break、return这三个跳转语句后面的代码是不会执行的，因为这三条语句已经跳转到别处，所以后面的代码等同于失效代码，因此也会称为：检测到无法访问到的代码

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

跳转语句用于无条件的转移控制。

 

什么是数组？

数组是一种结构，是把相同类型的数据按有序的形式组织起来。

通俗的理解：

以苹果举例：

每个苹果都看成一个具体数据，以前是用小盒子（变量）存放，当大量使用时就会不方便，所以如果将要使用苹果全部放到某一个空间中，那么效果就会很好。

这种情况下使用数组进行存放同一种类型的数据就会非常方便。

C#中数组可以分为：

一维数组、多维数组、数组的数组

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

数组的使用步骤：

1、声明数组（数组的类型和数组的名称）

2、创建数组（请求内存空间的分配）

3、初始化数组（给数组中每个空间放一个值）

一维数组的语法：

数据类型[] 数组名称;<-----声明一个数组对象

例如：int[] ages;//声明一组年龄的数组用于存储年龄的值

声明数组时要注意的事情

1、数据类型是C#语言中的任意数据类型

2、数组名称必须满足标识符的命名规范和变量的命名规范是相同的

数组名称 = new 数据类型[数组的长度];<----申请空间，包含多少个同类型的空间（数组长度）

ages = new int[10];<---创建整型数组对象，申请空间用于存放10个整型数据值

创建数组时要注意的事情

1、创建数组时，数组的长度不能省略，长度可以是常量、变量或表达式

2、数组的声明和创建可以合并到一起的。例如：int[] ages = new int[5];//这种写法比较常见

初始化数组

数组名称[索引] = 值;<---为数组的某个空间赋初值

int[] ages = new int[5];//声明并创建一个整型数组

ages[0] = 18;//将18 赋值给ages数组的第0个空间中

ages[1] = 20;//将20 赋值给ages数组的第1个空间中

ages[2] = 13;ages[3] = 22;ages[4] = 19;

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

ages[5] = 10;//这句赋值的代码是错误的。因为ages数组只有5个空间，空间的索引值从0开始

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

数组的索引从0开始因此数组的索引值一定是小于数组的长度，小一个

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

一维数组的动态初始化

语法：

数据类型[] 数组名称 = new 数据类型[]{值1,值2,值3,值4,....值N};

动态初始化时数组会根据初始化值的个数来确定数组的长度。

例如：

int[] ages = new int[]{12,13,23,22,18,16};

一维数组静态初始化

语法：

数据类型[] 数组名称 = {值1,值2,值3,值4,....值N};

例如：

int[] ages = {13,15,16,8,19};

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

元素的默认值：

数组是一种对象类型（属于引用类型），一旦创建对象则系统默认会给出原始初始化值。

int 类型 默认值 0

float 类型 默认值 0.0f

bool 类型 默认值 false

char 类型 默认值 '\u000'(表示一个空字符)

string 类型 默认值  null（对象的默认值就是null）

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

一维数组的访问：

数组名[索引] = 值;//为数组的指定索引的元素赋值

数组名[索引];//获取数组中指定索引的元素值

例如：

int[] ages = new int[5];

赋值：

ages[0] = 20;

取值：

int age = ages[0];//将指定索引位置的元素值取出赋给同类型的变量

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

数组和变量不同

数组的初始化其实是第二次赋值，变量的初始化才是真的第一次赋值

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

注意：

数组的长度是固定的，在C#语言中数组的长度一旦确定是不能更改的。

数组的索引一定小于数组的长度，否则会出现“索引超出了数组界限。”错误

 

一维数组的遍历

遍历：就是将集合内容进行逐个的访问。（例如：课堂上的点名）

是利用循环进行的，是通过数组的索引值进行计数循环，从而达到遍历数组元素的目的。

使用for这种循环进行数组的遍历。

由于for本身是一种计数器循环所以很容易的就和数组的索引值结合，这是天然的结合。通过这种结合就可以轻松的遍历数组中的每一个元素。

for循环遍历一维数组的语法：

for(数据类型 循环变量=0;循环变量 < 数组名.Length;循环变量++){操作数组元素;}

Length：<---长度（数组中表示包含元素的个数）

int[] ages = new int[5];

此时数组的长度就是5，也就是说ages数组中可以存放5个整数。那么ages.Length就是得到ages数组的长度

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

除了for循环经常用于集合的遍历外，C#还提供了foreach这种针对集合遍历的语句，方便我们对各种集合进行遍历

语法：

foreach(数据类型 循环变量 in 数组名称){语句块;}

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

一维数组的遍历

可以使用循环语句进行，但是前三种循环只能使用索引进行，foreach是专门针对集合进行遍历的结构，

foreach每次只能遍历一种数据类型的集合，其他三种遍历时只和索引有关和数组类型无关，如果数组的长度是一样则可以使用前三种循环语句结构，进行一次性同长度，不同类型的数组同时遍历。

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

二维数组

也是数组的一种，它是一组连续的内存空间，但是方向分为横向和纵向。

因此我们常常把二维数组看成一张二维表格

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

二维数组的声明和创建以及初始化

语法：

1、声明

数据类型[,] 数组名;//<---中（方）括号中的逗号将数组标识为二维数组。

2、创建

数组名 = new 数据类型[长度1,长度2];//<---长度一代表行的数量，长度2代表列的数量

//同时，长度1也表示二维数组中第一维的长度，长度2也表示二维数组中第二维的长度。

3、声明和创建二合一

数据类型[,] 数组名 = new 数据类型[长度1,长度2];

4、初始化二维数组

4.1 string[,] users = new string[2,2];

  user[0,0] = "jack";<---第0行，第0列

  user[0,1] = "sunny";<---第0行，第1列

  user[1,0] = "Jhon";<---第1行，第0列

  user[1,1] = "Tom";<---第1行，第1列

每个二维数组都有两个下标（索引），分别是行下标和列下标

4.2 stirng[,] = new string[,]{{"tom","rose"},{"jack","sunny"},{"mike","nancy"}};//动态初始化

这个相当于3行2列的二维数组；--->string[,] users = new string[3,2];

4.3 stirng[,] = {{"tom","rose"},{"jack","sunny"},{"mike","nancy"}};//静态初始化

 

二维数组的遍历

1、使用集合访问迭代器foreach

语法：

foreach（数据类型 循环变量 in 二维数组名 ）{循环体语句;}

使用foreach循环二维数组时是不考虑数组元素的索引，它会将数组中元素从头到尾全部提取出来。

2、使用for循环遍历二维数组

二维数组有两个维度:行维度和列维度

也就是有两个索引：行索引和列索引

需要取出二维数组每一个维度的长度

数组名.GetLength(维度索引)//获取指定维度的长度

C#语言中涉及到索引则都是从0开始

如果是第一维则维度索引就不是1而是0，第二维的维度索引就不是2而是1，因为索引是从0开始

使用数组名.Rank属性得到数组的维度

 

 

1、什么是排序？

就是将杂乱无章的数据按照某种格式进行排列的一种方式。

排序的目的是为了更好的、更快的搜索和查找数据。

2、排序的算法

就是怎样高效排列数据一种计算方法。

3、排序算法种类

3.1 冒泡排序

3.2 插入排序

3.3 选择排序

3.4 快速排序

4、冒泡排序的算法

反复对两个元素进行比较，如果这两个元素的顺序错误则进行交换。

原理：

1、比较相邻的元素，如果第一个比第二个大则交换它们两个

2、对每一对相邻的元素做同样的工作，从开始的一对到结尾的最后一对

3、针对所有的元素做同样的步骤，除了最后一个

4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较了。

原理分析：

设待排序的数组a中有n个元素，冒泡排序要进行n-1趟，每趟循环均是从比较相邻的两个元素开始，一直到最后两个元素。

算符实现的描述

两个循环进行嵌套

外循环和内循环均是循环这个数组a。

int[] a = {6,2,4,1,5,9}

外循环

for 从0-5六个元素，索引为i

内循环

fro 从0-5六个元素，索引为j

外循环第一次

i=0,进入内循环j=0，内循环第一次

a[i]>a[j+1]true

a[i]=a[j+1];<---交换两个元素的位置

内循环第二次

a[i+1]>a[j+1]true

a[i+1]=a[j+1];<---交换两个元素的位置

 

选择排序算法

算法原理：

1、从待排序的数组元素中选择值最小的或值最大的元素并将它与第一个元素进行交换

2、然后从不包括第一个位置的数组元素中选择最小的或最大的元素并将它与数组中第二个元素交换位置

3、重复前面的操作直到剩下一个元素为止。

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

冒泡排序：

很简单的一种经典排序算法。

但是普通情况下会有空循环的情况。

6个元素的数组来说

内循环会空跑12趟左右，外循环会空跑2趟左右

长度为6的数组，外循环每循环一次，内循环会循环6次

内外循环一共要循环6*6=36次。

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

当你从百度上找到你想要的代码时，不要马上拷贝到你的vs中执行。

而是要先观察理解代码的含义（思路），然后将代码复制到vs中，但是不要马上运行，事先需要整理代码。

当把代码整理好了后，再去运行。

因此就需要优化代码，提升效率。

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

插入排序

算法原理：

1、顺序的将待排序的元素按值的大小插入到已排序的元素子序列的适当位置

2、子序列的元素个数从1开始逐渐增大，当子序列的元素个数和数组中的元素个数相同时排序完成

 

复习

程序的三种：

一、顺序结构

二、选择结构

三、循环结构

这三种结构能够解决目前已知任何问题。

这三种结构的出现是通过研究人类行为得出的结论。

顺序结构（一个人的一生）

可以称为：开弓没有回头箭。

人一旦出生则终点以现。放在程序中就是一个大的顺序结构。

例如:操作系统，你一开机就意味着一段时间的开始。如果你一关机，就表示系统重新再来一次。

大的顺序结构。

放到自己的程序中则是从程序开始执行到程序结束，就是一个大的顺序结构。

就是从Main函数执行开始到执行结束。

选择结构

依托于顺序结构不能单独存在。

以人来说，每天每时每刻你都要做出无数种选择。这些选择会改变非常小的流程

选择结构改变流程是指内部小的流程而不是整体大流程。

C#程序中选择结构帮助我们对内部的执行流程做出一定的改变。

C#为了达到改变内部小流程的目的，创造了if语句和switch语句来达到目标

if语句是C#提供的选择结构的操作语句

if语句的四种形势：

1；单分支结构

2；双分支结构

3；多分支结构

4；嵌套结构

语法：

1，单分支

if(bool表达式)

{

   //表达式结果为真时要执行语句

}

2，双分支

if(bool 表达式)

{

   //表达式结果为真时要执行语句

}else

{

   //表达式结果为假是要执行语句

}

3，多分支

if(bool 表达式)

{

  //表达式结果为真时要执行语句

}else if(bool 表达式)

{

  //表达式结果为真时要执行语句

}。。。。。。

else

{

   //表达式结果为假是要执行语句，这个else语句并不是必须的

}

4，嵌套

if（bool 表达式）

{

    //表达式结果为真时要执行语句

    if(bool 表达式)

    {

      //表达式结果为真时要执行语句

    }

}else

{

    //表达式结果为假是要执行语句

    if（bool 表达式）

    {

      //表达式结果为真时要执行语句

    }

}

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

以上就是if语句的四种结构形势。

如何选择中间的哪一种呢？

如果你只需要做一个判断，但是后面任然是继续执行并不影响其他，那么使用单分支即可。

如果你需要无论判断成立还是不成立都要做不同的事情，那么使用双分支即可

如果你需要在多种情况下选一个执行，那么使用多分支即可。

如果你需要层层递进的判断，那么使用嵌套即可

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

多分支语句的简洁形势：

switch语句

语法：

switch(表达式)

{

      case 常量表达式：

      break;

      case 常量表达式：

      break;

      ......

      default:语句块;

      break;

}

同样实现多分支语句的功能，但是switch只能进行相等的比较，不能进行范围比较，而且case后面只能是常量表达式。switch还有一个高级用法就是“贯穿”，

贯穿用法：几种情况不同但是处理方式是相同的，此时可以使用“贯穿”

switch(表达式)

{

      case 常量表达式：

      case 常量表达式：

      case 常量表达式：

      case 常量表达式：

      break;

      case 常量表达式：

      break;

      ......

      default:语句块;

      break;

}

switch语句结构不能完全取代if多分支，因为switch不能判断复杂的条件，只能判断相等的关系。

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

循环结构

C#中提供了四种循环语句来实现循环的功能。

while 循环

do...while 循环

for 循环

foreach 循环

 

函数复习

 * 函数重载是指在一个类中创建一个函数的多个版本
             * 默认情况下每个类的范围内不可以声明同名对象超过一个，因为这样会发生二义性的错误，此时编译器将无法识别.
             * 函数也是一样的，为了解决这一个问题，微软提供函数重载来解决这个问题。
             * 函数重载是通过函数的签名来进行识别和区分，而不是通过函数名称来区分的。
             * 函数签名示例：
             * void Add();/int Add();<-----这种情况不是签名不同而是只识别函数名称和形参列表
             * 正确的函数签名是这样的：函数名称(形参列表)/---->Add(int parm)
             * 函数重载发生的三种情况：
             * 1、函数名称相同，形参类型不同，其他相同或不相同都行
             * 2、函数名称相同，形参个数不同，其他相同或不相同都行
             * 3、函数名称相同，形参顺序不同，其他参数类型不同外，其他相同或不相同都行
             * PS:严格来说重载是只和形参相关，是通过形参来识别，上述的三种重载情况可以构成函数签名不同
             * 一下情况和函数重载无关：
             * 1、返回值类型不同和重载无关
             * 2、访问修饰符不同和重载无关
             * 3、和函数所属（static）也和重载无关
             * 函数和类的注释不能只用简单的单行、多行注释，应该使用///的块级注释，因为块级注释可以在调用函数是产生注释内容的提示
             * ==============================================================
             * 字符是指Unicode编码的一个文本或符号
             * 字符类型中包含很多实用的函数：
             * 1、char.IsControl()<----用于判断是否属于控制字符
             * 2、char.IsDigit() <----用于判断是否是十进制数字
             * 3、char.IsLetter()<----用于判断是否是字母
             * 4、char.IsLower()<----用于判断是否是小写字母
             * 5、char.IsUpper()<----用于判断是否是大写字母
             * 6、char.IsWhiteSpace() <---用于判断是否是空白字符
             * 。。。。。。
             * ----------------------------------------------------------
             * 字符串是一串Unicode字符组成，它是引用类型，但是表象是值类型，它同样提供了丰富的函数来供开发者使用：
             * 字符串属性：
             * Length<---用于获取字符串的长度，也就是字符串中包含的字符个数，是常用的属性,它是针对于具体的某个字符串的
             * 字符串函数：
             * 1、Trim()<---用于消除字符串两端的空格
             * 2、EndWith()<----用于指定字符串匹配末尾是否一样
             * 3、IndexOf()<----用于查找指定字符串在目标字符串中第一个匹配的索引位置，匹配成功返回索引，失败返回-1
             * 4、LastIndexOf()<----用于查找指定的字符串在目标字符串中最后一个匹配的索引位置，匹配成功返回索引，失败返回-1
             * 5、SubString()<----用于指定开始的位置和长度来截取字符串，也可以只指定开始位置，然后截取
             * 6、Split()<----用于指定的字符或字符串把目标字符串分割为字符串数组
             * 7、Replace()<----用于使用指定的字符串替换目标字符串中的匹配的内容
             * 8、string.IsNullOrEmpty()<----用于测试字符串变量是否是空值还是空字符串
             * 9、Contains()<----用于测试指定的字符串是否出现在目标字符串中
             * 10、.Clone()<----返回对这个字符串实例的引用（克隆方法）
             * 11、CompareTo()<----与指定的object比较，并指示是在object之前还是之后
             * */

类型转换

1、几种类型转换？

隐式转换、显示转换

2、特点

隐式转换系统默认，有低到高（范围小到范围大，精度低到精度高，不会出错）

显示转换必须明确指定要转换的类型，而且有出错的可能，一般是溢出错误和格式不正确错误

 

嵌套

嵌套：就是一层里面还有一层。

if语句中间可以包含n个if语句这种情况就称为：“嵌套”

嵌套if语句执行的流程：

先执行外层的if如果成立则执行内层的if语句。如果里面还包含if语句则还是这样执行。

PS：一个if语句只能对应一个else语句，而且只和最近的else语句匹配。所以在写if语句时一定要注意括号，否则当if语句较多时很容易出现匹配不当的情况，这种情况不属于语法错误，属于语义错误。

小窍门：书写if语句时当if后面的布尔表达式写完后立即回车换行然后打上一对大括号，然后光标回去一格然后回车。如果发现括号不匹配了，那么请首先找到左边的折叠标识进行折叠，这样能够帮助我们快速的找到括号不匹配的问题。

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

嵌套if语句是当需要层层递进的判断时就使用if语句的嵌套

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

注意这里的并不是绝对的：

当出现嵌套if语句的逻辑时如果可以更加清晰话那么就改为多分支if语句

如果多分支if语句逻辑更加模糊的话那么就使用嵌套。

这样的事情称为：“代码优化”

什么是switch？

switch语句可以判断很多条件，适合从一组互斥的分支中选择一个分支执行。

语法说明

switch语句后面的表达式必须是一个变量

case 后面必须是常量，它的类型一定和switch表达式的类型一致。

default语句是可以省略的，如果有那么就只能有一个。

switch表达式的数据类型只能是：整数，字符，字符串，布尔，枚举

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

switch语句的贯穿用法：

多个条件不同，但是执行一样这种情况下我们就可以使用switch的“贯穿”

虽然使用if也可以做到但是如果要判断的条件仅仅是等于关系那么使用switch会更加清晰容易阅读

程序的三种结构：

1、顺序

2、选择（判断）

3、循环

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

什么是循环？

1、不断的重复进行--》循环

2、直到某条件不成立终止循环---》循环结束

3、如果条件永远成立则为“死循环”

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

两种情况：

1、先判断再执行（循环）

2、先执行一次再判断，条件为真则继续执行直到条件为假退出循环

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

C#中的四种循环语句

1、while(循环)

2、do...while（循环）

3、for（循环）

4、foreach（循环）

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

while循环是一种当型循环，就是当条件满足为真时执行循环，当条件不满足为假时退出循环。

while(布尔表达式)

{

      //循环体语句

}<----不用写分号结束

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

循环的核心是控制循环的次数，所以一般使用整数进行控制，例如：int i;

循环的三要素：

1、初始部分：从哪里开始

2、终止条件：到哪儿结束

3、迭代部分：循环语句体的执行

条件虽然不同判断是一样都是等于而且执行也是一样的那么就可以使用switch

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

多分支if语句与switch语句相同点：

1、都能实现多分支选择

2、多分支if语句和switch语句都能实现不需要层层递进判断的多分支

多分支if语句与switch语句不同点：

1、嵌套语句语法复杂、有代码冗余、结构容易混乱，但是层层递进逐步判断只能使用嵌套

2、switch语句语法简洁，但是只能判断相等关系，不能判断区间。

3、除了层层递进和相等关系就选择多分支if语句

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

注意：

switch语句中每个case后面的常量值必须唯一，否则语法错误

case后面必须跟上break退出case，如果不写就会出语法错误

使用贯穿case时在最后一个case后面写上break退出否则语法错误

default语句是可以省略的，如果有那么就只能有一个。

while循环语句其实最适合做次数不确定的循环，

但是却知道什么条件才终止循环的场景。

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

while中表达式可以逆向判断，也就是说可以进行取反的判断，使用关系运算符中的(!=)不等于运算可以进行取反的操作。

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

除非我们有意引入死循环，否则一定要在程序中避免死循环。

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

do...while循环是先执行一次循环体语句然后在判断循环条件是否为真。

使用场景：

当需要无论什么情况都要先执行语句然后在确定是否循环的情况下，使用do...while循环会更适合。

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

语法：

do{

   //循环体语句    

 

}while(布尔表达式); <---这里一定不要忘记了分号结束语句

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

do...while循环至少会执行一次。while循环可能一次都不执行

while是先判断再执行，do...while是先执行一次或多次再判断是否循环

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

死循环产生的必要条件:就是循环终止条件永不为假。

Console.

1、Clear<---清屏

2、WindowHeight<---设置黑屏幕的高度

3、WindowWidth<---设置黑屏幕的宽度

4、BufferHeight<---设置屏幕缓冲区的高度

5、BufferWidth<---设置屏幕缓冲区的宽度

6、ForegroundColor<---设置前景色

7、BackgroundColor<---设置背景色

8、Beep<---播放指定频率和时长的声音

9、SetCursorPosition<---设置屏幕光标的位置的方法（函数）

10、CursorLeft<---光标距离黑屏左边的多少字符

11、CursorTop<---光标距离黑屏顶部的多少字符

回顾

while和do...while区别？

1，while是先判断后执行，有可能一次都不循环

2，do...while是先执行一次循环，然后在判断是否执行循环，所以无论如何都会执行至少一次。

3，while和do...while都适合于不知道循环次数的循环

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

for语句？

for循环语句也叫“迭代语句”

名词解释：迭代

迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。

重复执行一系列运算步骤，从前面的量依次求出后面的量的过程。此过程的每一次结果，都是由对前一次所得结果施行相同的运算步骤得到的。例如利用迭代法*求某一数学问题的解。

对计算机特定程序中需要反复执行的子程序*(一组指令)，进行一次重复，即重复执行程序中的循环，直到满足某条件为止，亦称为迭代。

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

for语句也称为：计数器循环语句

for语法：

for（表达式1;表达式2;表达式3）

{

    循环语句

}

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

在同一个作用范围内不能声明相同变量名的变量，因为这样会产生二义性。编译器将不能识别。

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

for语句中三个表达式的作用：

表达式1作用是赋初值，仅在开始执行一次

表达式2每次都会执行，用于判断是否终止循环

表达式3作用是对表达式1的变量进行累加或递减，第一次不会执行，以后每次都会执行直到循环终止

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

for可以有四种表现形式

1，for (i = 1; i <= max; i++)  <---基本用法

2，int i=0;

for (; i <= max; i++) <---第二种

3, for (i = 1; i <= max; ){i++;} <---第三种

4，for (i = 1; ; i++) <---第四种

   {

      if (i <= max)

       {  //语句}

      else{break;}

   }

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

while、do...while、for相同点

1、都是循环语句，有固定的语法

2、都是有循环条件和循环体构成

3、循环的核心都是控制好循环的次数，次数又由三点决定：

 a、初始部分

 b、终止条件

 c、迭代部分

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

while、do...while、for不同点

1、while、do...while适合用于循环次数未知的情况，for循环适合循环次数确定的情况

2、while、do...while初始部分通常在开始之前就完成了，for循环则是在语法表达式的表达式1部分完成

3、while、do...while循环的迭代是在循环体中完成，for循环是在语法结构的表达式3部分完成，for循环是将三要素同时写在for后面的小括号中

4、while和for是先判断在执行，如果条件一开始就不成立，则循环一次都不执行。do...while先执行在判断，无论条件是否成立最少执行一次。

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

注意：

for语句中三个表达式，如果为空也必须使用;号进行站位。如果缺失则语法错误

 

C#中的循环语句学习了三种

1、while循环

2、do...while循环

3、for循环

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

while和do...while

用于不确定次数的循环

for用于确定次数的循环

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

for循环是属于最灵活的循环语句

因为for语句四种形式的用法，所以是非常灵活

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

1、输出实心矩形

思路：

首先将控制台屏幕看成一个平面的二维表格，

矩形是由行和列组成，那么我们可以使用循环语句进行输出，

首先循环行，为什么要先循环行，因为我们的习惯是从行开始，而每行都会包含列，因为行在习惯中是不确定的，列是确定的，因为人的视角宽度是有限的，横向阅读一定会有一个终点，但是纵向可以无限向下延伸。这也是当前所有网页、表格、文档的习惯。

这里要搞清楚的是行是向下是纵向的，列横向的。

然后在每行的基础上去循环列，同时输出，当每行中的列输出完成后，一定要换行。

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

2、输出空心矩形

空心矩形就是将实心矩形中间给挖出（输出空格取代*号）

思路：

在第一行时是全部输出

在最后一行也是全部输出

但是在第二行一直到倒数第二行都是第一列和最后一列输出*号，其他的都是空格

跳转语句

通俗的说就是从一个地方跳到另一个地方。

是属于流程控制语句中的一种，用于无条件的转移控制

C#中提供了四种跳转语句

1、continue：立即终止当前这一次循环，进入下一次循环。（仅用于各种循环语句，只能作用于包裹它的循环）

2、break：立即终止当前循环或退出switch语句（仅用于各种循环语句和switch语句，只能作用于包裹它的循环或switch）

3、goto：无条件跳转，可以跳转到任意指定标签位置。（可以构成循环效果）现代编程中是严禁使用

使用goto语句的地方一般是在受限设备中，例如：各种芯片中使用，因为芯片中的空间有限通常只有几k或几十k的空间

4、return：立即跳出当前（包裹return）函数，不会执行return后面的语句，函数也会立即终止执行。

return语句也是用于终止函数执行的语句

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

continue、break、return这三个跳转语句后面的代码是不会执行的，因为这三条语句已经跳转到别处，所以后面的代码等同于失效代码，因此也会称为：检测到无法访问到的代码

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

跳转语句用于无条件的转移控制。

 

什么是数组？

数组是一种结构，是把相同类型的数据按有序的形式组织起来。

通俗的理解：

以苹果举例：

每个苹果都看成一个具体数据，以前是用小盒子（变量）存放，当大量使用时就会不方便，所以如果将要使用苹果全部放到某一个空间中，那么效果就会很好。

这种情况下使用数组进行存放同一种类型的数据就会非常方便。

C#中数组可以分为：

一维数组、多维数组、数组的数组

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

数组的使用步骤：

1、声明数组（数组的类型和数组的名称）

2、创建数组（请求内存空间的分配）

3、初始化数组（给数组中每个空间放一个值）

一维数组的语法：

数据类型[] 数组名称;<-----声明一个数组对象

例如：int[] ages;//声明一组年龄的数组用于存储年龄的值

声明数组时要注意的事情

1、数据类型是C#语言中的任意数据类型

2、数组名称必须满足标识符的命名规范和变量的命名规范是相同的

数组名称 = new 数据类型[数组的长度];<----申请空间，包含多少个同类型的空间（数组长度）

ages = new int[10];<---创建整型数组对象，申请空间用于存放10个整型数据值

创建数组时要注意的事情

1、创建数组时，数组的长度不能省略，长度可以是常量、变量或表达式

2、数组的声明和创建可以合并到一起的。例如：int[] ages = new int[5];//这种写法比较常见

初始化数组

数组名称[索引] = 值;<---为数组的某个空间赋初值

int[] ages = new int[5];//声明并创建一个整型数组

ages[0] = 18;//将18 赋值给ages数组的第0个空间中

ages[1] = 20;//将20 赋值给ages数组的第1个空间中

ages[2] = 13;ages[3] = 22;ages[4] = 19;

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

ages[5] = 10;//这句赋值的代码是错误的。因为ages数组只有5个空间，空间的索引值从0开始

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

数组的索引从0开始因此数组的索引值一定是小于数组的长度，小一个

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

一维数组的动态初始化

语法：

数据类型[] 数组名称 = new 数据类型[]{值1,值2,值3,值4,....值N};

动态初始化时数组会根据初始化值的个数来确定数组的长度。

例如：

int[] ages = new int[]{12,13,23,22,18,16};

一维数组静态初始化

语法：

数据类型[] 数组名称 = {值1,值2,值3,值4,....值N};

例如：

int[] ages = {13,15,16,8,19};

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

元素的默认值：

数组是一种对象类型（属于引用类型），一旦创建对象则系统默认会给出原始初始化值。

int 类型 默认值 0

float 类型 默认值 0.0f

bool 类型 默认值 false

char 类型 默认值 '\u000'(表示一个空字符)

string 类型 默认值  null（对象的默认值就是null）

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

一维数组的访问：

数组名[索引] = 值;//为数组的指定索引的元素赋值

数组名[索引];//获取数组中指定索引的元素值

例如：

int[] ages = new int[5];

赋值：

ages[0] = 20;

取值：

int age = ages[0];//将指定索引位置的元素值取出赋给同类型的变量

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

数组和变量不同

数组的初始化其实是第二次赋值，变量的初始化才是真的第一次赋值

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

注意：

数组的长度是固定的，在C#语言中数组的长度一旦确定是不能更改的。

数组的索引一定小于数组的长度，否则会出现“索引超出了数组界限。”错误

 

一维数组的遍历

遍历：就是将集合内容进行逐个的访问。（例如：课堂上的点名）

是利用循环进行的，是通过数组的索引值进行计数循环，从而达到遍历数组元素的目的。

使用for这种循环进行数组的遍历。

由于for本身是一种计数器循环所以很容易的就和数组的索引值结合，这是天然的结合。通过这种结合就可以轻松的遍历数组中的每一个元素。

for循环遍历一维数组的语法：

for(数据类型 循环变量=0;循环变量 < 数组名.Length;循环变量++){操作数组元素;}

Length：<---长度（数组中表示包含元素的个数）

int[] ages = new int[5];

此时数组的长度就是5，也就是说ages数组中可以存放5个整数。那么ages.Length就是得到ages数组的长度

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

除了for循环经常用于集合的遍历外，C#还提供了foreach这种针对集合遍历的语句，方便我们对各种集合进行遍历

语法：

foreach(数据类型 循环变量 in 数组名称){语句块;}

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

一维数组的遍历

可以使用循环语句进行，但是前三种循环只能使用索引进行，foreach是专门针对集合进行遍历的结构，

foreach每次只能遍历一种数据类型的集合，其他三种遍历时只和索引有关和数组类型无关，如果数组的长度是一样则可以使用前三种循环语句结构，进行一次性同长度，不同类型的数组同时遍历。

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

二维数组

也是数组的一种，它是一组连续的内存空间，但是方向分为横向和纵向。

因此我们常常把二维数组看成一张二维表格

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

二维数组的声明和创建以及初始化

语法：

1、声明

数据类型[,] 数组名;//<---中（方）括号中的逗号将数组标识为二维数组。

2、创建

数组名 = new 数据类型[长度1,长度2];//<---长度一代表行的数量，长度2代表列的数量

//同时，长度1也表示二维数组中第一维的长度，长度2也表示二维数组中第二维的长度。

3、声明和创建二合一

数据类型[,] 数组名 = new 数据类型[长度1,长度2];

4、初始化二维数组

4.1 string[,] users = new string[2,2];

  user[0,0] = "jack";<---第0行，第0列

  user[0,1] = "sunny";<---第0行，第1列

  user[1,0] = "Jhon";<---第1行，第0列

  user[1,1] = "Tom";<---第1行，第1列

每个二维数组都有两个下标（索引），分别是行下标和列下标

4.2 stirng[,] = new string[,]{{"tom","rose"},{"jack","sunny"},{"mike","nancy"}};//动态初始化

这个相当于3行2列的二维数组；--->string[,] users = new string[3,2];

4.3 stirng[,] = {{"tom","rose"},{"jack","sunny"},{"mike","nancy"}};//静态初始化

 

二维数组的遍历

1、使用集合访问迭代器foreach

语法：

foreach（数据类型 循环变量 in 二维数组名 ）{循环体语句;}

使用foreach循环二维数组时是不考虑数组元素的索引，它会将数组中元素从头到尾全部提取出来。

2、使用for循环遍历二维数组

二维数组有两个维度:行维度和列维度

也就是有两个索引：行索引和列索引

需要取出二维数组每一个维度的长度

数组名.GetLength(维度索引)//获取指定维度的长度

C#语言中涉及到索引则都是从0开始

如果是第一维则维度索引就不是1而是0，第二维的维度索引就不是2而是1，因为索引是从0开始

使用数组名.Rank属性得到数组的维度

 

 

1、什么是排序？

就是将杂乱无章的数据按照某种格式进行排列的一种方式。

排序的目的是为了更好的、更快的搜索和查找数据。

2、排序的算法

就是怎样高效排列数据一种计算方法。

3、排序算法种类

3.1 冒泡排序

3.2 插入排序

3.3 选择排序

3.4 快速排序

4、冒泡排序的算法

反复对两个元素进行比较，如果这两个元素的顺序错误则进行交换。

原理：

1、比较相邻的元素，如果第一个比第二个大则交换它们两个

2、对每一对相邻的元素做同样的工作，从开始的一对到结尾的最后一对

3、针对所有的元素做同样的步骤，除了最后一个

4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较了。

原理分析：

设待排序的数组a中有n个元素，冒泡排序要进行n-1趟，每趟循环均是从比较相邻的两个元素开始，一直到最后两个元素。

算符实现的描述

两个循环进行嵌套

外循环和内循环均是循环这个数组a。

int[] a = {6,2,4,1,5,9}

外循环

for 从0-5六个元素，索引为i

内循环

fro 从0-5六个元素，索引为j

外循环第一次

i=0,进入内循环j=0，内循环第一次

a[i]>a[j+1]true

a[i]=a[j+1];<---交换两个元素的位置

内循环第二次

a[i+1]>a[j+1]true

a[i+1]=a[j+1];<---交换两个元素的位置

 

选择排序算法

算法原理：

1、从待排序的数组元素中选择值最小的或值最大的元素并将它与第一个元素进行交换

2、然后从不包括第一个位置的数组元素中选择最小的或最大的元素并将它与数组中第二个元素交换位置

3、重复前面的操作直到剩下一个元素为止。

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

冒泡排序：

很简单的一种经典排序算法。

但是普通情况下会有空循环的情况。

6个元素的数组来说

内循环会空跑12趟左右，外循环会空跑2趟左右

长度为6的数组，外循环每循环一次，内循环会循环6次

内外循环一共要循环6*6=36次。

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

当你从百度上找到你想要的代码时，不要马上拷贝到你的vs中执行。

而是要先观察理解代码的含义（思路），然后将代码复制到vs中，但是不要马上运行，事先需要整理代码。

当把代码整理好了后，再去运行。

因此就需要优化代码，提升效率。

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

插入排序

算法原理：

1、顺序的将待排序的元素按值的大小插入到已排序的元素子序列的适当位置

2、子序列的元素个数从1开始逐渐增大，当子序列的元素个数和数组中的元素个数相同时排序完成

 

复习

程序的三种：

一、顺序结构

二、选择结构

三、循环结构

这三种结构能够解决目前已知任何问题。

这三种结构的出现是通过研究人类行为得出的结论。

顺序结构（一个人的一生）

可以称为：开弓没有回头箭。

人一旦出生则终点以现。放在程序中就是一个大的顺序结构。

例如:操作系统，你一开机就意味着一段时间的开始。如果你一关机，就表示系统重新再来一次。

大的顺序结构。

放到自己的程序中则是从程序开始执行到程序结束，就是一个大的顺序结构。

就是从Main函数执行开始到执行结束。

选择结构

依托于顺序结构不能单独存在。

以人来说，每天每时每刻你都要做出无数种选择。这些选择会改变非常小的流程

选择结构改变流程是指内部小的流程而不是整体大流程。

C#程序中选择结构帮助我们对内部的执行流程做出一定的改变。

C#为了达到改变内部小流程的目的，创造了if语句和switch语句来达到目标

if语句是C#提供的选择结构的操作语句

if语句的四种形势：

1；单分支结构

2；双分支结构

3；多分支结构

4；嵌套结构

语法：

1，单分支

if(bool表达式)

{

   //表达式结果为真时要执行语句

}

2，双分支

if(bool 表达式)

{

   //表达式结果为真时要执行语句

}else

{

   //表达式结果为假是要执行语句

}

3，多分支

if(bool 表达式)

{

  //表达式结果为真时要执行语句

}else if(bool 表达式)

{

  //表达式结果为真时要执行语句

}。。。。。。

else

{

   //表达式结果为假是要执行语句，这个else语句并不是必须的

}

4，嵌套

if（bool 表达式）

{

    //表达式结果为真时要执行语句

    if(bool 表达式)

    {

      //表达式结果为真时要执行语句

    }

}else

{

    //表达式结果为假是要执行语句

    if（bool 表达式）

    {

      //表达式结果为真时要执行语句

    }

}

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

以上就是if语句的四种结构形势。

如何选择中间的哪一种呢？

如果你只需要做一个判断，但是后面任然是继续执行并不影响其他，那么使用单分支即可。

如果你需要无论判断成立还是不成立都要做不同的事情，那么使用双分支即可

如果你需要在多种情况下选一个执行，那么使用多分支即可。

如果你需要层层递进的判断，那么使用嵌套即可

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

多分支语句的简洁形势：

switch语句

语法：

switch(表达式)

{

      case 常量表达式：

      break;

      case 常量表达式：

      break;

      ......

      default:语句块;

      break;

}

同样实现多分支语句的功能，但是switch只能进行相等的比较，不能进行范围比较，而且case后面只能是常量表达式。switch还有一个高级用法就是“贯穿”，

贯穿用法：几种情况不同但是处理方式是相同的，此时可以使用“贯穿”

switch(表达式)

{

      case 常量表达式：

      case 常量表达式：

      case 常量表达式：

      case 常量表达式：

      break;

      case 常量表达式：

      break;

      ......

      default:语句块;

      break;

}

switch语句结构不能完全取代if多分支，因为switch不能判断复杂的条件，只能判断相等的关系。

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

循环结构

C#中提供了四种循环语句来实现循环的功能。

while 循环

do...while 循环

for 循环

foreach 循环

 

函数复习

 * 函数重载是指在一个类中创建一个函数的多个版本
             * 默认情况下每个类的范围内不可以声明同名对象超过一个，因为这样会发生二义性的错误，此时编译器将无法识别.
             * 函数也是一样的，为了解决这一个问题，微软提供函数重载来解决这个问题。
             * 函数重载是通过函数的签名来进行识别和区分，而不是通过函数名称来区分的。
             * 函数签名示例：
             * void Add();/int Add();<-----这种情况不是签名不同而是只识别函数名称和形参列表
             * 正确的函数签名是这样的：函数名称(形参列表)/---->Add(int parm)
             * 函数重载发生的三种情况：
             * 1、函数名称相同，形参类型不同，其他相同或不相同都行
             * 2、函数名称相同，形参个数不同，其他相同或不相同都行
             * 3、函数名称相同，形参顺序不同，其他参数类型不同外，其他相同或不相同都行
             * PS:严格来说重载是只和形参相关，是通过形参来识别，上述的三种重载情况可以构成函数签名不同
             * 一下情况和函数重载无关：
             * 1、返回值类型不同和重载无关
             * 2、访问修饰符不同和重载无关
             * 3、和函数所属（static）也和重载无关
             * 函数和类的注释不能只用简单的单行、多行注释，应该使用///的块级注释，因为块级注释可以在调用函数是产生注释内容的提示
             * ==============================================================
             * 字符是指Unicode编码的一个文本或符号
             * 字符类型中包含很多实用的函数：
             * 1、char.IsControl()<----用于判断是否属于控制字符
             * 2、char.IsDigit() <----用于判断是否是十进制数字
             * 3、char.IsLetter()<----用于判断是否是字母
             * 4、char.IsLower()<----用于判断是否是小写字母
             * 5、char.IsUpper()<----用于判断是否是大写字母
             * 6、char.IsWhiteSpace() <---用于判断是否是空白字符
             * 。。。。。。
             * ----------------------------------------------------------
             * 字符串是一串Unicode字符组成，它是引用类型，但是表象是值类型，它同样提供了丰富的函数来供开发者使用：
             * 字符串属性：
             * Length<---用于获取字符串的长度，也就是字符串中包含的字符个数，是常用的属性,它是针对于具体的某个字符串的
             * 字符串函数：
             * 1、Trim()<---用于消除字符串两端的空格
             * 2、EndWith()<----用于指定字符串匹配末尾是否一样
             * 3、IndexOf()<----用于查找指定字符串在目标字符串中第一个匹配的索引位置，匹配成功返回索引，失败返回-1
             * 4、LastIndexOf()<----用于查找指定的字符串在目标字符串中最后一个匹配的索引位置，匹配成功返回索引，失败返回-1
             * 5、SubString()<----用于指定开始的位置和长度来截取字符串，也可以只指定开始位置，然后截取
             * 6、Split()<----用于指定的字符或字符串把目标字符串分割为字符串数组
             * 7、Replace()<----用于使用指定的字符串替换目标字符串中的匹配的内容
             * 8、string.IsNullOrEmpty()<----用于测试字符串变量是否是空值还是空字符串
             * 9、Contains()<----用于测试指定的字符串是否出现在目标字符串中
             * 10、.Clone()<----返回对这个字符串实例的引用（克隆方法）
             * 11、CompareTo()<----与指定的object比较，并指示是在object之前还是之后
             * */