第二课时之c#语言基础

第一章 c#语言基础

 

本章学习目标：

• 理解c#语言的基本字符集和词汇集
• 理解c#的数据类型和常量,变量的定义方法,掌握简单数据类型转换的方法
• 熟练掌握c#的运算符,掌握利用变量,常量和运算符构成表达式的方法

 

2.1c#的基本字符集和词汇

字符是构成程序设计语言的最小语法单位。不同的程序设计语言的基本字符集是大同小异的，它们都以ASCII字符集为基础。

c#的基本字符集包括

数字：0 1 2 3 4 5 6 7 8 9

英文字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

                  a b c d e f g h i j k l m n o p q r s t u v w x y z

 特殊字符：( ) { } @ & 等

 

程序设计最常用到的ASCII字符，只需7位二进制数即可表示，因此基本ASCII字符集共包含128个字符，其中有95个可打印字符(代码为32-126)，其余33个为不可打印字符(代码为0-31,127)用作控制字符。

 

c#中所有字符都是使用Unicode编码表示的。

 

按照Unicode的编码规定，每个字符都由两个字节(16位二进制数)来表示，编码范围为0-65535,所以Unicode字符集最多可以表示65536个字符，事实上已经包含了世界上大多数语言的字符集，基本ASCII字符集成为Unicode字符集的一个子集，编码范围为0000H-007FH。

 

2.1.2词汇集

c#的词汇集主要包括关键字,标识符和文字常量等。

 

1.关键字

关键字又称保留字，是对编程语言编译器具有特殊意义的预定义保留标识符，编译器在扫描程序时，遇到关键字将做出专门的解释

关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。 

在 C# 中，有些关键字在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。

下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：

 

abstract	as	base	bool	break	byte	case
catch	char	checked	class	const	continue	decimal
default	delegate	do	double	else	enum	event
explicit	extern	false	finally	fixed	float	for
foreach	goto	if	implicit	in	in (generic modifier)	int
interface	internal	is	lock	long	namespace	new
null	object	operator	out	out (generic modifier)	override	params
private	protected	public	readonly	ref	return	sbyte
sealed	short	sizeof	stackalloc	static	string	struct
switch	this	throw	true	try	typeof	uint
ulong	unchecked	unsafe	ushort	using	virtual	void
volatile	while
上下文关键字
add	alias	ascending	descending	dynamic	from	get
global	group	into	join	let	orderby	partial (type)
partial (method)	remove	select	set

 

2.标识符

标识符在程序设计中的作用就是为程序中涉及的数据对象命名，这些数据对象包括：变量，类，对象，方法(函数)以及文件等。

在c#程序中，标识符的命名必须遵循如下规则：

• 标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
• 标识符中的第一个字符不能是数字。
• 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ' / \。
• 标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
• 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
• 不能与C#的类库名称相同。
• 长度不能超过255个字符

 

2.2c#的数据类型

为了便于表示不同类型的信息，又尽可能避免存储空间的浪费，提高程序的运行效率，c#提供了多种数据类型。这些数据类型分成两个大类，即值类型和引用类型。

值类型(value type)包括简单类型(simple types),结构类型(struct types)和枚举类型(enumeration types),引用类型(reference type)主要包括类(class),数组(array),接口(interface),委托(delegate)等。

简单类型包括13种不同的数据类型。它们的存储空间大小，取值范围，表示精度和用途都有所区别，如下表所示：

简单数据类型	表示数据	字节长度	取值范围	默认初值	后缀
bool	布尔型	1	true或false	false
sbyte	字节型	1	-128-127	0
byte	无符号字节型	1	0-255	0
short	短整型	2	-32768- +32767	0
ushort	无符号短整型	2	0 - 65535	0
int	整型	4	-2^31- 2^31-1	0
uint	无符号整型	4	0-2^32-1	0	U
long	长整型	8	-2^63- 2^63-1	0	L
ulong	无符号长整型	8	0 - 2^64-1	0	UL
char	字符型	2	0 - 65535	null
float	单精度浮点数	4	1.40E-45 - 3.40E+38	0.0	F
double	双精度浮点型	8	4.940E-324 - 1.798E+308	0.0	D
decimal	十进制数类型	16	1.0*10^-28 - 7.9*10^28	0.0	M

 

2.2.1布尔型

布尔型(bool)数据在内存中以一个字节存储，只有两个可能的取值：true(逻辑真)或者false(逻辑假)，以此作为影响程序执行流程的依据。

2.2.2整数类型

整数类型指的是那些没有小数部分的数字，按字节长度和表示范围的不同，分为字节型(byte和sbyte),短整数(short和ushort),整数(int和uint),长整型(long和ulong)以及字符型(char)等九种类型，并且都可以表示十进制或十六进制的形式。

 

2.3变量

程序运行过程中，其值可以改变的量称为变量(variable)

2.3.1声明变量

c#是一种强类型语言，程序中用到的所有变量，都必须遵循”先声明，后引用”的原则。

声明变量的基本形式如下：

   数据类型  变量名1[,变量名2,...,变量名n]

2.3.2变量的初始化操作与初值

2.3.3简单类型数据之间的转换

1. 隐式转换

隐式转换的原则，就是允许从占用内存较少的短数据类型转换到占用内存较多的长数据类型，或者说从表示范围较小的数据类型转换到表示范围较大的数据类型，此类转换不会造成有效数值的丢失，也不存在精度的损失

1. 不同数值类型之间的显示转换

在不能完全排除发生错误的危险，但又确实需要进行数据类型转换的情况下，只能采用显式转换。显式转换是一种强制执行的类型转换。

 

2.4常量

2.4.1文字常量

2.4.2符号常量

 

2.5运算符与表达式

2.5.1算术运算符用来对数值型数据进行计算

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

 

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int b = 10;
            int c;

            c = a + b;
            Console.WriteLine("Line 1 - c 的值是 {0}", c);
            c = a - b;
            Console.WriteLine("Line 2 - c 的值是 {0}", c);
            c = a * b;
            Console.WriteLine("Line 3 - c 的值是 {0}", c);
            c = a / b;
            Console.WriteLine("Line 4 - c 的值是 {0}", c);
            c = a % b;
            Console.WriteLine("Line 5 - c 的值是 {0}", c);

            // ++a 先进行自增运算再赋值
            c = ++a;
            Console.WriteLine("Line 6 - c 的值是 {0}", c);

            // 此时 a 的值为 22
            // --a 先进行自减运算再赋值
            c = --a;
            Console.WriteLine("Line 7 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}

输出结果为：

Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21

 

2.5.2关系运算符

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

 

using System;

class Program
{
  static void Main(string[] args)
  {
      int a = 21;
      int b = 10;
      
      if (a == b)
      {
          Console.WriteLine("Line 1 - a 等于 b");
      }
      else
      {
          Console.WriteLine("Line 1 - a 不等于 b");
      }
      if (a < b)
      {
          Console.WriteLine("Line 2 - a 小于 b");
      }
      else
      {
          Console.WriteLine("Line 2 - a 不小于 b");
      }
      if (a > b)
      {
          Console.WriteLine("Line 3 - a 大于 b");
      }
      else
      {
          Console.WriteLine("Line 3 - a 不大于 b");
      }
      /* 改变 a 和 b 的值 */
      a = 5;
      b = 20;
      if (a <= b)
      {
         Console.WriteLine("Line 4 - a 小于或等于 b");
      }
      if (b >= a)
      {
         Console.WriteLine("Line 5 - b 大于或等于 a");
      }
  }
}

输出结果为：

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

 

2.5.3逻辑运算符

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A || B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

 

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
           
            if (a && b)
            {
               Console.WriteLine("Line 1 - 条件为真");
            }
            if (a || b)
            {
                Console.WriteLine("Line 2 - 条件为真");
            }
            /* 改变 a 和 b 的值 */
            a = false;
            b = true;
            if (a && b)
            {
                Console.WriteLine("Line 3 - 条件为真");
            }
            else
            {
                Console.WriteLine("Line 3 - 条件不为真");
            }
            if (!(a && b))
            {
                Console.WriteLine("Line 4 - 条件为真");
            }
            Console.ReadLine();
        }
    }
}

输出结果为：

Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

 

2.5.4位运算符

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

 

 

using System;
namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 60;               /* 60 = 0011 1100 */  
            int b = 13;               /* 13 = 0000 1101 */
            int c = 0;           

             c = a & b;           /* 12 = 0000 1100 */ 
             Console.WriteLine("Line 1 - c 的值是 {0}", c );

             c = a | b;           /* 61 = 0011 1101 */
             Console.WriteLine("Line 2 - c 的值是 {0}", c);

             c = a ^ b;           /* 49 = 0011 0001 */
             Console.WriteLine("Line 3 - c 的值是 {0}", c);

             c = ~a;               /*-61 = 1100 0011 */
             Console.WriteLine("Line 4 - c 的值是 {0}", c);

             c = a << 2;     /* 240 = 1111 0000 */
             Console.WriteLine("Line 5 - c 的值是 {0}", c);

             c = a >> 2;     /* 15 = 0000 1111 */
             Console.WriteLine("Line 6 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}

输出结果为：

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

 

2.6枚举与结构

2.6.1枚举

枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。

C# 枚举是值数据类型。换句话说，枚举包含自己的值，且不能继承或传递继承。

声明枚举的一般语法：

enum 枚举名 [:基本数据类型]
{
     枚举常量列表
}

下面的实例演示了枚举变量的用法：

using System;
namespace EnumApplication
{
   class EnumProgram
   {
      enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

      static void Main(string[] args)
      {
         int WeekdayStart = (int)Days.Mon;
         int WeekdayEnd = (int)Days.Fri;
         Console.WriteLine("Monday: {0}", WeekdayStart);
         Console.WriteLine("Friday: {0}", WeekdayEnd);
         Console.ReadKey();
      }
   }
}

输出结果为：

Monday: 1
Friday: 5

 

2.6.2结构

在 C# 中，结构体是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。struct 关键字用于创建结构体。

 声明结果类型的一般形式如下：

struct 结构名
{
   结构成员声明语句1
   结构成员声明语句2
   结构成员声明语句3
   ......
   结构成员声明语句n
}

例如下面的语句声明了一个Student结构

struct Student
{
   public string name;
   public string sex;
   public uint age;
   public string phone;
}

 

本章小结：

c#语言的基本字符集仍然是ASCII字符集，c#规定了77个关键字。

c#是一种强类型语言，程序中的所有变量都必须先声明，然后才能引用。

转载于:https://www.cnblogs.com/LQ6H/p/csharp-2.html