CS1L7——显式转换

显式转换

显式转换就是将不能隐式转换的变量类型手动强制转换为另一种类型，这种转换需要用额外的指令和语法（显式转换的类型）进行强行转换
显式转换主要有四种类型：括号强转、Parse()、Convent()、ToString()

关键字

1
2
3
___.Parse()        //字符串类型转换为相应的类型
Convert.To___()    //更准确的将各种类型进行相互转换
.ToString()        //其他类型转string的方法

显式转换的类型

  1. 括号强转

    括号强转是将高精度的类型转换为低精度的类型，​bool​ 和 ​string​ 不能通过括号强转

    注意！括号强转时刻要注意当前变量是否超出要转换的类型的范围！否则可能会出现异常（溢出而导致数字显示不正确）

    1
    2
    3
    //语法：变量类型 变量名 = (变量类型)变量;
    //注意：精度问题 范围问题
    short s = (short)i;

    有符号整形的转换

    1
    2
    3
    //有符号整形
    int i = (int)l;
    sbyte sb = (sbyte)s;

    括号强转可能会出现范围问题造成的异常（下面的结果就是超出范围导致溢出了）

    1
    2
    3
    i = 40000;
    short s = (short)i;
    Console.WriteLine(s);

    输出：

    1
    -25536    //结果是异常的

    无符号整形的转换

    1
    2
    //无符号整形
    b = (byte)ui;

    浮点数之间的转换

    浮点数括号强转可能会出现精度丢失（四舍五入）

    1
    2
    3
    4
    //浮点数之间
    d = 1.123456789123456789;
    f = (float)d;
    Console.WriteLine(f);

    输出：

    1
    1.1234568    //浮点数括号强转可能会出现精度丢失（四舍五入）

    无符号和有符号的相互转换

    将负数转化为无符号会出现异常
    在转换时时刻注意范围，否则结果可能会出现异常

    1
    2
    3
    4
    //无符号和有符号
    i = -1;
    ui = (uint)i;
    Console.WriteLine(ui);

    输出：

    1
    4294967295    //结果是异常的！

    浮点与整形之间的转换

    浮点转整形会直接抛弃小数点后的部分，不会四舍五入

    1
    2
    3
    //浮点与整形
    i = (int)1.789f;
    Console.WriteLine(i);

    输出：

    1
    1    //浮点转整形会直接抛弃小数点后的部分，不会四舍五入

    char和数值类型的转换

    1
    2
    3
    4
    i = 'A';
    c = (char)i;
    Console.WriteLine(i);
    Console.WriteLine(c);

    输出：

    1
    2
    65
    A

  2. Parse法

    作用：把字符串类型转换为相应的类型
    语法：变量类型.Parse("字符串")​
    注意：字符串必须能够转换为相应类型否则报错，填写超出变量类型的范围内的内容也会报错

    • 有符号

      1
      2
      3
      4
      5
      6
      //有符号
      int i4 = int.Parse("123");
      Console.WriteLine(i4);
      short s5 = short.Parse("123");
      Console.WriteLine(s5);                    //注意！填写超出变量类型的范围内的内容也会报错
      Console.WriteLine(sbyte.Parse("1"));    //直接打印语句的结果

      输出：

      1
      2
      3
      123
      123
      1

    • 无符号

      规则与有符号相同

      1
      2
      3
      4
      //无符号
      Console.WriteLine(byte.Parse("2"));
      Console.WriteLine(ushort.Parse("3"));
      Console.WriteLine(uint.Parse("4"));

      输出：

      1
      2
      3
      2
      3
      4

    • 浮点数

      写超出范围的会四舍五入

      1
      2
      3
      float f4 = float.Parse("1.232323232323");    //写超出范围的会四舍五入
      Console.WriteLine(f4);
      double d4 = double.Parse("1.2323");

      输出：

      1
      1.2323233

    • 特殊类型

      1
      2
      3
      4
      bool b5 = bool.Parse("true");
      Console.WriteLine(b5);
      char c2 = char.Parse("A");
      Console.WriteLine(c2);

      输出：

      1
      2
      True
      A

  3. Convent法

    作用：更准确的将各种类型进行相互转换
    语法：Convert.To目标类型（变量或常量）​
    注意：填写的变量或常量必须正确，否则报错

    • 字符串转其他

      如果是字符串转其他类型，填写了不符合规则内的内容就会报错

      1
      2
      int a = Convert.ToInt32("12");    //32是位数，4个字节有32位
      Console.WriteLine(a);

      输出：

      1
      12

    • 浮点数转整数

      ​Convent​ 比括号强转更好，会四舍五入

      1
      2
      a = Convert.ToInt32(1.654321f);
      Console.WriteLine(a);

      输出：

      1
      2

    • bool值可以转成数值类型

      ​true​ 对应 1​，false​ 对应 0​

      1
      2
      3
      4
      a = Convert.ToInt32(true);
      Console.WriteLine(a);
      a = Convert.ToInt32(false);
      Console.WriteLine(a);

      输出：

      1
      2
      1
      0

    • ​char​ 也可以转换为数值类型

      会转换为字符对应的编码

      1
      2
      a = Convert.ToInt32('A');
      Console.WriteLine(a);

      输出：

      1
      65

    每种类型都存在对应类型的Convert方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    //每种类型都存在对应类型的Convert方法
    sbyte sb2 = Convert.ToSByte("1");
    short s3 = Convert.ToInt16("1"); // short占16位，因此可以视为int16
    int s4 = Convert.ToInt32("1");
    long l4 = Convert.ToInt64("1"); // long占64位，因此可以视为int64

    byte b2 = Convert.ToByte("1");
    ushort us3 = Convert.ToUInt16("1"); // ushort占16位，因此可以视为uint16
    uint us4 = Convert.ToUInt32("1");
    ulong ul4 = Convert.ToUInt64("1"); // ulong占64位，因此可以视为uint64

    float f2 = Convert.ToSingle("1"); // float是单精度，因此可称为single
    double d2 = Convert.ToDouble("1");
    decimal de2 = Convert.ToDecimal("1");

    bool b3 = Convert.ToBoolean("true"); //注意是Toboolean
    char c4 = Convert.ToChar("A");

    string str5 = Convert.ToString(12345678);

  4. 其他类型转string

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    string str4 = 1.ToString();
    str4 = true.ToString();
    str4 = 'A'.ToString();
    str4 = 1.2f.ToString();

    int aa = 1;
    str4 = aa.ToString();

    Console.WriteLine("123123" + 1 + true);
    Console.WriteLine("字符串拼接时会自动将非字符串类型使用.ToString()");

    输出：

    1
    2
    1231231True
    字符串拼接时会自动将非字符串类型使用.ToString()

本课源代码

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
namespace lesson7显式转换
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("显式转换");
            //显式转换——>手动强制转换变量类型

            #region 变量申明
            //1、有符号的整形变量 能存储一定范围内的正负数包括0的变量类型
            sbyte sb = 1; // -128~127
            int i = 1;  //  -21亿~21亿
            short s = 1;    //  -32768~32767
            long l = 1;    //  -九百万兆~九百万兆
            //2、无符号的整型变量 能存储一定范围内0和正数的变量类型
            byte b = 1;    //  0~255
            uint ui = 1;    //  0~42亿
            ushort us = 1;  //  0~65535
            ulong ul = 1;   //  0~18百万兆
            //3、浮点数（小数）
            float f = 1.1f;    //  数字后必须加f声明float，因为小数会被默认为double，从非0数算起为有效数字，7/8位有效数字，根据编译器不同有可能不同，超出部分会四舍五入
            double d = 1.11;    //  从非0数算起为有效数字，15~17位有效数字，超出部分会四舍五入
            decimal de = 0.1m;    //  数字后必须加m声明，因为小数会被默认为double，27~28位有效数字，不建议使用
            //4、特殊类型
            bool bo = true; //  true或者false
            char c = 'a';   //  需要加'',单个字符
            string st = "hello";    //  需要加"",字符串
            #endregion

            #region 括号强转 将高精度的类型强制转换为低精度
            Console.WriteLine("一般情况下将高精度的类型强制转换为低精度,在转换时时刻注意范围，否则结果可能会出现异常");
            //语法：   变量类型 变量名 = (变量类型)变量;
            //注意：   精度问题 范围问题
            //有符号整形
            i = 40000;
            s = (short)i;
            Console.WriteLine(s);
            //括号强转可能会出现范围问题造成的异常（上面就溢出了）
            i = (int)l;
            sb = (sbyte)s;
            Console.WriteLine(sb);

            //无符号整形
            b = (byte)ui;

            //浮点数之间
            d = 1.123456789123456789;
            f = (float)d;
            Console.WriteLine(f);
            //括号强转可能会出现精度丢失（四舍五入）

            //无符号和有符号
            i = -1;
            ui = (uint)i;
            Console.WriteLine(ui);
            //将负数转化为无符号会出现异常
            //在转换时时刻注意范围，否则结果可能会出现异常

            //浮点与整形
            i = (int)1.789f;
            Console.WriteLine(i);
            //浮点转整形会直接抛弃小数点后的部分，不会四舍五入

            //char和数值类型
            i = 'A';
            c = (char)i;
            Console.WriteLine(i);
            Console.WriteLine(c);

            //bool和string不能通过括号强转

            #endregion

            #region Parse法 常用于把字符串类型转换为相应的类型
            //作用    把字符串类型转换为相应的类型
            //语法    变量类型.Parse("字符串")
            //注意    字符串必须能够转换为相应类型否则报错

            //有符号
            int i4 = int.Parse("123");
            Console.WriteLine(i4);
            //如果填写了不符合规则内的内容就会报错
            short s5 = short.Parse("123");
            Console.WriteLine(s5);
            //填写超出变量类型的范围内的内容也会报错
            Console.WriteLine(sbyte.Parse("1"));//  直接打印语句的结果

            //无符号
            Console.WriteLine(byte.Parse("2"));
            Console.WriteLine(ushort.Parse("3"));
            Console.WriteLine(uint.Parse("4"));
            //规则与有符号相同

            //浮点数
            float f4 = float.Parse("1.232323232323");
            Console.WriteLine(f4);
            //写超出范围的会四舍五入
            double d4 = double.Parse("1.2323");

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

            char c2 = char.Parse("A");
            Console.WriteLine(c2);

            #endregion

            #region Convert法 更准确的将各种类型进行相互转换
            //  作用 更准确的将各种类型进行相互转换
            //  语法 Convert.To目标类型（变量或常量）
            //  注意 填写的变量或常量必须正确，否则报错

            //字符串转其他
            int a = Convert.ToInt32("12");//32是位数，4个字节有32位
            Console.WriteLine(a);
            //如果是字符串转其他类型，填写了不符合规则内的内容就会报错
            a = Convert.ToInt32(1.654321f);
            Console.WriteLine(a);
            //Convent比括号强转更好，会四舍五入

            //bool值可以转成数值类型 true对应1 false对应0
            a = Convert.ToInt32(true);
            Console.WriteLine(a);
            a = Convert.ToInt32(false);
            Console.WriteLine(a);

            //char也可以转换为数值类型
            a = Convert.ToInt32('A');
            Console.WriteLine(a);

            //每种类型都存在对应类型的Convert方法
            sbyte sb2 = Convert.ToSByte("1");
            short s3 = Convert.ToInt16("1"); // short占16位，因此可以视为int16
            int s4 = Convert.ToInt32("1");
            long l4 = Convert.ToInt64("1"); // long占64位，因此可以视为int64

            byte b2 = Convert.ToByte("1");
            ushort us3 = Convert.ToUInt16("1"); // ushort占16位，因此可以视为uint16
            uint us4 = Convert.ToUInt32("1");
            ulong ul4 = Convert.ToUInt64("1"); // ulong占64位，因此可以视为uint64

            float f2 = Convert.ToSingle("1"); // float是单精度，因此可称为single
            double d2 = Convert.ToDouble("1");
            decimal de2 = Convert.ToDecimal("1");

            bool b3 = Convert.ToBoolean("true"); //注意是Toboolean
            char c4 = Convert.ToChar("A");

            string str5 = Convert.ToString(12345678);

            #endregion

            #region 其他类型转string
            //作用：拼接打印
            //语法：变量.toString();
            string str4 = 1.ToString();
            str4 = true.ToString();
            str4 = 'A'.ToString();
            str4 = 1.2f.ToString();

            int aa = 1;
            str4 = aa.ToString();

            Console.WriteLine("123123" + 1 + true);
            Console.WriteLine("字符串拼接时会自动将非字符串类型使用.ToString()");

            #endregion

            #region 练习
            Console.WriteLine("将24069转成字符并打印");
            char c6 = Convert.ToChar(24069);
            Console.WriteLine(c6);
            Console.WriteLine("提示用户输入姓名、语文、数学、英语成绩，并将输入的三门成绩用整形变量存储");
            Console.Write("请输入你的姓名:");
            string name = Console.ReadLine();
            Console.Write("请输入你的语文成绩:");
            int chinese = Convert.ToInt32(Console.ReadLine());
            Console.Write("请输入你的数学成绩:");
            int math = int.Parse(Console.ReadLine());
            Console.Write("请输入你的英语成绩:");
            int english = int.Parse(Console.ReadLine());


            #endregion
        }
    }
}