.net第二章数据类型、变量和常量

前言

标识符及其命名规则

变量和常量

数据类型

预定义基本数据类型的使用
整型、浮点型、decimal、浮点型、布尔型、字符型、Object类型

类型的转换

元组

标识符及其命名规则

标识符（identifier）

• 变量、类型、类型成员等的名称

• 第一个字符必须是字母、下划线（“_”）或@，其后的字符可以是字母、下划线或数字

• 区分大小写：例如，ABC和abc视为不同的名称

• C#语言的保留关键字（如if、for、namespace等），不能作为标识符

命名规约

• PascalCase
  自定义类型及其成员(如名称空间、类名、字段、方法等)

• camelCase
  局部变量名和方法参数等

• UPPERCASE
  一般用于常量名

变量和常量

变量

• 成员变量

在类型中声明，作为类型成员的变量(即字段)

静态变量和非静态变量(实例变量)

class Test
{
    int x = 45;
    static int y = 90;
}
1
2
3
4
5

• 局部变量

在类型的成员方法中声明的变量

作为方法定义的参数也属于局部变量，包括值参数、引用参数和输出参数

static void Main(string[] args)
{int j = 10;
for (int i =0; i<=20; i++)
{    
    Console.WriteLine(i.ToString());
}
…}
1
2
3
4
5
6
7

变量的声明

使用前必须先进行声明

变量的赋值和引用

变量的作用域

变量可被访问的范围

例子

    public class TestVariableScope
    {
        static int j = 99;           //静态变量j属于TestVariableScope类
        public static void Main()
        {
            for (int i = 0; i < 3; i++)  //局部变量i属于当前的for语句
            {
                int k = 10;         //局部变量k属于当前的for语句
                Console.WriteLine(k + " * " + i + " = " + k * i);
            } //局部变量i和k的作用域到此为止

            int j = 20;               //定义局部变量j，与类的静态变量j不冲突
            Console.WriteLine("class j=" + TestVariableScope.j);
            Console.WriteLine("local j=" + j);

            for (int i = 0; i < 3; i++) //局部变量i属于当前的for语句，重新定义局部变量i不会冲突
            {
                int k = 20;       //局部变量k属于当前的for语句，重新定义局部变量k不会冲突
                Console.WriteLine(k + " * " + i + " = " + k * i);
            }
        }
    }


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

常量

• 文本常量
• 用户自定义常量

在声明和初始化变量时，在变量的前面加上关键字const,可以将变量指定为一个常量（通常大写）

数据类型

• 每个变量和对象都必须具有声明类型
  值类型、引用类型和指针类型

• 通用类型系统（CTS）

• 值类型（value type）的变量在堆栈（Stack）中直接包含其数据，每个变量都有自己的数据副本（除 ref 和 out 参数变量外），因此对一个变量的操作不影响另一个变量

• 引用类型（reference type）的变量在堆栈（Stack）中存储对数据（对象）的引用（地址），数据（对象）存储在托管运行环境管理的堆（Heap）中。对于引用类型，两个变量可能引用同一个对象，因此对一个变量的操作可能影响另一个变量所引用的对象
  

值类型与引用类型

	  class Class1
	  {
	    public int Value = 0;
	  }
	  class ValueReference
	  {
	    static void Main() 
	    {    
	        int val1 = 0;     int val2 = val1;     val2 = 123;
	       Class1 ref1 = new Class1(); Class1 ref2 = ref1;  ref2.Value = 123;
	        Console.WriteLine("Values: {0}, {1}", val1, val2);
	        Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
                            Console.ReadKey();                
	      }
	  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

装箱和拆箱——值类型与引用类型间的转换

• C#中所有的类型都继承于System.Object根类型，而所有的值类型都继承于System.ValueType类型

• 通过装箱（boxing）和拆箱（unboxing）机制，可以实现值类型和引用类型之间的转换

• 装箱转换是指将一个值类型隐式或显式地转换成一个object类型，或者把这个值类型转换成一个被该值类型应用的接口类型（interface-type）

• 拆箱转换是指将一个对象类型显式地转换成一个值类型，或是将一个接口类型显式地转换成一个执行该接口的值类型

 static void Main()
    {
            int i = 123;
            object obj1 = i;          //隐式装箱（boxing）
            object obj2 = (object)i;    //显式装箱（boxing）
            i = 456;                // 改变 i 的内容
            int j = (int)obj1;          // 拆箱（unboxing）
            Console.WriteLine("The value-type value(i) = {0}", i);
            Console.WriteLine("The value-type value(j) = {0}", j);
            Console.WriteLine("The object-type value(obj1) = {0}", obj1);
            Console.WriteLine("The object-type value(obj2) = {0}", obj2);
            Console.ReadKey();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

预定义基本数据类型的使用

     整型、浮点型、decimal、浮点型、布尔型、字符型、Object类型
1

整型数据类型

C#支持8个预定义整数类型
分别支持8位、16位、32位和64位整数值的有符号和无符号的形式

浮点型数据类型

C#支持2种浮点数据类型（float和double），用于包含小数的计算

decimal数据类型

• decimal数据类型一般用于财务计算，即可以用较大的精确度来表示货币值
• decimal常量
• 以M或m为后缀的实数的类型为decimal
• 例如，1m、1.5m、1e10m和123.456M
• 不能隐式地将double类型转换为decimal类型

布尔型数据类型

• C#的bool数据类型用于逻辑运算

• 包含bool值true或false

• bool值和整数值不能相互转换

 static void Main()
      {
	bool b1 = true;
	//bool b2 = 0;//编译错误：常量值“0”无法转换为“bool”
	char c = '0';
	bool b3 = (c > 64 && c < 123);
	Console.WriteLine("{0}\t{1}",b1,b3);
                 Console.ReadKey();
      }
1
2
3
4
5
6
7
8
9

字符型数据类型

• C#的char数据类型用于保存单个字符的值

• C#的char表示一个16位的（Unicode）字符
  

• 字符常量

• 使用单引号括起来，如’a’，’A’，’1’，’*’等

• 特殊符号需要使用转义序列标识

 //char char0 = "Z";    //使用双引号会产生编译错误
char ch1 = 'X';        //字符常量
char ch2 = '\x0058';   //16进制编码
char ch3 = (char)88;   //从整型转换
char ch4 = '\u0058';   //Unicode

Console.WriteLine("{0}\t{1}\t{2}\t{3}", ch1, ch2, ch3, ch4);
Console.WriteLine("{0}的小写字母是：{1}", ch1, Char.ToLower(ch1));
Console.WriteLine("{0}是字母吗？{1}", ch1, Char.IsLetter(ch1)); 
1
2
3
4
5
6
7
8
9

可为null的类型和Object类型

• 可以为null的类型

• 可被赋值为null值的值类型变量，其取值范围为其基础值类型正常范围内的值，再加上一个null值

• 例如，bool? (Nullable)的值包括true、false或null

声明语法：T? x 或Nullable x
例如：int? num = null;

string数据类型

• C#字符串处理使用string（System.String的别名）类型表示零或更多Unicode字符组成的序列

• string是引用类型

• C#支持两种形式的字符串

  • 正则字符串（regular string）
    包含在双引号中的零个或多个字符组成（如"hello"），并且可以包含简单转义序列（如表示制表符的\t）、十六进制转义序列和Unicode转义序列
  • 原义字符串（verbatim string）
    由@字符后跟开始的双引号字符、零个或多个字符以及结束的双引号字符组成。一个简单的示例就是 @"hello“

内插字符串（C# 6.0）

Object类型

• object类型是C#编程语言的类层次结构的根类型，object是System.Object的别名，所有的类型都隐含地最终派生于System.Object类

• object类型主要可以用于两个目的：

• 可以使用object引用绑定任何类型的对象

• object类型执行许多基本的一般用途的方法，包括Equals()、GetHashCode()、GetType()和ToString()等

隐式类型

类型的转换

隐式转换

• 只允许发生在从小的值范围的类型到大的值范围的类型的转换，转换后的数值大小不受影响
• 然而，从int、uint或long到float的转换以及从long到double的转换的精度可能会降低

int a;
double d;
a = 255;
d = a;    //从int到double的隐式转换
1
2
3
4

显式转换（强制转换）

x = 1.23;
float y = (float)x;    //显式地将x转换为float类型
1
2

• 显式强制转换调用转换运算符，从一种类型转换为另一种类型。如果未定义相应的转换运算符，则强制转换会失败。可以编写自定义转换运算符，在用户定义类型之间进行转换

• 显式数值转换可能导致精度损失，也可能引发异常（如溢出异常OverflowException）

Convert类提供的类型转换方法

double dNumber = 23.15;      //OK: 23.15默认为double浮点型变量
int iNumber = System.Convert.ToInt32(dNumber);      //返回 23
bool bNumber = System.Convert.ToBoolean(dNumber);  //返回 True
string strNumber = System.Convert.ToString(dNumber);  //返回 "23.15"
char chrNumber = System.Convert.ToChar(strNumber[0]);//返回 ‘2’
1
2
3
4
5

溢出检查和checked关键字

使用关键字checked可以指定已检查的上下文；使用关键字unchecked可以指定未检查的上下文

元组

• 元组（Tuples）是一组有序系列
• C#7.0提供了元组支持，使用元组可以提供轻量级的多个元素数据处理支持
• 例如，一个包含两个元素的元组（二元组），第一个元素保存城市名，第二个元素保存这个城市所在的国家
  

元组对象的创建

var t1 = new Tuple <T1,[T2,…,T8]> (x1, [x2,…,x8]);
var t2 = Tuple. Create <T1,[T2,…,T8]> (x1, [x2,…,x8]);

var p1 = new Tuple <string , int> (“New York”, 8008278);
var p2 = Tuple. Create <string , int> (“New York”, 8008278);
1
2
3
4
5

元组的访问

临时虚拟变量（Discard）