C#笔记补充.doc

一.“+”在C#中有两种意义：
1）是数学中的加法运算：两边参与假发运算的数据类型卫数字类型，则“+”
表示数字上的加法的意义。
2）是连接的意思：两本参与加号运算的数据，有一个是字符类型，那么这个
“+”号就是连接的意义。

二.在Console.WritLine("")中，第一个变量/字符串中可以使用占位符。
占位符由{数字}组成，数字由0开始编号
第1个占位符：{0}
第2个占位符：{1}
第3个占位符：{2}
....

三.Consle.Write()有多个参数时，输出的都是第一个参数中的内容，从第二个参数
开始，都是用来替换第一个参数中的占位符的值，所以从第二个参数开始，要不
要输出，就要看第一个参数中有没有相关的占位符。

四.Console.ReadLine()
接收的用户输入的内容必须是定义一个字符串进行接收.
string input = Console.ReadLine();

五.转义字符
1）什么时候用，当我们需要在字符串中输入一些特殊字符时，比如：半角引号，换行，
退格.就需要使用转义字符.
2）转义字符是一个字符， 它由一个\+一个字符来组成具有特殊意义的一个字符.
常用的转义字符：
\n 表示换行
\b backspace 退格
\t tab键 有多个空格组成的字符，具有行与行之间的对齐功能.
3）在字符串前面加一个@符号有两种意义：
①字符串中如果有\，则不再理解为转义字符.
②使字符串可以换行
4）如果字符串前面加了@符号，在字符串上用两个双引号代表一个双引号.

六.类型自动转换规则：
参与运算（算术运算和赋值运算）的操作数和结果类型必须一致，当不一致时，满足
下面条件时，系统自动完成类型转换.
1）两种类型兼容
如：int和double兼容
目标类型大于源类型，如：double>int
2)对于表达式，如果一个操作数卫double型，则整个表达式可提升为double型.

七.强制类型转换
当需要丢失精度的转换（如从double3.14到int3的转换，会丢失0.14的精度）时，系统
是不会帮我们自动转换的，需要程序员来写代码完成转换.
转换的语法为：（数据类型名）待转换的值.

八.类型转换
int 变量名 = Convert.ToInt32(待转换字符)
把待转字符串转换成int类型后赋给变量.

第二章
一.C#中异常捕获：
try
{
有可能出现错误的代码写在这里
}
catch
{

}
上面的程序如何执行：
如果try中的代码没有出错，则程序正常运行try中的内容后，
不会执行catch中的内容.
如果try中的代码一旦出错，程序立即跳入catch中去执行代码，
那么try中的出错代码后面的代码不再执行.
二.运算
int age=18;
int sum=age++ -10;
上面代码age是后加，所以在进行语句运算时，age++取age原值参与运算.
所以sum=8
int age=18;
int sum=++age -10;
上面代码age是前加，所以再进行语句运算时，++age取age加1后的新值参与运算
所以sum=9
总之，不管++age还是age++，经过运算后,age的值都进行了加1运算.
三.if if else
在if else if语句中，只有当上一个条件不成立时，才会进入下一个if语句.
并进行if语句后面的条件判断.一旦有一个if后面的条件为ture，则执行此if
所带的语句（块）,语句（块）执行完成后，程序跳出if-else if结构,如果
所有的if条件都不成立，则如果最后有else则执行else所带的语句，否则什么
都不执行。
四.switch-case语句：
语法：
switch(表达式)
{
case 值1：语句块1；
break;
case 值2：语句块2；
break;
case 值3：语句块3；
break;
default:语句块4；
break;
}
五.if-else if和switch的比较
相同点：都可以实现多分支结构
不同点：
switch：一般只能用于等值比较
if-else if：可以处理范围
第三章
一.While 循环的语法：
while（循环条件）
{
要循环执行的N条程序; //循环体
}
执行过程：
1.先判断循环条件，如果条件为true，则转向2；
如果条件为false，则转向3
2.执行循环体，循环体执行完后，转向1
3.跳出循环，循环结束
二.do-while 为先执行，再判断
语法：
do{循环体;}
while{条件};
执行过程：
1.执行循环体，执行完循环体转向2
2.判断条件是否成立，如果条件为true，则转向1，如果条件为
false，则转向3.
3.跳出循环
三.break:
1.可以用于switch-case判断中，用于跳出switch
2.用在循环中，用于立即跳出（终止）循环.
注意：用于循环中时，跳出的是break所在的循环
四.continue:
用于循环中，程序一旦执行到continue语句，立即结束本次循环
（就是不再执行循环体中continue下面的语句了），直接进行下次
循环.（do-while/while直接进行下一次循环条件的判断,如果条件成立
则再次进入循环. 对于for循环，先执行表达式3，再判断循环条件时否成功！）
五.三元表达式：
表1?表2:表3
执行过程：首先计算表达式1，表达式1应该是一个能够计算成bool类型的值，
如果表1的值为true,则表达式2的值作为整个表达式的值，如果表1的值为false，
则表达式3的值做为整个表达式的值.
表达式2和表达式3类型一定要相同（相容）

顺序结构。。分支结构。。循环结构

第四章
一.常量和枚举
常量：
语法：const 类型 常量名 = 常量值
枚举：定义一个枚举类型，同时指定这个类型的所有值
语法：enum 类型名{值1，值2，值3....值n};
枚举的定义一般和类定义在同一个级别，这样在同一个命名空间
下的所有的类就都可以使用这个枚举了.(方法/类中都行)
枚举的作用：
1）限制用户不能随意赋值，只能赋在定义枚举时列举的值中选择.
2）不需要死记每一个值是什么，只需要选择相应的值
注意：定义枚举时，值不能是int类型的
枚举类型的变量都可以强制转换成一个int类型，枚举的值在定义
时是有一个默认的编号的，编号从0开始.
如何把一个字符串转换成枚举类型：
（自枚）（Enum.Parse（typeof（自枚）,"待转换的字符串"））;
二.结构
1）比如为了存储一个人的信息，就要申明一组变量，当我们要存储
n个人的信息时，就要申明n组变量.
2）存储一个人信息的这几个变量间没有关系，容易记错.
语法：
访问修饰符 struct 结构名
{
定义结构成员
}
定义好一个结构后就可以直接声明相应的变量了，声明好变量后，通过变量
名.成员名 来访问结构的成员
三.数组
数组一次可以声明多个同类型的变量.这些变量在内存中是连续存储的
数组声明语法：数据类型[] 数组名 = new 数据类型[数组长度];
Int类型数组一旦声明，里面的每个元素被初始化成0.
通过 数组名.Length 可以获得数组的长度
Console.Clear(); 清屏
四.冒泡排序：
让数组中的元素两两比较（第i个与第i+1个比较），经过u(i-1)遍两两比较，
数组中的元素能按照我们预期的规律排序
for(int i+0;i<nums.Length-1;i++)
{
for(int j=0;j<nums.Length-i-1;j++)
{
if(>)或if(<)
{
交换元素
}
}
}

第五章
一.方法：用来复用代码的，当我们在一个程序中反复的写了同样
的代码，一般情况下，我们可以把需要重复写的代码定义在一个
方法中，用的时候只需要调用就行了.
定义方法的语法：
[访问修饰符] [static] 返回值类型 方法名([参数])
{
方法体；
}
注意:
1）方法一般定义在类中
2）如果方法没有返回值，则返回值类型写 void
方法的调用：如果是静态方法（由static修饰的）则使用
类名.方法名();
在类中调用本类的方法时可以只写方法名();
return：退出本方法
二.变量的作用域：
在方法中定义的变量称为局部变量，其作用域从定义开始到其所在
的大括号结束为止.
当被调用者想得到调用者方法中的变量时，则可以让调用者以参数
的形式给被调用者.
三.返回值
当调用者想访问我们方法中的变量时，可以通过返回值返回
为什么方法前面能够定义一个变量收到方法的值，是因为在方法中使用
了返回值.
只要在方法中返回了值，那么调用方法中，前面应该用一个变量来接收
方法的返回值.
注意：一个方法只能有一个返回值
一旦一个方法又返回值，那么在这个方法中，就必须通过return语句返回
一个值，并且这个值要与返回值类型是相同的.
语法：return 值;
当形参是数组时，我们传数组名
一个变量一旦定义在方法外，类的里面，就叫做类的字段，这个变量就可以
被本类的所有方法所访问，但是要注意，静态方法只能访问静态字段.
由const修饰的常量不能定义静态的.
四.方法的重载
一般在同一个类中，方法名相同，并且方法的参数的个数不同或者对应位置
上的类型不同，才能构成方法的重载.
注意：方法重载和返回值没有关系
五.out和ref
1）out 关键字会导致参数通过引用来传递。 这与 ref 关键字类似，不同之处
在于 ref 要求变量必须在传递之前进行初始化。 若要使用 out 参数，
方法定义和调用方法都必须显式使用 out 关键字。
2）尽管作为 out 参数传递的变量不必在传递之前进行初始化，但被调用的方法
需要在返回之前赋一个值。
3）一个接受 ref 参数，另一个接受 out 参数，则无法重载这两个方法。
如果一个方法采用 ref 或 out 参数，而另一个方法不采用这两类参数，
则可以进行重载。
4）属性不是变量，因此不能作为 out 参数传递
5）当希望方法返回多个值时，声明 out 方法很有用。
第六章
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _01
{
class Program
{ //在下面的数组存储我们游戏地图各各管卡
//在数组下标为0的元素对应地图上的第1格 下标为1的对应第2格....下标为n的对应第n+1格
//在数组中用 1:表示幸运轮盘
// 2:地雷
// 3:暂停
// 4:时空隧道
// 0:表示普通
static int[] Map = new int[100];
static int[] playerpos = { 0, 0 };//playerpos[0]存玩家A的下标 playerpos[1]存玩家B的下标
static void Main(string[] args)
{
Random r = new Random();//产生一个随机数字
bool[] Isstop = { false, false };//Isstop[0]表示A是否上一次走到暂停了，Isstop[1]表示B，如果走到了暂停，则设置值为true
int temp = 0;//用于存放产生的随机数
string[] names = new string[2];//存储2个姓名，namse[0],name[1]
string msg = "";
ShowUI();//显示游戏名字
Console.WriteLine("请输入玩家A的名字？");
names[0] = Console.ReadLine();
//判断用户输入是否为空，为空则让用户重新输入
while (names[0] == "")
{
Console.WriteLine("玩家A的姓名不能为空，请重新输入：");
names[0] = Console.ReadLine();
}
Console.WriteLine("请输入玩家B的名字？");
names[1] = Console.ReadLine();
while (names[1] == "" || names[1] == names[0])
{
if (names[1] == "")
{
Console.WriteLine("玩家B的姓名不能为空，请重新输入：");
}
if (names[1] == names[0])
{
Console.WriteLine("该姓名已被玩家A占用!");
}
names[1] = Console.ReadLine();
}
Console.Clear();
ShowUI();
Console.WriteLine("对战开始.......");
Console.WriteLine("{0}用A表示",names[0]);
Console.WriteLine("{0}用B表示",names[1]);
Console.WriteLine("如果AB在同一位置,用<>来表示");
InitialMap();//初始化地图
DrawMap();
Console.WriteLine("开始游戏.....");
//这个循环中让玩家A和玩家B轮流掷骰子 当玩家A或玩家B的坐标>=99时，则结束循环
//产生一个m到n之间的随机数
//Random r = new Random();
//int i = r.Next(m,n+1);
while (playerpos[0] < 99 && playerpos[1] < 99)
{
if (Isstop[0] == false)
{
#region 玩家A掷骰子
Console.WriteLine("{0}按任意键开始掷骰子......", names[0]);
Console.ReadKey(true);//不显示按的键
temp = r.Next(1, 7);
Console.WriteLine("{0}掷出了：{1}", names[0], temp);
Console.WriteLine("按任意键开始行动......");
Console.ReadKey(true);
playerpos[0] = playerpos[0] + temp;//一旦坐标改变，就要判断坐标值是否>99或者<0
Checkpos();//判断坐标是否越界
if (playerpos[0] == playerpos[1])//玩家A踩到玩家B
{
playerpos[1] = 0;
msg = string.Format("{0}踩到了{1}，{1}退回原点!", names[0], names[1]);
}
else
{
switch (Map[playerpos[0]])
{
case 0:
//普通，没效果
break;
case 1:
//幸运轮盘管卡
Console.Clear();
DrawMap();
Console.WriteLine("{0}走到了幸运轮盘，请选择？", names[0]);
Console.WriteLine("1----交换位置 2----轰炸对方");
int input = ReadInt(1, 2);
if (input == 1)
{
//跟对方交换位置
int b = playerpos[0];
playerpos[0] = playerpos[1];
playerpos[1] = b;
msg = string.Format("{0}选择了跟对方交换位置!", names[0]);
}
else
{
//轰炸对方
playerpos[1] -= 6;
Checkpos();
msg = string.Format("{0}轰炸了{1}，{1}退6格!", names[0], names[1]);
}
break;
case 2:
//踩到地雷
playerpos[0] -= 6;
Checkpos();
msg = string.Format("{0}踩到了地雷，退6格!", names[0]);
break;
case 3:
//暂停一次
Isstop[0] = true;
msg = string.Format("{0}走到了暂停关卡，被暂停一次!", names[0]);
break;
case 4:
//时空隧道
playerpos[0] += 10;
Checkpos();
msg = string.Format("{0}进入时空隧道，前进10格!", names[0]);
break;
}
}
Console.Clear();
DrawMap();
if (msg != "")
{
Console.WriteLine(msg);
}
Console.WriteLine("{0}掷出了{1},行动完成了!", names[0], temp);
Console.WriteLine("************玩家A和玩家B的位置如下**********");
Console.WriteLine("{0}的位置是：{1}", names[0], playerpos[0] + 1);
Console.WriteLine("{0}的位置是：{1}", names[1], playerpos[1] + 1);
#endregion
}
else
{
Isstop[0] = false;
}
if (playerpos[0] >= 99)
{
break;
}
if (Isstop[1] == false)
{
#region 玩家B掷骰子
Console.WriteLine("{0}按任意键开始掷骰子......", names[1]);
Console.ReadKey(true);//不显示按的键
temp = r.Next(1, 7);
Console.WriteLine("{0}掷出了：{1}", names[1], temp);
Console.WriteLine("按任意键开始行动......");
Console.ReadKey(true);
playerpos[1] = playerpos[1] + temp;//一旦坐标改变，就要判断坐标值是否>99或者<0
Checkpos();//判断坐标是否越界
if (playerpos[1] == playerpos[0])//玩家A踩到玩家B
{
playerpos[0] = 0;
msg = string.Format("{0}踩到了{1}，{1}退回原点!", names[1], names[0]);
}
else
{
switch (Map[playerpos[1]])
{
case 0:
//普通，没效果
break;
case 1:
//幸运轮盘管卡
Console.Clear();
DrawMap();
Console.WriteLine("{0}走到了幸运轮盘，请选择？", names[1]);
Console.WriteLine("1----交换位置 2----轰炸对方");
int input = ReadInt(1, 2);
if (input == 1)
{
//跟对方交换位置
int b = playerpos[1];
playerpos[1] = playerpos[0];
playerpos[0] = b;
msg = string.Format("{0}选择了跟对方交换位置!", names[1]);
}
else
{
//轰炸对方
playerpos[0] -= 6;
Checkpos();
msg = string.Format("{0}轰炸了{1}，{1}退6格!", names[1], names[0]);
}
break;
case 2:
//踩到地雷
playerpos[1] -= 6;
Checkpos();
msg = string.Format("{0}踩到了地雷，退6格!", names[1]);
break;
case 3:
//暂停一次
Isstop[1] = true;
msg = string.Format("{0}走到了暂停关卡，被暂停一次!", names[1]);
break;
case 4:
//时空隧道
playerpos[1] += 10;
Checkpos();
msg = string.Format("{0}进入时空隧道，前进10格!", names[1]);
break;
}
}
Console.Clear();
DrawMap();
if (msg != "")
{
Console.WriteLine(msg);
}
Console.WriteLine("{0}掷出了{1},行动完成了!", names[1], temp);
Console.WriteLine("************玩家A和玩家B的位置如下**********");
Console.WriteLine("{0}的位置是：{1}", names[0], playerpos[0] + 1);
Console.WriteLine("{0}的位置是：{1}", names[1], playerpos[1] + 1);
#endregion}
}
else
{
Isstop[1] = false;
}
}
//判断谁胜利了
Console.Clear();
ShowUI();
if (playerpos[0] >= 99)
{
Console.WriteLine("{0}胜利了!", names[0]);
}
else
{
Console.WriteLine("{0}胜利了!", names[1]);
}

Console.ReadKey();
}
/// <summary>
/// 判断玩家A和