黑马程序员————————C#基础知识（三）
2013-10-03 12:59
561 查看
----------------------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时，经过逻辑“与”运算的变量isRight的值为true.
2）逻辑或语法：bool
isRight=表达式① |表达式②；
逻辑“或”的运算图解如下：
当两个表达式的值都为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#语言规范）：
从上到下，优先级依次降低。
----------------------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 |
2）逻辑或语法：bool
isRight=表达式① |表达式②；
逻辑“或”的运算图解如下：
| 表达式①的值 | 表达式②的值 | 逻辑“与”结果 |
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
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培训、期待与您交流！
----------------------
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- [黑马程序员] _C#基础知识小结
- 黑马程序员————————C#基础知识之结构体（二）
- 黑马程序员_c#基础知识学习笔记:数组
- 黑马程序员————————C#基础知识（五）
- 黑马程序员————————C#基础知识之多线程
- 黑马程序员—c#基础知识2。。
- 黑马程序员-C#基础知识
- 黑马程序员----C#基础知识06
- 黑马程序员-C#基础知识-学习笔记01
- 黑马程序员—c#基础知识。。5
- “黑马程序员”~~C#基础知识One
- 黑马程序员————————C#基础知识之面向对象（一）
- 黑马程序员.Net培训 C#基础知识——数据类型
- 黑马程序员_C#基础知识学习笔记:变量的使用和命名规则
- 黑马程序员----C#基础知识07
- 黑马程序员————————C#基础知识（一）
- 黑马程序员_c#基础知识学习笔记:方法重载和out,ref传参
- 黑马程序员_C#基础知识学习笔记:逻辑表达式
- 黑马程序员－c#基础知识小结
- 黑马程序员--01 c#基础知识