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

来源：互联网发布：html导航页面源码编辑：程序博客网时间：2024/06/04 18:22

----------------------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

False

True

False

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

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

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

表达式①的值

表达式②的值

逻辑“与”结果

True

False

True

False

True

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

前减量

(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培训、期待与您交流！ ----------------------