一.类型转换

类型转换：不同数据类型之间的相互转换

1.隐式转换

不同类型的自动转换（大类型装小类型）

（1）相同大类型之间的转换

有符号的类型：long —> int —>short —>sbyte

long l = 1;
int i = 1;
short sh = 1;
sbyte sb = 1;

//隐式转换，int类型隐式转换为了long
l = i;
//可以用大范围装小范围的类型（隐式转换）

//不能用小范围类型去装大范围类型
//i = l;
//也就是说大范围的数不能隐式转换为小范围的数

#region 可转换类型
l = i;
l = sh;
l = sb;
i = sh;
i = sb;
sh = sb;
#endregion
//这些都是大类型装小类型,其他的都不可以

同理：

无符号的类型：ulong —> uint —> ushort —> byte

浮点型：double —> float

但是：decimal类型无法用隐式转换的形式去存储double和float类型

特殊类型，不存在隐式转换。

（2）不同大类型之间的转换

①有符号和无符号之间的转换

//有符号类型
sbyte sb = 1;
short sh = 1;
int i = 1;
long l = 1;
//无符号类型 是不能装负数的
byte b = 1;
ushort ush = 1;
uint ui = 1;
ulong ul = 1;

//无符号的不能装有符号的
//有符号的可以装无符号的
//所有有符号的数不能隐式转换为无符号的数
sh= b;
i = ush;
i = b;
l = ui;
l = ush;
l = b;
//而且无符号的数的范围不能超过有符号数的范围才可以隐式转换，如以上

②浮点型和整数（有、无符号）之间的转换

//整型
sbyte sb = 1;
short sh = 1;
int i = 1;
long l = 1;
byte b = 1;
ushort ush = 1;
uint ui = 1;
ulong ul = 1;
//浮点型
float f = 1;

f = sb;
f = sh;
f = i;
f = l;
f = b;
f = ush;
f = ui;
f = ul;
 
float f1 = 1000000000000000000000000000;
Console.Write(f1);
//同理decimal也可以
decimal de = sb;

所以，所有的浮点型都可以装载整型变量。也就是说所有的整型变量都可以隐形转换为浮点型。

double —> float —> 所有整型变量（有、无符号）

decimal  —> 所有整型变量（有、无符号）

相反可得知，浮点型不可以隐形转换为整型变量。

③特殊类型和其他数据类型

bool没有办法和其他类型相互隐形转换

其他数据类型没有办法隐形转换为char类型

但是char类型可以隐形转换为整型和浮点型

bool bo = true;
char c = 'A';
string str = "1231";

//整型
sbyte sb = 1;
short sh = 1;
int i = 1;
long l = 1;
byte b = 1;
ushort ush = 1;
uint ui = 1;
ulong ul = 1;
//浮点型
float f = 1;

sh = c;
//范围在char字符的ASCII码值范围之内的不能隐形转换
Console.WriteLine(sh);

char隐形转换成的数据类型是一个ASCII码，由于计算机存储的是二进制，字符，中文，英文，标点符号在计算机中都对应一个ASCII码。

string类型无法与其他数据类型隐形转换。

2.显式转换

显式转换—>手动处理  强制转换

（1）括号强转

作用：一般情况下，将高精度的类型强制转换为低精度

语法：变量类型        变量名        =        （变量类型）变量

注意：精度问题  范围类型

①相同大类的整型

//整型有符号
sbyte sb = 1;
short sh = 1;
int i = 1;
long l = 1;
sb = (sbyte)sh;
sh = (short)i;
i = (int)l;
Console.WriteLine(sb);
Console.WriteLine(sh);
Console.WriteLine(i);

//整型无符号
byte b = 1;
ushort ush = 1;
uint ui = 1;
ulong ul = 1;
b = (byte)ush;
ush = (ushort)ui;
ui = (uint)ul;
Console.WriteLine(b);
Console.WriteLine(ush);
Console.WriteLine(ui);

//浮点型
float f = 1.1f;
double d = 1.3242424242424242;

f = (float)d;
Console.WriteLine(f);

②不同类型之间转换

//有、无符号的整型
int i = -1;
uint ui = 1;
ui = (uint)i;
Console.WriteLine(ui);
//整型和浮点型
float f = 1.5f;
i = (int)f;
Console.WriteLine(i);
//char和数据类型
char c = 'A';
int i2 = 1;
c = (char)i2;
Console.WriteLine(c);
//bool和string类型

//无法将bool类型强制转换为string类型，以及无法将string类型强制转换为bool类型。
/*bool bo = true;
string str = "false";
string str1 = (string)bo;
bool bo1 = (bool)str;
Console.WriteLine(str1);
Console.WriteLine(bo1);*/

所以括号强转可能会出现范围问题造成异常

（2）Parse法

作用：把字符串类型转换为对应的类型

语法：变量类型.Parse（“字符串”）

注意：字符串必须能够转换为对应类型，否则报错

字符串的范围，必须是能被变量存储的。

//有符号类型
string str1 = "123";
int i = int.Parse(str1);
Console.WriteLine(i);

//无符号类型
string str2 = "321";
uint ui = uint.Parse(str2);
Console.WriteLine(ui);

//浮点型
string str3 = "1.23";
float f = float.Parse(str3);
Console.WriteLine(f);

//特殊类型
string str4 = "true";
bool bo = bool.Parse(str4);
Console.WriteLine(bo);

string str5 = "A";
char c = char.Parse(str5);
Console.WriteLine(c);

（3）Convert法

作用：各个类型之间相互转换。

语法：Convert.To目标类型（变量或常量）

注意：填写的变量和常量必须正确，否则出错

//转字符串
int a = Convert.ToInt32("12");
Console.WriteLine(a);
//浮点数，精度比括号强转好一点，会四舍五入
a = Convert.ToInt32(1.55f);
Console.WriteLine(a);
//bool类型
a = Convert.ToInt32(true);
Console.WriteLine(a);
a = Convert.ToInt32(false);
Console.WriteLine(a);
//char类型
a = Convert.ToInt32('A');
Console.WriteLine(a);

//有符号
sbyte sb = Convert.ToSByte("1");
short sh = Convert.ToInt16("1");
int i = Convert.ToInt32("1");
long l = Convert.ToInt64("1");
//无符号
byte b = Convert.ToByte("1");
ushort ush = Convert.ToInt16("1");
uint ui = Convert.ToInt32("1");
ulong ul = Convert.ToInt64("1");
//浮点型
float f = Convert.ToSingle("13.2");
double d = Convert.ToDouble("13.2");
decimal de = Convert.ToDecimal("13.2");
//特殊
bool bo = Convert.ToBoolean("true");
char c = Convert.ToChar("A");
string str = Convert.ToString(231313);


Console.WriteLine(sb);
Console.WriteLine(sh);
Console.WriteLine(i);
Console.WriteLine(l);
Console.WriteLine(b);
Console.WriteLine(ush);
Console.WriteLine(ui);
Console.WriteLine(ul);
Console.WriteLine(f);
Console.WriteLine(d);
Console.WriteLine(de);
Console.WriteLine(bo);
Console.WriteLine(c);
Console.WriteLine(str);

（4）其他类型转string类型

作用：拼接打印

语法：变量.tToString（）；

string str = 1.ToString();
Console.WriteLine(str);

str = true.ToString();
Console.WriteLine(str);

str = 'A'.ToString();
Console.WriteLine(str);

str = 1.2f.ToString();
Console.WriteLine(str);

//当我们进行字符串拼接时，就会自动调用toString()
Console.WriteLine("1234241" + 1 + true);

二.异常捕获

1.作用

通过对异常捕获的学习，可以避免代码出现错误时吗，程序卡死

//获取键盘输入的字符串
string str = Console.ReadLine();
int i = int.Parse(str);

2.基本语法

//必要部分
try
{
    //把希望进行异常捕获的代码放大try中
    //如果try里面的代码，报错了，不会让程序卡死
}
catch(Exception e)
{
    //如果出错了运行 catch中的代码，来捕获异常
    //catch(Exception e)具体报错跟踪，通过e得到 具体的错误信息                                                                                                                                 
}
//可选部分
finally
{
    //最后执行的代码，不管有没有出错都会执行的代码
}

注意：异常捕捉代码基本结构中，不需要加；在里面去写代码逻辑时，每一句代码才加；

3.实践

try
{
    string str = Console.ReadLine();
    int i = int.Parse(str);
    Console.WriteLine(i);
}
catch
{
    Console.WriteLine("请输入合法数字");
}
finally
{
    Console.WriteLine("执行完毕");
}