黑马程序员————————C#基础知识（三）

 ----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

l      转义符

l      算术运算符与类型转换

l      复合函数

l      异常捕获和自加自减

l      复合运算符

l      关系运算符

l      逻辑运算符

l      条件运算符及其短路

l      各种运算符优先级比较

1.转义符

 1)               C#中，用“\”加一个字符组成转义字符，一般用来输出特殊符号，比如说想要在Console.WriteLine(“在这里输入内容”); 中加入双引号，因为函数中已经包含双引号，如果直接输入则会造成错误，这时需要用“\”加引号进行转义。例如：

 Console.WriteLine("在这里输入\"内容");    输出语句中有一个引号

 Console.WriteLine("在这里输入\"\"内容");   输出语句中有两个引号

\加\可输出\

\加”可输出”

\加汉字，+，%等都不能组成转义字符，因为它们可以直接输出，  因此，\加字符组成的转义字符一般用来输入不能直接输入的特殊字符如 \，”,换行，退格。

\加字母组成有特殊意义的转义字符，如下：

\n        （换行符）

\b        （退格符）

\r          (回车符)  跳转到本行开始位置

例如：Console.WriteLine("1234\r5");   输出5234 ，回车后的内容5跳转本行开始，覆盖了1   

\t    tab键（制表符）由多个空格组成，具有行与行对齐功能

如下：

  Console.WriteLine("1\t2\t3\t4\t");

 Console.WriteLine("123\t34561\t14567\t123456\t");

输出后，两行输入内容中的数字将会对齐，

2)如果在输出语句之前加上符号@，则输出语句中的\可被直接输出，不会用作组建转义字符，一般常用于输出语句为路径时，比如：

Console.WriteLine(@"C:\Users\lenovo\Desktop\html\net");

注意@符号需要加到格式要求的双引号之前

另：输入语句之前加上@，则输入语句可以换行而不会产生编译错误；输入语句中输入双引号，编译输出后会变成单引号。

Console.WriteLine(@"1234""45565");    

        

所以需要用两个双引号来输出一个双引号。

 Console.WriteLine(@"看  ""我"" 的反应"); 

2.算术运算符与数据类型转换（自转和强转）

+  -  *  /   %(取模、取余数)

它们都是二元运算符，运算过程中，优先级与数学上优先级相同，都是先乘除后加减，有括号先算括号里，相同级别的从左至右算。但不同于数学运算中的是，小括号可以无限制添加，但一定要成对儿出现。

如（（a+b）+（2+2）)*c

要求参与运算的操作数类型必须相同，并且经过运算后的结果也与运算数类型相同。参与运算（算术运算和赋值运算）的操作数和结果类型必须一致。当不一致时，满足下列条件，系统自动完成类型转换。（数据类型必须兼容，必须一边的数据范围大，一边的数据范围小，并且把小的转向大的，不丢失精度，只有不丢失精度的同类数据类型的变量，系统才会发生隐式转换）

 两种类型兼容

int与double兼容

目标类型大于源类型

double>int

对于表达式

       如果一个操作数为double类型，则整个表达式可提升为double类型。

           int a = 10, b = 3;

           double c = a / b;

           Console.WriteLine(c);       输出结果c=3  

           int a = 10, b = 3;

           double c =1.0* a / b;

           Console.WriteLine(c);       输出结果c=3.33333333333333

           double a = 10, b = 3;

           double c =1.0* a / b;

           Console.WriteLine(c);       输出结果c=3.3333333333333

如上：在第一个运算函数中发生了隐式类型转换，因为发生运算的a,b两个变量都是int型，所以运算结果也是int型，而int又被double兼容，因而默认程序无错误编译输出产生结果，忽略小数。

强制类型转换：要求数据类型一定要兼容（强制转换，不进行四舍五入）

语法：（数据类型）待转换的值

如：   int x = (int)3.14;

           Console.WriteLine(x);

 虽然此时变量的值为double类型，但是加入（int）强制转换，输出结果为3.即便丢失了0.14的精度，编译也未发生错误。

强制转换要求待转换值的类型与目标类型都是数值类型，也就是说，只是数值类型变量之间的转换。

3. 函数Convert.ToInt32和复合函数

              Console.WriteLine("请输入您的年龄。");

           string s =Console.ReadLine();

           int age =Convert.ToInt32(s);

           Console.WriteLine("您的年龄是{0}",age);

           int year = 2013 - age;

           Console.WriteLine("您是{0}出生的",year);

函数Convert.ToInt32();可将string类型的数字转换为有效（可参与算术运算）的int类数字，但是如果用户键入非数字以及超过int32位范围的数字，则会出现错误，所以要求在之后编写其他代码来要求规范用户输入,目前只能用try和catch报错。

可以将两个函数连接在一起组成：如下，多个函数组成需求变量，只要编译无错误，保证函数可被相应的数据类型声明，即可编译运行。

           Console.WriteLine("请输入您的年龄！");

           int year=2013-Convert.ToInt32(Console.ReadLine());

           Console.WriteLine("您是{0}年出生的", year);

           Console.ReadKey();

其他的与此类似的函数还有Convert.ToSByte(); Convert.ToInt64(); 等等；

String  x =Convert.ToString();

所有类型都可以通过该函数转换成string类型

4.C#中用来捕获异常的函数：

          try          

             {

               在这里输入有可能出错的代码

           }

           catch

           {

               如果try中的程序运行出错，程序会自动跳转到这里执行catch中的程序          

           }

一般情况下，在catch中写入报错后的处理方法。如果try中的程序没有出错，则不会执行catch中的代码，而一旦try中的程序出错，程序会立刻执行catch中的代码，而try未执行的代码将跳过作废不再执行。

5.小程序，将秒数转换成具体的天数小时数分钟数

//秒数转换成天数和小时分钟

      Console.WriteLine("请输入你要转换的秒数：");

      int seconds =Convert.ToInt32(Console.ReadLine());             //暂不考虑无效转换

      int days = seconds / (3600 * 24);

      int mod = seconds % (3600 * 24);   //除以天后剩余的秒数

      int hours = mod / 3600;     

      mod = mod % 3600; //除以天后剩余的秒数再除以小时后剩余的秒数

      int min = mod / 60;

      int second = mod % 60; //除以天，小时，分，后剩余的秒数，前面都涉及到mod的重新赋值法   

      Console.WriteLine("您好，您输入的秒数转换后是{0}天{1}小时{2}分{3}秒",days,hours,min,second);

      Console.ReadKey();

当然，如果真的是这种程序的话，大概需要定义long类型或者double类型变量，毕竟总有很多闲的蛋疼的人输入一长串数字考验程序。

6.变量的自加自减

 ++  自加，分前自加和后自加

 --   自减，分前自减和后自减

 以上两种都是一元运算符，只要一个操作数就可以运算。一元运算符比二元运算符（加减乘除）有优先级。

语句中运算时，前自加/自减取新值参与运算；后自加/自减取原值参与运算；但是自加/自减的变量最后输出的都是新值。例如：

     int a = 18, b = a++ - 10;

          Console.WriteLine(b);

          Console.ReadKey();

运算后输出的结果为8，而

           int a = 18, b =++a - 10;

           Console.WriteLine(b);

           Console.ReadKey();

运算后的结果为9；但以上两个语句运算后的变量a的值都为19.

           int a = 18, b = a--- 10;

           Console.WriteLine(b);

           Console.ReadKey();

运算结果为8；

           int a = 18, b = --a- 10;

           Console.WriteLine(b);

           Console.ReadKey();

 

运算结果为7；但是以上两个语句运算后的变量a的值都为17.

Q：       int a = 2;

                    a = a++;

                    Console.WriteLine(a);

为什么该语句输出后的值依然是2？难道后++的优先级小于赋值？而且程序运算完成后a没有再自加？

虽然                      int a = 2, b = 3;

                     b = a++;

                     Console.WriteLine("{0}{1}",a,b);

这个时候a自加了，上面却没有，难道上式程序以原值赋值运行后没有再自加吗？

到现在依然认为只是因为优先级的原因，后加加是基元运算符，运算时变量中的数据还未来得及改变，等运算完成后才自加，前加加为一元运算符，先自加改变变量中的值才发生的运算。上面二例中变量改变，自然赋值也就来得及改变，而一例运算之前，并未发生改变。希望以后有机会，能看看它们之间微小的运算速度差异来做出判断。

7.复合运算符/复合赋值符（不是一元运算符，因为一个操作数时无法独立运算）

l       +=      a+=3相当于a自加三，也就是a=a+3;但是=右边没有值的时候就会出错，以下同理。

l       -=     

l       *=                  

l       /=     

l       %=   

之所以要用复合赋值符代替诸如a=a+3这样的表达式是因为程序执行的时候会更快，代码写入也会更简练。

能够改变变量中值的运算符只有自加自减等号以及复合运算符。

8.C#中的关系运算符

>   大于

   <     小于

== 等于

!=  不等于

>=  大于等于

     <=  小于等于

关系表达式：由关系运算符连接起来的表达式。

 赋值表达式：由赋值运算符（等号和复合赋值符）连接起来的表达式。

运算符两侧的内容经关系表达式运算后形成命题，即判断成立不成立，从而引出bool数据类型。运算符两侧运算数据类型要求一致或者兼容；一般数值类数据类型的变量可以比较大小，非数值类型的变量只能比较等于或者不等。

9.bool类型

 只有两个值：true    false

关系表达式形成的命题成立则为true

不成立则为false

例如：

           int a = 12, b = 19;

           bool isRight = a < b;

           Console.WriteLine(isRight);          

           Console.ReadKey();

输出结果是：true;

 

           int a = 12, b = 19;                 

           bool isRight = a > b;

           Console.WriteLine(isRight);

           Console.ReadKey();

输出结果是：false;

10.逻辑运算符

  &    逻辑与  二元运算符

  ||     逻辑或  二元运算符

  ！    逻辑非（取反）  一元运算符

  ^     逻辑异或        二元运算符

1）逻辑与语法：bool isRight=表达式① &表达式②；

逻辑“与”连接的表达式①和②，要求能够求解成bool类型，一般情况下表达式都是关系表达式。

逻辑“与”运算的结果也是bool类型，运算图解如下：

表达式①的值	表达式②的值	逻辑“与”结果
True	True	True
True	False	False
False	True	False
False	False	False

当两个表达式的值都为true时，经过逻辑“与”运算的变量isRight的值为true.

2）逻辑或语法：bool isRight=表达式① |表达式②；

逻辑“或”的运算图解如下：

表达式①的值	表达式②的值	逻辑“与”结果
True	True	True
True	False	True
False	True	True
False	False	False

当两个表达式的值都为false是，经过逻辑“或”运算的变量isRight的值为false,其他情况都是true.

3）逻辑非语法： ！（布尔型表达式）

  如果布尔型表达式为true,则运算后结果为false.

  如果布尔型表达式为false，则运算后结果为false.

4）逻辑异或语法： bool isright=表达式①^表达式②

  当且仅有一个表达式为true时整个语句运算为true，否则运算为false.

       Console.WriteLine(true^true);         //输出false

           Console.WriteLine(true ^false);        //输出true

           Console.WriteLine(false ^true);        //输出true

           Console.WriteLine(false ^false);       //输出false

11.条件运算符及其短路

  &&    条件与    二元运算符

||     条件或     二元运算符

  ？：   条件运算    三元运算符（具体参见循环结构体中三元表达式）

条件运算符同样用于计算可以计算为bool类型结果的表达式，运算图解与对应的逻辑运算符相同。不同的是条件运算符在某些情况下会发生短路而逻辑运算符不会。

   因为条件 && 的判定条件要求两个表达式都为true时才为true，其他都为false，当 &&之前的表达式判定为false时，&&已经直接判断整个连接表达式运算结果为false，此时&&后的表达式将不再运算。

同理，条件||的判定条件要求两个false时才为false,只要有一个true则结果为true，因而当第一个表达式判定值为true时，程序运行到||时将发生短路（终止）。

逻辑或和条件或比较：

           int a = 5;

           int b = 4;

           if (a++>b| a-->b)

           {

               Console.WriteLine("逻辑与");

               Console.WriteLine(a);

               Console.WriteLine(b);

           }

           a = 5;               //为了比较，特意保留原值

           b = 4;

           if (a++ > b || a-- > b)

           {

               Console.WriteLine("条件与");

               Console.WriteLine(a);

               Console.WriteLine(b);

           }

输出：

可以看出，逻辑或判断出第一个表达式为true后继续判断第二个表达式而条件或并未判断。

逻辑与和条件与比较：

 

           int a = 5;

           int b = 4;

           if (a++ < b & a-- < b)

           {

               Console.WriteLine("逻辑与判断为true");

           }

           else

           {

               Console.WriteLine("逻辑与判断为false");

               Console.WriteLine(a);

               Console.WriteLine(b);

           }

           a = 5;

           b = 4;

           if (a++ < b && a-- < b)

           {

               Console.WriteLine("条件与判断为true");

           }

           else

           {

               Console.WriteLine("条件与判断为false");

               Console.WriteLine(a);

               Console.WriteLine(b);

           }

输出：

可以看出，逻辑与判断出第一个表达式为false后继续判断第二个表达式而条件与并未判断。

12.各种运算符的优先级比较（引用自C#语言规范）：

类别	表达式	说明
基本	x.m	成员访问
	x(...)	方法和委托调用
	x[...]	数组和索引器访问
	x++	后增量
	x--	后减量
	new T(...)	对象和委托创建
	new T(...){...}	使用初始值设定项创建对象
	new {...}	匿名对象初始值设定项
	new T[...]	数组创建
	typeof(T)	获得T的System.Type对象
	checked(x)	在 checked上下文中计算表达式
	unchecked(x)	在unchecked上下文中计算表达式
	default(T)	获取类型T的默认值
	delegate {...}	匿名函数（匿名方法）
一元	+x	恒等
	-x	求相反数
	!x	逻辑求反
	~x	按位求反
	++x	前增量
	--x	前减量
	(T)x	显式将x转换为类型T
乘除	x * y	乘法
	x / y	除法
	x % y	求余
加减	x + y	加法、字符串串联、委托组合
	x – y	减法、委托移除

 

移位	x << y	左移
	x >> y	右移
关系和类型检测	x < y	小于
	x > y	大于
	x <= y	小于或等于
	x >= y	大于或等于
	x is T	如果x属于T类型，则返回true，否则返回false
	x as T	返回转换为类型T的x，如果x不是T则返回null
相等	x == y	等于
	x != y	不等于
逻辑AND	x & y	整型按位 AND，布尔逻辑 AND
逻辑XOR	x ^ y	整型按位 XOR，布尔逻辑 XOR
逻辑OR	x | y	整型按位 OR，布尔逻辑 OR
条件AND	x && y	仅当x为true才对y求值
条件OR	x || y	仅当x为false才对 y求值
空合并	X ?? y	如果x为null，则对y求值，否则对x求值
条件	x ? y : z	如果x为true，则对y求值，如果x为false，则对z求值
赋值或匿名函数	x = y	赋值
	xop= y	复合赋值；支持的运算符有： *=  /=  %=  +=  -=  <<=  >>=  &=  ^=  |=
	(T x) => y	匿名函数（lambda表达式）

从上到下，优先级依次降低。

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------