Unity基础之C#入门篇笔记3：类型转换_unity double转float

类型转换

什么是类型转换

不同变量类型之间的相互转换

隐式转换

隐式转换规则：不同类型之间自动转换（大范围装小范围）；

1.相同大类型之间的转换

1. 有符号：long ; int ; short ; sbyte(从大到小)

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

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

//不能用小范围的类型去装载大范围的类型
i=l;//该行报错
s=l;//该行报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14

数据类型范围大小可以参考 Unity基础之C#入门篇笔记1

2. 无符号：ulong ; uint ; ushort ; byte(从大到小)

ulong ul =1;
uint ui = 1;
ushort us = 1;
byte b = 1;

//隐式转换  int隐式转换成了long
//可以用大范围的类型去装载小范围的类型（隐式转换）
ul=ui;
ul=us;
ui=us;

//不能用小范围的类型去装载大范围的类型
ui=ul;//该行报错
us=ul;//该行报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 浮点数：decimal; double; float(从大到小)

decimal de = 1.1m;
double d = 1.1;
float f = 1.1f;
//decimal 这个类型 没有办法用隐式转换的形式 去存储 double和float
d=f;//double隐式转换为  double

//float 可以隐式转换为  double
1
2
3
4
5
6
7

注：
1：decimal 这个类型 没有办法用隐式转换的形式 去存储 double和float
2：float 可以隐式转换为 double

4. 特殊类型：bool ; char; string(它们之间不存在隐式转换)

2.不同大类型之间的转换

1. 无符号和有符号之间：

//无符号
ulong ul2 =1;
uint ui2 = 1;
ushort us2 = 1;
byte b2 = 1;
//有符号
long l2 =1;
int i2 = 1;
short s2 = 1;
sbyte sb2 = 1;

//无符号装有符合
//无符号的变量 不可以 装置  有符号的变量（有符号可以表示为负数，但无符号不能）
b2 = sb2;//报错
us2 = sb2;//报错
ul2 = sb2;//报错

//有符号装无符合
//有符号的变量 可以 装置  无符号的变量 （前提：范围一定要覆盖，存在隐式转换）
i2=ui2;//报错：因为有符号的变量  可能会超过  这个无符号数的范围
i2 = b2;//正确：因为有符号的变量 无论是多少  都在这个无符号数的范围内

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 浮点数和整数（有，无符号）之间：

//浮点数
decimal de2 = 1.1m;
double d2 = 1.1;
float f2 = 1.1f;
//无符号
ulong ul2 =1;
uint ui2 = 1;
ushort us2 = 1;
byte b2 = 1;
//有符号
long l2 =1;
int i2 = 1;
short s2 = 1;
sbyte sb2 = 1;

//浮点数装整数
//浮点数 可以装载  任何类型的整数  存在隐式转换
f2 = l2;
f2 = ul2;
f2 = s2;
f2 = ui2;
f2 = 1000000000000000000;//不报错（用科学计数法表示）：浮点数可表示范围大于整型变量

//decimal 不能隐式存储 float和double
//但是 decimal 可以 隐式存储整型变量
de = l2;
de = ul2;

//总结
//double--> float--> 所有整型（无符号，有符号）
//decimal --> 所有整型（无符号，有符号）

//整数装浮点数
//整数 不能装载 浮点数 （因为整数不能表示小数）
i2 = f2;//报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

总结：
1：double–> float–> 所有整型（无符号，有符号）
2：decimal --> 所有整型（无符号，有符号）
3：整数 不能装载 浮点数 （因为整数不能表示小数）

3. 特殊类型和其它类型之间：特殊类型不能和其它类型相互隐式转换

//浮点数
decimal de2 = 1.1m;
double d2 = 1.1;
float f2 = 1.1f;
//无符号
ulong ul2 =1;
uint ui2 = 1;
ushort us2 = 1;
byte b2 = 1;
//有符号
long l2 =1;
int i2 = 1;
short s2 = 1;
sbyte sb2 = 1;
//特殊类型
bool bo2 = true;
char c2 = 'A';
string str = "1234"


//bool 没有办法和其他类型 相互隐式转换
bo2 = i2;//报错
bo2 = f2;//报错
bo2 = ui2;//报错
i2 = bo2;//报错
ui2 = bo2;//报错
f2 = bo2;//报错
bo2 = c2;//报错
c2 = bo2;//报错
bo2 = str2;//报错
str2 = bo2;//报错


//char  char   没有办法隐式存储  其它类型变量
c2 = i2;//报错
c2 = f2;//报错
c2 = ui2;//报错
c2 = str2;//报错

//char  可以隐式转换成  整型和浮点型
//char 隐式转换成数值类型时  对应的数值 是一个ASCII码
//一个字符 对应一个数字 ASCII码是一种对应关系
i2 = c2;//打印出 i2 为 65
f2 = c2;//打印出 f2 为 65
ui2 = c2;//打印出 ui2 为 65

//string 类型 无法和其他类型相互转换

i2 = =str2;//报错
ui2 = str2;//报错
f2 = dtr2;//报错
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

总结：
1：bool 没有办法和其他类型 相互隐式转换
2：char 没有办法隐式存储 其它类型变量
3：char 可以隐式转换成 整型和浮点型（char 隐式转换成数值类型时 对应的数值 是一个ASCII码）
4：string 类型 无法和其他类型相互转换

4. 总结：隐式转换规则

1：高精度（大范围）装低精度（小范围）
2：double --> float --> 整数（有符号，无符号）–> char
3：decimal --> 整数（有符号，无符号）–> char
4：string 和 bool 不参与隐式转换规则

显式转换

显式转换：手动处理，强制转换；

1.括号强转

作用：一般情况下，将高精度的类型强制转换为低精度
语法： 变量类型 变量名 = (变量类型) 变量 ;
注意：精度问题 范围问题

//有符号整型
sbyte sb = 1;
short s = 1;
int i = 40000;
long l = 1;

// int 强制转换为 short
//括号强转 可能会出现范围问题 造成的异常
s = (short)i;

//有符号整型
byte b = 1;
uint ui = 40000;
b = (byte)ui;

//浮点之间
float f = 1.1f;
double d = 1.1234567890123456789 f;
//括号强转 可能会出现精度问题 造成的异常
f = (float)d;

//无符号和有符号
uint ui2 = 1;
int i2 = -1;
//在括号强转时需要注意范围 不然结果可能有异常
ui2 = (uint)i2;

//浮点和整型
//浮点数括号强转整型 会直接抛弃小数点后面的小数
i2 = (int)1.24f;//打印结果为1

//char 和数值类型
i2 = 'A';
char c =(char)i2;

//bool 和 string  不能够通过 括弧强转

bool bo = true;
int i3 = (bool)bo;//报错
string str ="123";
i3 = (str)str;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.Parse法

作用：把字符串类型转换为对应的类型
语法： 变量类型.Parse(“字符串”);
注意：字符串必须能转换成对应类型，否则报错

//有符号
string str2 = "123";
int i4 = int.Parse(str2);
short s3 = short.Parse("4");
//字符串必须能转换成对应类型，否则报错
int i4 = int.Parse(123.45);//报错
//字符串值的范围必须是能够被变量存储的值，否则报错
short s3 = short.Parse("40000");//报错

//无符号
uint ui4 = uint.Parse(str2);
ushort us3 = ushort.Parse("4");
//字符串必须能转换成对应类型，否则报错
uint ui4 = uint.Parse(123.45);//报错
//字符串值的范围必须是能够被变量存储的值，否则报错
ushort us3 = ushort.Parse("40000");//报错

//浮点数
float f3 = float.Parse("1.232");
double d3 = doube.Parse("1.230");

//特殊类型
bool b5 = bool.Parse("true");
char c2 = char.Parse("A");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.Conver法

作用：更准确的将 各个类型之间进行相互转换
语法： Convert.To目标类型(变量或常量);
注意：填写的常量或者变量必须正确，否则报错

//转字符串 如果是把字符串转对应类型 那字符串一定要合法合规
int a = Convert.ToInt32("12");//打印结果为12

//精度比括号强转好，会四舍五入
a = Convert.ToInt32(1.45815f);//打印结果为2

//bool也可以转成数值类型 1对应true 0对应false
a = C.ToInt32(true);//打印结果为1
a = Convert.ToInt32(false);//打印结果为0

a = Convert.ToInt32('A');//打印结果为65

//每一个类型都存在对应的Convert中的方法
sbyte sb5 = Convert.ToSByte("1");
short s5 = Convert.ToInt16("1");
int i5 = Convert.ToInt32("1");
long l5 = Convert.ToInt64("1");

byte b5 = Convert.ToByte("1");
ushort us5 = Convert.ToUInt16("1");
uint ui5 = Convert.ToUInt32("1");
ulong ul5 = Convert.ToUInt64("1");

float f5 = Convert.ToSingle("13.2");
double d5 = Convert.ToDouble("13.2");
decimal de5 = Convert.ToDecimal("13.2");

bool bo5 = Convert.Boolean("true");
char c5 = Convert.ToChar("A");
string str5 = Convert.Tostring("54545");


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4.其它类型转string

作用：拼接打印
语法： 变量.ToString();

string str6 = 1.ToString();
str6 = true.ToString();
str6 = 'A'.ToString();
str6 = 1.2f.ToString();

int aa = 1;
str6 = aa.ToString();
bool bo6 = true;
str6 = bo6.ToString();

//当我们进行字符串拼接时，会自动调用ToString 转成string
Console.WriteLine("1231" + 1 + true);//拼接打印

1
2
3
4
5
6
7
8
9
10
11
12
13

泰课在线 学习笔记