Java/J2ME（13）
javaweb（5）
String s=&中国&;
byte[] buf=new byte[s.length()+1];//buf长度为3
s.getBytes(0,s.length(),buf,0);//buf[0]=45,buf[1]=-3,buf[2]=0
String sByte=&&;
&&for(int i=0;i&buf.i++){
&&&sByte=sByte+String.format(&%02X&,buf[i])+& &;&
//sByte=&2D FD 00&
char[] cbuf=s.toCharArray();//cbuf[0]=中,cbuf[1]=国
&&for(int i=0;i&cbuf.i++){
&&&ascBuf[i]=(int)cbuf[i];//ascBuf[0]=20013,ascBuf[1]=22269
&&for(int i=0;i&ascBuf.i++){
&&&sByte=sByte+String.format(&%02X&,ascBuf[i])+& &;&
//sByte=&4E2D 56FD&
最终解决方法:
&&&byte[] buf2=s.getBytes(&GBK&);
&&&sByte=&&;
&&&for(int i=0;i&buf2.i++){
&&&&sByte=sByte+String.format(&%02X&,buf2[i])+& &;&
&&&System.out.println(&sByte:&+sByte);
//sByte=&D6 D0 B9 FA&
&&} catch (UnsupportedEncodingException e) {
&&&e.printStackTrace();
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：248183次
积分：4036
积分：4036
排名：第6709名
原创：162篇
评论：25条
(1)(2)(1)(4)(2)(1)(1)(2)(5)(2)(2)(1)(1)(1)(1)(1)(1)(1)(1)(2)(5)(3)(1)(5)(2)(2)(5)(3)(2)(1)(1)(2)(4)(2)(3)(1)(2)(3)(1)(2)(3)(2)(1)(5)(5)(1)(5)(2)(5)(7)(3)(8)(10)(10)(1)(3)(2)(2)(4)(1)Pages: 15/20
主题 : 变量的赋值方式(重要）
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
enum为系统关键字，枚举标识符遵循变量的命名规则。 &枚举可以自动排序&&例如： 赋初值，20.第二格变量就是21. &基础类型必须能够表示该枚举中定义的所有枚举数值。枚举声明可以显式地声明 byte、sbyte、short、ushort、int、uint、long 或 ulong 类型作为对应的基础类型。没有显式地声明基础类型的枚举声明意味着所对应的基础类型是 int。 &　枚举成员是该枚举类型的命名常数。任意两个枚举成员不能具有相同的名称。每个枚举成员均具有相关联的常数值。此值的类型就是枚举的基础类型。每个枚举成员的常数值必须在该枚举的基础类型的范围之内。 &新手入门：C/C++中枚举类型(enum)&&如果一个变量你需要几种可能存在的值，那么就可以被定义成为枚举类型。之所以叫枚举就是说将变量或者叫对象可能存在的情况也可以说是可能的值一一例举出来。 &&　　举个例子来说明一吧，为了让大家更明白一点，比如一个铅笔盒中有一支笔，但在没有打开之前你并不知道它是什么笔，可能是铅笔也可能是钢笔，这里有两种可能，那么你就可以定义一个枚举类型来表示它！&enum&box{pencil,pen};//这里你就定义了一个枚举类型的变量叫box，这个枚举变量内含有两个元素也称枚举元素在这里是pencil和pen，分别表示铅笔和钢笔。&　这里要说一下，如果你想定义两个具有同样特性枚举类型的变量那么你可以用如下的两种方式进行定义！ &enum&box{pencil,pen};& && &enum&box&box2;//或者简写成box&box2;&　　再有一种就是在声明的时候同时定义。&enum&{pencil,pen}box,box2;&//在声明的同时进行定义！&　　枚举变量中的枚举元素系统是按照常量来处理的，故叫枚举常量，他们是不能进行普通的算术赋值的，(pencil=1;)这样的写发是错误的，但是你可以在声明的时候进行赋值操作！ &enum&box{pencil=1,pen=2};&但是这里要特别注意的一点是，如果你不进行元素赋值操作那么元素将会被系统自动从0开始自动递增的进行赋值操作，说到自动赋值，如果你只定义了第一个那么系统将对下一个元素进行前一个元素的值加1操作，例如&enum&box{pencil=3,pen};//这里pen就是4系统将自动进行pen=4的定义赋值操作！&&前面说了那么多，下面给出一个完整的例子大家可以通过以下的代码的学习进行更完整的学习！&#include&&iostream&& &using&namespace&& && &void&main(void)& &{& &&&&&enum&egg&{a,b,c};& &&&&&enum&egg&&//在这里你可以简写成egg&& && &&&&&test&=&c;&//对枚举变量test进行赋予元素操作，这里之所以叫赋元素操作不叫赋值操作就是为了让大家明白枚举变量是不能直接赋予算数值的，例如(test=1;)这样的操作都是不被编译器所接受的，正确的方式是先进行强制类型转换例如(test&=&(enum&egg)&0;)！& && &&&&&if&(test==c)& &&&&&{& &&&&&&&&&cout&&&&枚举变量判断:test枚举对应的枚举元素是c&&&&&& &&&&&}& && &&&&&if&(test==2)& &&&&&{& &&&&&&&&&cout&&&&枚举变量判断:test枚举元素的值是2&&&&&& &&&&&}& && &&&&&cout&&&&a&&&&&|&&&&&b&&&&&|&&&&&test&&&& && &&&&&test&=&(enum&egg)&0;&//强制类型转换& &&&&&cout&&&&&枚举变量test值改变为:&&&&&test&&&& &&&&&cin.get();& &} &　　看到这里要最后说一个问题，就是枚举变量中的枚举元素(或者叫枚举常量)在特殊情况下是会被自动提升为算术类型的！&#include&&iostream&& &using&namespace&& && &void&main(void)& &{& &&&&&enum&test&{a,b};& &&&&&int&c=1+b;&//自动提升为算术类型& &&&&&cout&&&&c&&&& &&&&&cin.get();& &} &[ 此帖被haoxue在 10:06重新编辑 ]
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
注：以下全部代码的执行环境为VC++ 6.0&宏和枚举的区别&宏和枚举之间的差别主要在作用的时期和存储的形式不同，宏是在预处理的阶段进行替换工作的，它替换代码段的文本，程序运行的过程中宏已不存在了。而枚举是在程序运行之后才起作用的，枚举常量存储在数据段的静态存储区里。宏占用代码段的空间，而枚举除了占用空间，还消耗CPU资源。&但也不能就此说宏比枚举好，如果需要定义非常多的常量，用一条enum {.....}明显比一大堆define更清晰，枚举也可以用来定义一些特殊类型，比如Bool，&如： type enum {FALSE,TRUE} B&&&在程序中，可能需要为某些整数定义一个别名，我们可以利用预处理指令#define来完成这项工作，您的代码可能是：&#define MON& 1&#define TUE&& 2&#define WED& 3&#define THU&& 4&#define FRI&&& 5&#define SAT&& 6&#define SUN&& 7&在此，我们定义一种新的数据类型，希望它能完成同样的工作。这种新的数据类型叫枚举型。&1. 定义一种新的数据类型 - 枚举型&&以下代码定义了这种新的数据类型 - 枚举型&enum DAY&{&&&&&& MON=1, TUE, WED, THU, FRI, SAT, SUN&};&(1) 枚举型是一个集合，集合中的元素(枚举成员)是一些命名的整型常量，元素之间用逗号,隔开。&(2) DAY是一个标识符，可以看成这个集合的名字，是一个可选项，即是可有可无的项。&(3) 第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1。&(4) 可以人为设定枚举成员的值，从而自定义某个范围内的整数。&(5) 枚举型是预处理指令#define的替代。&(6) 类型定义以分号;结束。&2. 使用枚举类型对变量进行声明&新的数据类型定义完成后，它就可以使用了。我们已经见过最基本的数据类型，如：整型int, 单精度浮点型float, 双精度浮点型double, 字符型char, 短整型short等等。用这些基本数据类型声明变量通常是这样：&char&&&& //变量a的类型均为字符型char&char&&&&&int&&&&&&& x,&&&&&&&&&&& y,&&&&&&&&&&& //变量x,y和z的类型均为整型int&int&&&&&&&double& m,&double& //变量result的类型为双精度浮点型double&既然枚举也是一种数据类型，那么它和基本数据类型一样也可以对变量进行声明。&方法一：枚举类型的定义和变量的声明分开&enum DAY&{&&&&&& MON=1, TUE, WED, THU, FRI, SAT, SUN&};&enum DAY&enum DAY&enum DAY //变量tomorrow的类型为枚举型enum DAY&enum DAY good_day, bad_ //变量good_day和bad_day的类型均为枚举型enum DAY&方法二：类型定义与变量声明同时进行：&enum //跟第一个定义不同的是，此处的标号DAY省略，这是允许的。&{&&&& saturday,&&&& sunday = 0,&&&& monday,&&&& tuesday,&&&& wednesday,&&&& thursday,&&&& friday&} //变量workday的类型为枚举型enum DAY&enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} //变量days的类型为枚举型enum week&enum BOOLEAN { false, true } end_flag, match_ //定义枚举类型并声明了两个枚举型变量&方法三：用typedef关键字将枚举类型定义成别名，并利用该别名进行变量声明：&typedef enum workday&{&&&& saturday,&&&& sunday = 0,&&&& monday,&&&& tuesday,&&&& wednesday,&&&& thursday,&&&& friday&} //此处的workday为枚举型enum workday的别名&workday today, //变量today和tomorrow的类型为枚举型workday，也即enum workday&enum workday中的workday可以省略：&typedef enum&{&&&& saturday,&&&& sunday = 0,&&&& monday,&&&& tuesday,&&&& wednesday,&&&& thursday,&&&& friday&} //此处的workday为枚举型enum workday的别名&workday today, //变量today和tomorrow的类型为枚举型workday，也即enum workday&也可以用这种方式：&typedef enum workday&{&&&& saturday,&&&& sunday = 0,&&&& monday,&&&& tuesday,&&&& wednesday,&&&& thursday,&&&& friday&};&workday today, //变量today和tomorrow的类型为枚举型workday，也即enum workday&注意：同一个程序中不能定义同名的枚举类型，不同的枚举类型中也不能存在同名的命名常量。错误示例如下所示：&错误声明一：存在同名的枚举类型&typedef enum&{&&&& wednesday,&&&& thursday,&&&& friday&}&typedef enum WEEK&{&&&& saturday,&&&& sunday = 0,&&&& monday,&}&&&错误声明二：存在同名的枚举成员&typedef enum&{&&&& wednesday,&&&& thursday,&&&& friday&} workday_1;&typedef enum WEEK&{&&&& wednesday,&&&& sunday = 0,&&&& monday,&} workday_2;&3. 使用枚举类型的?&fc1&淞?&3.1 对枚举型的变量赋值。&实例将枚举类型的赋值与基本数据类型的赋值进行了对比：&方法一：先声明变量，再对变量赋值&#include&stdio.h&&&enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };&void main()&{&&&& &&&& int x, y,&&&& &&&& x = 10;&&&& y = 20;&&&& z = 30;&&&& &&&& &&&& enum DAY yesterday, today,&&&& &&&& yesterday = MON;&&&& today&&&& = TUE;&&&& tomorrow& = WED;&&&& printf(&%d %d %d \n&, yesterday, today, tomorrow);&}&方法二：声明变量的同时赋初值&#include &stdio.h&&&enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };&void main()&{&&&& &&&& int x=10, y=20, z=30;&&&& &&&& enum DAY yesterday = MON, &&&&&&&&&&&&&&&&&&&&&&&& today = TUE,&&&&&&&&&&&&&&&&&&& tomorrow = WED;&&&& printf(&%d %d %d \n&, yesterday, today, tomorrow);&}&方法三：定义类型的同时声明变量，然后对变量赋值。&#include &stdio.h&&&enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN } yesterday, today,&&int x, y,&void main()&{&&&& &&&& x = 10;& y = 20;& z = 30;&&&& &&&& &&&& yesterday = MON;&&&& today&&&& = TUE;&&&& tomorrow& = WED;&&&& printf(&%d %d %d \n&, x, y, z); //输出：10 20 30&&&& printf(&%d %d %d \n&, yesterday, today, tomorrow); //输出：1 2 3&}&方法四：类型定义，变量声明，赋初值同时进行。&#include &stdio.h&&&enum DAY&{&&&& MON=1, &&&& TUE,&&&& WED,&&&& THU,&&&& FRI,&&&& SAT,&&&& SUN &}&yesterday = MON, today = TUE, tomorrow = WED;&&int x = 10, y = 20, z = 30;&void main()&{&&&& printf(&%d %d %d \n&, x, y, z); //输出：10 20 30&&&& printf(&%d %d %d \n&, yesterday, today, tomorrow); //输出：1 2 3&}&3.2 对枚举型的变量赋整数值时，需要进行类型转换。&#include &stdio.h&&enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN };&void main()&{&&&& enum DAY yesterday, today,&&&& yesterday = TUE;&&&& today = (enum DAY) (yesterday + 1); //类型转换&&&& tomorrow = (enum DAY) 30; //类型转换&&&& //tomorrow = 3; //错误&&&& printf(&%d %d %d \n&, yesterday, today, tomorrow); //输出：2 3 30&}&3.3 使用枚举型变量&#include&stdio.h&&enum&{ &&&& BELL&&&&&&&&& = '\a',&&&& BACKSPACE = '\b',&&&& HTAB&&&&&&&& = '\t',&&&& RETURN&&&&& = '\r',&&&& NEWLINE&&& = '\n', &&&& VTAB&&&&&&&& = '\v',&&&& SPACE&&&&&& = ' '&};&enum BOOLEAN { FALSE = 0, TRUE } match_&void main()&{&&&& int index = 0;&&&& int count_of_letter = 0;&&&& int count_of_space = 0;&char str[] = &I'm Ely efod&;&match_flag = FALSE;&&&& for(; str[index] != '\0'; index++)&&&&&&&& if( SPACE != str[index] )&&&&&&&&&&&& count_of_letter++;&&&&&&&& else&&&&&&&& {&&&&&&&&&&&& match_flag = (enum BOOLEAN) 1;&&&&&&&&&&&& count_of_space++;&&&&&&&& }&&&& &&&& printf(&%s %d times %c&, match_flag ? &match& : &not match&, count_of_space, NEWLINE);&&&& printf(&count of letters: %d %c%c&, count_of_letter, NEWLINE, RETURN);&}&输出：&match 2 times&count of letters: 10&Press any key to continue&4. 枚举类型与sizeof运算符&#include &stdio.h&&enum escapes&{ &&&& BELL&&&&& = '\a',&&&& BACKSPACE = '\b',&&&& HTAB&&&&& = '\t',&&&& RETURN&&& = '\r',&&&& NEWLINE&& = '\n', &&&& VTAB&&&&& = '\v',&&&& SPACE&&&& = ' '&};&enum BOOLEAN { FALSE = 0, TRUE } match_&void main()&{&&&& printf(&%d bytes \n&, sizeof(enum escapes)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(escapes)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(enum BOOLEAN)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(BOOLEAN)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(match_flag)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(SPACE)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(NEWLINE)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(FALSE)); //4 bytes&&&& printf(&%d bytes \n&, sizeof(0)); //4 bytes&｝&&&typedef&& struct&& weekday_st &{ &&&&&&&& enum&& week& {sun=,mon,tue,wed,thu,fri,sat }; &&&&&&&& enum&& day&& {monring,&& moon,&& aftermoon} ; &}weekday_ &int&& main(int&& argc,&& char&& *argv[]) &{ &&&&&&&& printf( &sizeof(weekday_st)=%d\n &,&& size&42b&of(weekday_st)); &&&&&&&& printf( &sizeof(weekday)=%d\n &,&& sizeof(weekday_st::week)); &&&&&&&& printf( &sizeof(day)=%d\n &,&& sizeof(weekday_st::day)); &&&&&&&& return&& 0; &} &sizeof(weekday_st)=1 &sizeof(weekday)=4 &sizeof(day)=4 &printf( &sizeof(weekday_st)=%d\n &,&& sizeof(weekday_st)); &这里因为结构体里面并没有定义任何的变量 &所以这个结构是空的，但是用sizeof进行运算的话也不能返回0 &因为毕竟存在着这么一个东西 &所以这时sizeof返回一个在机器里面所能表达的最小的存储单位的值 &一般的PC里面最小的存储单位的值是char &所以sizeof返回1 &printf( &sizeof(weekday)=%d\n &,&& sizeof(weekday_st::week)); &printf( &sizeof(day)=%d\n &,&& sizeof(weekday_st::day)); &因为枚举量是当作整型常量来处理的 &所以上面这两个sizeof都是返回4&&&这里的enum&& week和enum&& day只是内嵌“类型”，而不是成员变量，如果改成： &typedef&& struct&& weekday_st &{&&&&&& &enum&& week& {sun=,mon,tue,wed,thu,fri,sat }&& &&&&& enum&&& day&& {monring,&& moon,&& aftermoon}&& &}weekday_ &sizeof(weekday_st)=8 &sizeof(weekday)=4 &sizeof(day)=4&0&&
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
线程同步和线程异步有什么区别？（重要基础知识）&打个比方，如果你在等一个人，&同步的时候，你会一直等到她来了之后才做其他事情，这个过程除了等待你啥都不会做，&异步的时候，你一边在等，可能一边玩游戏或者是看报纸什么的，一直到她到来，你的等待状态才会结束&在实现上，同步的过程会阻塞进程的所有其他操作，将同步转换为异步的最常见方法则是&将会阻塞进程的等待操作放入到一个新的进程中，同时为该等待操作添加一个监视器，在检测到等待操作完成的时候结束等待的进程。&&&
级别: 侠客
可可豆: 1227 CB
威望: 1227 点
在线时间: 195(时)
发自: Web Page
&&牛b人 楼主 mark 学习&&
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
XML Parser 概述&XML Parser 是做网络应用开发常用到的，iPhone SDK 自带了两个 libraries，除此之外还有很多第三方的 XML Parser libraries，包括 TBXML, TouchXML, KissXML, TinyXML, and GDataXML，这里就有一个问题，做开发的时候该选择哪一个适合自己的？下面为大家做了具体介绍：&首先要清楚两个概念：SAX 和 DOM。SAX，Simple API for XML，属于 event driven，即所谓的事件驱动。当满足一定的条件时，相应的事件就会被驱动，常用的事件类似于ErrorOccur，DataRecieved。DOM，Document Object Model，简单来讲，就是要把文档完全下载完以后，然后对其里面的内容、objects等进行操作。弄清两个概念，再来看都有哪些可以用的 Libraries。NSXMLParser，SAX 型，这是 iPhone SDK 自带的，用 Objective C 写的，直接用，但是并不是最简单的。libxml2，开源的，也是 SDK  自带的，用的是 C 语言，同时支持 SAX 和 DOM。它有一个非常好的特性，parse 和 read  同时进行，也就是说你不用等到整个文档下载完以后才读，比如你需要 parse 一个非常大的文件，你不希望用户等你 parse  完才看到内容，你可以这 parse 的同时把内容呈现出来。TBXML，特点是小，DOM 型，可以在低内存损耗的条件下快速提取内容，缺点也是太简单，不支持 xPath，并且只能读，不能写，也就是说，你读完了 xml，想修改里面的内容再发送，对不起，爷没这功能。TouchXML，特点几乎与上面那位一样，简单，只读不写，但是支持 xPath。KissXML，实际上是基于 TouchXML 的，只是增加了写的功能，可以编辑。TinyXML，是一个小的 C 语言 DOM 型，不支持 xPath。GDataXML，Google 开发的，基于 Objective-C 的 parser。哪一个更好呢？&    Apple 有一个叫 XMLPerformance的SampleCode，里面分别用 NSXMLParser 和 libxml2 两种方法 parse 了一个 900KB 大小的 xml 文件，300 首 iTunes 的歌。对于各种 parser 的方式，有个老美用自己的 iPhone 做了测试，结果如下图所示。&&&&&  图中可以看出 SDK 自带的 NSXML 实际上是最慢的。TBXML 是最快的，当然，如前面所说，它简单，功能也少。个人觉得 libxml2 是比较好的方案，不仅同时支持 SAX 和 DOM，而且功能强大，支持 parse 和 read 同时进行，支持 xpath。当然具体问题需要具体分析。总体来讲，DOM 所占用的内存要大于 SAX，除了 TBXML，TB 是非常简单而有效率的。
级别: 风云使者
UID: 78198
发帖: 3543
可可豆: 3376 CB
威望: 13237 点
在线时间: 4900(时)
发自: Web Page
微信whglyy
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
app提交 iTunes 以后，大概要花7-14天来等候审批。
级别: 侠客
UID: 21088
可可豆: 1027 CB
威望: 981 点
在线时间: 275(时)
发自: Web Page
标记下，好东西
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
必须动手练一下，下面网址中的内容，非常重要&&/dotey/archive//2075954.html&&&[ 此帖被haoxue在 18:20重新编辑 ]
级别: 精灵王
UID: 39045
发帖: 1386
可可豆: 12975 CB
威望: 12975 点
在线时间: 840(时)
发自: Web Page
initWithNibName 和 ViewDidLoad两个方法的区别是什么？&一个是创建viewcontroller，一个是创建完成加载的方法。&initWithNibName：用于加载本地的NIB文件&&ViewDidLoad: view加载完成的方法&&&&在用代码初始化一个ViewController时，使用initWithNibName方法时会犯一个习惯性的小错误：& // 下面这行是错误写法!!!& MyViewController *myViewController = [[MyViewController alloc] initWithNibName:@&MyViewController.xib& bundle:nil];& 问题相当简单，就是NibName是指不包含.xib的字符串，把.xib去掉就OK了& MyViewController *myViewController = [[MyViewController alloc] initWithNibName:@&MyViewController& bundle:nil];&&&
Pages: 15/20
关注本帖(如果有新回复会站内信通知您)
个人IDP证书一年费用？ 正确答案:99美金
发帖、回帖都会得到可观的积分奖励。
按"Ctrl+Enter"直接提交
关注CocoaChina
关注微信 每日推荐
扫一扫 浏览移动版C#OOP之二 变量和表达式-爱编程
C#OOP之二 变量和表达式
2.1& C#的基本语法
C#代码的外观和操作方式与C++和Java非常相似。初看起来，其语法比较混乱，
不像书面英语和其他语言。但是，在C#编程中，使用的样式是比较清晰的，不用花太多的力气就可以编写出可读性很强的代码。
与其他语言的编译器不同，无论代码中是否有空格或回车符或tab字符（这些字符统称为空白字符），C#编译器都不考虑这些字符。这样格式化代码时就有很大的自由度，但遵循某些规则将有助于使代码易于阅读。
C#代码由一系列语言组成，每一个语句都用一个分号来结束。因为空格被忽略，所以一行可以有多个语句，但从可读性的角度来看，通常在分号后面加上回车符，这样就不能在一行上放置多个语句了。但一句代码放在多个行上是可以的。
C#是一块结构的语言，所有的语句都是代码块的一部分。这些块用花括号来界定（“{”和“}”），代码块可以包含任意多行语句，或者根本不包含语句。注意花括号字符不需要附带分号。
所以，简单的C#代码如下所示：
&& &code line 1,statement 1&;
& &code line 2,statement 2&
&codeline 3,statement 3&;
其中&code linex,statement y&部分并不是正真的C#代码，而是用这个文本作为C#语句的占位符。注意在这段代码中，第2，3行代码是同一个语句的一部分，因为在第2行的末尾没有分号。
在这个简单的代码中，还使用了缩进格式，使C#代码的可读性更高。这不是某些人的发明，而是一个标准规则，实际上在默认情况下VS会自动缩进代码。一般情况下，每个代码都会有自己的缩进级别，即它向右缩进了多少。代码块可以互相嵌套，而被嵌套的块要缩进得多一些。
&& &code line 1&;
& &&&& &&code line 2&;
&code line 3&;
&codeline 3&;
前面代码的续写通常也要所近得多一些，如上面第一个示例中的第3行代码。
在C#代码中，另一个常见的语句是注释。注释并不是严格意义上的C#代码，但代
码最好有注释。注释就是解释，即给代码添加描述性文本，编译器会忽略这些内容。在开始处理比较长的代码段时，注释可用于给正在进行的工作添加提示，例如“这行代码要求用户输入一个数字”，或“这段代码由Bob编写”。C#添加注释的方式有两种。可以在注释的开头和结尾放置标记，也可以使用一个标记，其含义是“这行代码的其余部分是注释”。在C#编译器忽略回车符的规则中，后者是一个例外，但这是一种特殊情况。
要使用第一种方式标记注释，可以在注释的开头加上“/*”,在末尾加上“*/”。这些注释符号可以在单独一行上，也可以在不同的行上，注释符号之间的所有内容都是注释。注释中唯一不能输入的是“*/”，因为它会被看作注释结束标记。所以下面的语句是正确的。
/* This is a comment */
/* And so…
&&&&&&&&&&&&&&&&&&&&& …is this!*/
但下面的语句会产生错误：
/*Comments often end with “*/”characters*/
注释结束符号后的内容（“*/”后面的字符）会被当作C#代码，因此产生错误。
另一个添加注释的方法是用“//”开始一个注释，其后可以编写任何内容，只要这些内容在一行上可即可。下面的语句是正确的：
//& 双行注释
但下面的语句会失败，因为第二行代码会解释为C#代码：
//So is this,
But this bit isn’t.
这类注释可用于语句的说明，因为他们都放在一行上：
&A statement&;& //Explanation of statement
前面说过有两种方法给C#代码添加注释。但在C#中，还有第三类注释，严格地说，这是//语法的扩展。他们都是单行注释，用三个“/”符号来开头，而不是两个。
/// 特殊的注释
在正常情况下，编译器会忽略他们，就像其他注释一样，但可以配置VS，在编译项目时，提取这些注释后面的文本，创建一个特殊格式的文本文件，该文件可用于创建文档说明书。
特别要注意的一点是，C#代码是区分大小写的。与其他语言不同，必须使用正确的大小写形式输入代码，因为简单地用大小写字母代替小写字母会中断项目的编译。
2.2&&&& 变量
首先我们应该说明一下为什么计算机语言会需要变量，我们来看一个例子。假如你
现在要去买一台电脑，假设我们知道这台电脑的标价是5000元，而现在恰逢国庆节打折，折扣率是10%，我们现在来计算这台电脑的价格。一般情况下我们会这样计算：首先我们要求出折扣了多少钱0元，然后我们只需要用就可以求出真实价&#元。很显然在这里又一个问题：我们开始算出来的500这个折扣额需要在后面使用，在日常生活中，我们可以把这个数写在纸上或记住，然后再做后面的运算。那么对于计算机来说需要怎么做才能完成任务呢，事实上，计算机会把这个值记在内存里，以便进行下面的运算，这就用到了变量。什么是变量？变量就是程序语言中存储数据的基本单元。
&&&&&&计算机操作如下：
1.&&&&&& 首先定义变量存储电脑价&#。
2.&&&&&& 执行价格*10%求出折扣额。
3.&&&&&& 将折扣额这个中间结果存入变量。
4.&&&&&& 将价格与折扣额相减。
5.&&&&&& 将真是的价格存入结果变量。
显而易见，变量对应一块能存东西的内存单元。程序语言通常使用变量来存储数据，使用变量可以引用存储在内存中的数据，并随时根据需要显示数据或修改数据。另外如前所述，变量是有类型的，不同类型的变量可以存储不同数据类型的数据。数据类型的概念我们稍后再说，下面来看一下C#中变量定义的语法：
数据类型 名&& 变量名
数据类型名& 变量名=初始值
比如我们可以定义整型的年龄变量：
int&age=20;
上面我们定义了一个整型的变量age，并且让这个变量的初始值为20。当你定义一个变量后，系统会根据此变量的数据类型为这个变量分配一块存储数据的内存，此后可以通过变量名来引用这个变量（就好比人名可以引用某个人一样）。
2.2.1&& 简单类型
变量中，简单类型实际上就是值类型，值类型的数据类型基本上可以归纳为三类：
第一类是整数型，包括int，long等，他们都可以定义整数变量。第二类是浮点型，它们包括float，double等，他们可以定义小数类型的变量。第三类是字符型和布尔型，包括char，bool等类型，他们可以定义字符串或者逻辑类型的变量。
&&&&&&&整数类型的常用类型有（如下表）：
名&&&&& 称
大小（字节）
范&&&&& 围
无符号字节类型
无符号整型
无符号短整型
无符号长整型
&&&&& 整数型也叫整形，是最常用的数据类型。使用整数定义的变量只能存储整型的数字，各种整型变量对应的内存参照表中的“大小”一栏，变量能保存的数值范围参照表中“范围”一栏。我们可以用整型定义人的年龄，国家的人口，日期的天数以及商品的数量等。
&&&&& 你可能会用疑问，不就是一个整数么，为什么整数需要这么多数据类型，而且你会发现每一种数据类型都有无符号和有符号两种。实际上，不管是int还是byte，不管是有符号还是无符号，都是为了更精确的说明和体现变量的真正含义，比如你定义天数最好使用ushort，因为天数没有负数并且天数的范围刚好适合ushort，一旦你这样定义了，那么如果给天数一个负数或者给天数一个特大的数，编译器将提示你这个数字不合法。这就可以初步保证正确的使用该变量。
&&&&&&整数型就先介绍到这里，下面我们来看常用的浮点型（如下表）：
名&&&&& 称
大小（字节）
范&&&&& 围
双精度浮点型
高精度浮点型
&&&&&&& 浮点型可以表示小数或整数值，也因此浮点型的变量可以保存整数和小数两种数字。虽然说浮点型也可以保存整数数字，但浮点型真正的用途是来表示有精度要求的小数。比如正弦值等。
&&&&&&& 各类浮点型变量的内存大小参照上表中“大小”一栏，通常越大的浮点型能保存的数值精度越高。
&&&&&&& 对于浮点型的数字通常要使用后缀来指明其数据类型。对于decimal类型的数字要使用后缀m或M；对于float类型的数字要使用后缀f或F；对于double类型的数字要使用后缀df或D，如20.4d等。这里要注意：如果一个小数没有使用后缀，那么此小数数值默认情况下是double类型。如果你将一个double类型的数值给一个float变量就会发生类型不匹配的错误，如：
float& m=2.2；
“2.2”默认为double型，要给浮点型变量赋值应该为：
float& m=2.2f；
上面介绍了整数型和浮点型，最好我们来看字符型和布尔型（如下表）：
名&&&&& 称
大小（字节）
范&&&&& 围
16位 Unicode 字符
true 和false
字符型变量用于保存和表示世界上已知书面语言中的一个字符。对于C#中的字符
型，熟悉C/C++语言的朋友要特别注意，在C/C++语言中char型大小为一个字节，只能表示一个英文字符，而C#中字符型有两个字节，可以表示世界上任何语言的字符。在C#中表示一个字符时应该带有单引号，字符类型变量的定义和使用方法如下：
&&&&&&&& char enchar=’M’;
&&&&&&& char cnchar=’ 国’;
&&&&&&& 对于布尔型，它可以用来表示逻辑判断的“真”和“假”。翻开逻辑学相关的书籍你会找到“真”和“假”的含义，我们说，给一个命题比如“所有人是动物“，如果这个命题成立，我们就认为此命题返回的结果为“真”，反之返回的结果为“假”。逻辑学中使用真和假来表示逻辑判断的结果，C#语言使用ture和false两个值来表示逻辑判断的真和假，这是C#语法。布尔型变量定义和使用方法如下：
&&&&&&&&& bool&& trbool=
&&&&&&&&& bool&& fsbool=
&&&&&&&&& bool&&& mybool=x&y;
&&&&&& 到现在为止，我们介绍完了C#中所有值类型的数据类型。最后我们来看一下值类型的一个综合示例：
static void Main(string[] args)
cx=10,cy=12,cr=0;
Console.WriteLine(“长方形的长是：{0}，宽是：{1}”,cx,cy);
Console.WriteLine(“长方形的面积是：{0}”,cr);
sx=12,sy=10.5;
Console.WriteLine(“三角形的底是：{0}，高是：{1}”,sx,sy);
Console.WriteLine(“三角形的面积是：{0}”,sx*sy/2);
sx=’C’,sy=’N’;
Console.WriteLine(“{0}{1}表示中国”，sx,sy);
Console.WriteLine(“{0}&{1}是{2}的”,cx,cy,bh);
&运行结果：
长方形的长是：10，宽是：12
长方形的面积是：120
三角形的底是：12，高是：10.5
三角形的面积是：63
CN表示中国
10&12是False的
上面的程序我们使用了刚才介绍的大部分数据类型。
2.2.2 变量的命名
变量在定义时涉及到数据类型和变量名两个元素，数据类型是系统定义好的关键
字，而变量名是可以自己定义的。这里着重说一下变量名的命名规则，变量名的命名主要有三条规则，变量名的构成规则必须满足下面条件：
l&&&&&&&&变量名可以由字母 数字 _（下划线）组合而成。
l&&&&&&&&变量名必须以字母或_(下划线)开头。
l&&&&&&&&C#语言中某些词（如 int或 float等）称为保留字，具有特殊意义，不能用作变量名。
要注意的是，C#语言中变量名区分大小写，因此变量age和Age是两个不同的变
量。实际上，C#程序中有许多需要命名的对象，例如变量名,方法名，类名等，为这些对象起一个名字来标识这些对象，这些名字都称作标识符，变量名就是变量标识符。C#语言规定同一种标识符不能重名，在这里也就说变量名不能重名，这是变量定义时要注意的问题。至此，我们可以来演练一下变量的定义了：
string& welcom=”欢迎进入C#世界”;
int age=20；
double money=30000；
char c=’A’;
从上面的例子我们也可以看出，变量和数据类型有着密切的关系，我们说不同的变
量代表着不同的内存存储空间，并且这块存储空间是固定大小的，这样就决定了变量有一定的存储范围，如果变量的值超出这个范围就会发生错误。而数据类型就决定了变量占用内存的大小，因此数据类型对于变量来说非常重要。
& 2.2.3 变量的声明和赋值
&&&&&&&&& 学完变量的命名规则后，变量的声明和赋值是非常简单的。变量在声明的时候首先要知道所定义的变量是什么类型的，在去声明你所定义的变量；变量的赋值——变量可以在声明的时候赋值，也可以声明后在下面用到该变量时对其进行赋值。下面我们来看下变量的声明和赋值的示例：
&&&&&&&& int&&&& age=20；//在声明变量时直接给变量赋值
&&&&&&&& 或
&&&&&&&& int&&& age；
&&&&&&&& age =20；//先声明变量，在对变量进行赋值
&&&&&&& 总的来讲，变量的声明和赋值的语法是：
&&&&&&& 数据类型&&&&& 变量名；
&&&&& &&&变量名=初始值；
&&&&&&&& 或
&&&&&&&& 数据类型&&&& 变量名=初始值；
2.3运算符和表达式
上一节我们学习了变量，那么变量和变量之间怎么联系起来呢?今天我们来学习运算符和表达式。
在程序语言中，变量是字词，通过运算符将变量连接成表达式，表达式相当于语言中的短句。运算符最常见的就是加、减、乘、除，这些运算符每一个小型的计算器都有。当然程序语言支持的运算符不止这些，每个程序语言提供的运算符号稍有些不同，但大体上都一样，在C#语言中主要有以下几种运算符：
★&&&&算术运算符
★&&&&关系运算符
★&&&&逻辑运算符
★&&&&赋值运算符
运算符操作数的个数，又可分为一元运算符和二元运算符，一元运算符连接一个操作数，二元运算符连接两个操作数，我们常见的加、减、乘、除都是二元运算符，他们需要连接两个操作数。
运算符连接操作数构成表达式，操作数可以是变量和常数（单独的一个数字或字符串等我们都可以称作常数）。许多小的表达式可以构成大的表达式。如“（x+y）+（x-y）”中间的加号连接两个小的表达式构成一个复杂的表达式，此时这些小表达式我们也可以认为是操作数，也就是说操作数也可以是表达式。事实上C#中的表达式和小学数学中的算式有些相似。
★&& 2.3.1算术运算符
下面我们首先来介绍算术运算符，算术运算符是我们最常见的运算符，如下图所示：
算术运算符
&&&& 示&& 例
&&&&&& +
&&& 加法操作
&&& 1+2，x+y
&&& 减法操作
&&& 2-1，x-y
&&& 乘法操作
&&& 2*3，x*y
&&& 除法操作
&&& 4、2，x/y
&&& 取余数操作
7%2=1，23%10=3
&&&&& ++
&&& 自增操作
& x++，++x
&&& 自减操作
& x--，--x
算术运算符用来连接操作数执行算术运算。其中前四种都很熟悉了。取余运算又叫取模运算，是用来取得余数，比如我们要取得12除以5的余数可以使用“12%5”，结果是2.关于自增“++”和自减“--”运算符的用法需要注意，我们可以用一种替代算法来解释他们。如果“x++”或者“++x”单独出现在一个语句中那么都相当于“x=x+1”（注意：“x++”和“++x”在一定范围下是有区别的），相对应的自减也类似。
关于算术操作符就介绍到这里，下面我们来看一个示例：
usingSystem.T
namespaceText
class program
static void Main(string[] args)
doubleb=a+2*5/2.5;
Console.WriteLine(“a={0},b={1}”,a,b);
Console.WriteLine(“x={0},y={1},z={2}”,x,y,z);
运行结果：
x=7，y=6,z=6
&& 按F5键运行后，运行结果如上，这里重点要注意z和y的值。运行结果中z和y都为6，你可以把上面的“++”符号换成“--”符号运行，结果z和y都为4.有时我们也形象的称自增或自减变量“参与表达式运算”为“使用”，如果递增运算符在变量的前面，那么变量先自我递增然后在“使用”，在这里的“使用”是指“x赋值给y”。如果自增运算符在变量后面，那么变量先“使用”再自我递增。即“++x”是“先运算后赋值“，“x++”是“先赋值后运算”。
2.3.2关系运算符
事实上，关系运算符就是我们在小学三年级学过的的那些大于 小于 等于等。C#中关系运算符用于测试两个数或者两个表达式之间的关系。关系运算符连接操作数构成关系表达式，关系表达式的计算结果为逻辑值true和false,如果此关系式表达成立则返回true，否则返回false。C#中的关系表达式大都是我们所熟悉的，如下表所示：
关系运算符
关系表达式得到的结果是逻辑值“真”和“假”。我们在前面提到过，在C#中“真”和“假”使用布尔类型来表示，“真”用小写true来表示，“假”用小写false来表示，它们描述了表达式所表达的关系是否成立，如下所示：
boolr=3&4;&& //关系不成立则r为false
boolr=3&2;&& // 关系成立则r为true
关系表达式也有一些很复杂的，比如“(a+b)&(a-b)”等复合表达式，关系表达式主要用在条件判断语句中（如if语句等，我们后面将会介绍），表示如果某个条件成立就去执行一个操作，如：
using System.T
namespace Text
class Program
static void Main(string[] args)
int a=1,b=2;
Console.WriteLine(“a小于b”);
运行结果：
2.3.3逻辑运算符
逻辑运算符通常连接关系表达式从而表示更复杂的关系。一般来说，逻辑运算符通常使用在if语句中连接一个或多个条件构成符合条件。要注意的是，逻辑运算符连接成的表达式还是关系表达式，返回值的类型也是布尔型，下表是C#中用到的逻辑运算符。
逻辑运算符
逻辑“与”操作
“并且”的意思
逻辑“或”操作
“或者”的意思
逻辑“非”操作
“不”或“非”的意思
在日常生活中经常出现复杂的条件选择，不如下面这个例子：
“假如我有钱或者我长得帅，那么我可以找个漂亮的女朋友。”
这里的“我有钱”和“我长得帅”两个条件之间的“或者”就相当于使用了逻辑运算符“||”，我们再举一个C#中的例子：
if（a&b&&&& a!=0）&& r=b/a;
这个式子意思是：假如a大于b并且a不为零，那么求b除以a的结果。
逻辑“非”相当于“不”，会对原来的值取反，比如：
“他不是个好人”就等效于“他！=好人”。
“他不不是个好人”就等效于“他！！好人”。
两个“非”运算符可以省略掉所以任何逻辑表达式不会同时出现两个并列的“非”符号,那是很无聊的写法。你可以简单的将逻辑运算符“&&”理解为“并且”，将 “||”理解为“或者”，“！”理解为“不”，这样有助于你对代码的理解。下表列举了所有逻辑运算符在各种各种运算情况下的结果，仔细观察会发现里面是有规律的：
false && false
true || true
true && true
true || false
true && false
false || false
通过上面的表我们可以得出结论：
●&&&&对于 && 操作，只有当两个条件都为true时结果才为true。
●&&&&对于 || 操作，只要任何一个条件为true则结果为true。
namespace Text
class Program
static void Main(string[] args)
floatprice1=27.3f; //第一种商品的价格
floatprice2=57.0f; //第二种商品的价格
int n1=2; //第一种商品的数量
int n2=3; //第二种商品的数量
floatdiscount=0.2f; //折扣
//总消费金额
doubletotal=price1 * n1 + price2 * n2;
//如果总消费额大于200或者买的每种商品的价格都超过了100则打折
if(total&200||(price1&100&& price2&100))
total=total*(1-discount);
Console.WriteLine(“折后总消费额为：{0}”,total);
Console.WriteLine(“总消费额为：{0}”,total);
运行结果为：
折后总消费额为：180.4799
上面的例子我们首先定义了两个价格和两个数量变量。价格变量定义成浮点型时因
为价格很可能存在小数，数量定义成整型是因为数量只能时整数。然后我们使用算术表达式求出所有的购买商品的总额，并保存到total变量中，total变量采用double类型只是为了演示double的用法，实际上用float型也可以。最后我们使用if语句根据条件来执行不同的代码块，假如if语句后面的括号中关系表达式返回true，则执行折扣计算相关代码，如果返回false则不计算折扣直接显示消费总额。
下面来看一个综合性的示例，猜猜它的运行结果？
class Person
static void Main()
char cSex='男';
iHeight=175;
float fWeight=65.55f;
//体重,float型需要加f
bIsMarriage=
//婚否,取值：true(表示已婚）；false(未婚)
//字符串类型
sName=&张秋枫&;
System.Console.WriteLine(&***************************&);//&&:字符串
System.Console.WriteLine(cSex);
System.Console.WriteLine(iHeight);
System.Console.WriteLine(fWeight);
System.Console.WriteLine(bIsMarriage);
System.Console.WriteLine(sName);
System.Console.WriteLine(&********************************&);
2.3.4赋值运算符
赋值运算符是给一个变量赋一个值，听起来像废话，实际上这个小小的赋值作用非
常大，她会指示系统向变量对应的内存存入一个值。赋值运算符就是我们前面见到的“x=2”表达式中间的那个等于号。这里要注意赋值符号和“等于”号的区别，赋值运算符是一个“=”号，而两个“==”号才是我们前面介绍的的关系运算中表示相等关系的“等于”号。除了基本的赋值符号外，C#中还支持复合赋值运算符号。下表中左边一列是复合赋值运算符，中间一列是示例，右边一列是与左边运算符等效的运算:
赋值运算符
给x赋值2
相当于x=x+2
相当于x=x-2
相当于x=x/2
相当于x=x*2
相当于x=%22
表中那些复合赋值运算符实际上就是后面描述部分的一个缩写形式，只不过那种省略的写法执行效率比较高，这是从C语言继承下来的特性，所以提倡使用前面的那种省略的写法。赋值运算符的计算执行是从右往左进行，比如我们常见的“x=x+2”，实际上是先计算了“x+2”然后再把这个结果给x，所以运算结果后x会增加2，如果出现连写的赋值运算，则计算是从右往左逐个赋值，如：“x=y=a”，则结果x y都等于a，下面是一个经典的交换两个数的算法：
int a=1,b=2;
b=(a+b)-(a=b);
一句话执行完后a、b的值将互换，a变为2，b变为1。计算首先从右边开始，先计算左边括号里面的“a+b”，结果为3，然后计算右边括号里面的值，右边括号里面的值计算完后结果为2，同时a已经等于了2。最后，左边括号里面的结果3减去右边括号里面的结果2得到结果1，这个1赋值给b，那么b就是1了，交换完毕。从上面的例子我们不难看出，系统运算的每一步在内存中都会暂存结果。上面的两个括号的结果先计算完，然后再把这两个结果进行相减，最后将减的结果进行赋值。
namespace MyText
class Text
static void Main(string[]args)
int num=4567;
int thousand,hundred,ten,
thousand=num/1000;
num%=1000;
hundred=num/100;
ten=num/10;
indiv=num%10;
num=indiv * 1000+te n*100+hundred * 10+
Console.WriteLine(“反转后的数是：{0}”，num);
运算结果：
反转后的数是：7654
注意：赋值运算右边表达式的值必须和被赋值对象数据类型相同，如：
int a=3.3f;
float b=‘a’;
上面的第一个表达式右边是浮点型数字而左边是整型的变量，这样是不对的。同样第二条语句右边是字符，左边是浮点型的变量，这样赋值也是不合理的。如果赋值运算两边是引用类型，那么类型也必须兼容。一般来说，你完全可以把变量当作是一个特定的容器，比如装番茄酱的瓶子，对此你不能将辣椒酱装在里面，在进行赋值操作时要特别注意这一点。当然后面我们会介绍数据类型转换的相关知识，有了数据类型的转换你就可以把辣椒酱装到番茄酱瓶子里了，你就可以把浮点型赋值给整型了。
2.3.5 运算符的优先级
现在，你几乎已经了解所有的运算符，是你大显身手的时候了，那么你能计算下面的式子吗： r=（2-1）* 3 + !2 – 5% 2 * 2& && 3；
你如果没有接触过其他程序语言，相信你应该傻眼儿了，这么多运算符应该先算哪个呢？我们在小学时就知道运算符有优先级，我们知道乘法和除法的优先级高于减法运算，而括号的优先级最高，一个式子既有加减又有乘除还有括号，那么计算的顺序是：括号里面的—&乘除--&加减，如“3*4+2/(5+2+1)”式子，结果是：“12.25”。我们知道C#中的运算符远比数学中的运算符多，而且这些运算符都可以出现在同一个表达式中，那么我们的优先级是怎样的呢？
C#中运算符优先级从高到低排列如下表所示：
括号优先级最高
等号，不等号
++，--，！
递增，递减，逻辑非运算符
乘，除，取模操作
=，+=，*=，/=,%=,-=
赋值运算符和复合赋值运算符
小于 小于等于 大于 大于等于
运算符的结合性是指同时出现多个该运算符时的计算方向。比如优先级最高的括号，如果在一个表达式中出现多个括号，那么将从左向右依次计算这些括号里面的内容。再比如大于小于号，如果几个大于 小于号连接在一起，那么是从左到右进行计算的。通常，能接两个操作数的运算符称作二元运算符，比如“+”号，接一个操作数的我们称作一元运算符，比如“!”和“++”等。从上面的优先级例子可以看出，除了括号外，一元运算符的优先级最高。除此之外，从大的范围来讲算术运算符的优先级高于关系运算符，关系运算符的优先级高于逻辑运算符，优先级最低的是赋值运算符。
namespace Text
class Program
static void Main(string[] args)
int y=2002;
if(y % 4 == 0 && y % 100!=0 ||y % 400== 0)
Console.WriteLine（”{0}年是闰年”，y）;
Console.WriteLine（”{0}年不是闰年”，y）;
上面是一个求闰年的算法。假如某年能被400整除那么这年是闰年，如果某年不能被100整除并且能被4整除，那么这年也是闰年，也就是说这两个条件满足其中的一个就是闰年。上面的if语句中优先级最高的运算符是“%”号，所有的“%”计算完了再计算“==”号，然后计算“&&”号，最后计算“||”号，最终结果false，所以2002年不是闰年。这里注意的是，上面的式子不够好，虽然实现了功能，但看起来令人头晕，所以我们提倡多用括号，善于用括号，上面的式子应改为：
If（(y % 4 == 0 && y % 100!=0) ||（y %400 == 0)）
很显然加了括号的式子含义明了，代码工整，直观易懂。这属于代码规范的范畴。多种运算符同时出现的地方不是什么算术表达式，而是像上面那样的条件表达式中。计算运算符的优先级是件头痛的事，加上括号后会使问题变得简单化。
另外，在上面使用运算符号时你可能也注意到了一个问题，这个问题原不属于运算符的优先级的问题，是关于长表达式跟数据类型有关的问题。问题是如果这个表达式中存在各种数据类型的数值怎么办，如下面的式子：
double r=1 + 1/2 + 2.0;
上面式子中r的值为3而不是3.5。对于混合数据类型表达式的计算，结果按照最高精度为准，超过精度的一概被“切”掉，比如“1/2”结果是0，本来计算的结果是0.5，但大家都是整型所以结果是整型，小数点后数字都被“切”掉了。如果将“1/2”变成“1/2.0”，那么结果就是0.5，因为2.0是浮点型，所以结果也是浮点型。长表达式无非就是许多小表达式组合计算的结果，比如上面那个式子，首先计算“1/2”结果是0，然后计算“1+0+2.0”，结果是double类型的3.0。
关于运算符和表达式的内容我们就介绍到这里，要特别注意的是：运算符的优先级以及混合数据类型表达式的计算问题。
实践问题：
1.&&&&& 下列变量的声明正确的是（）
A．int&&&1name；
B．int&&&&_name；
C．int&&&& float；
1.&&&&& 本章中学了几种运算符？他们的优先级从高到低的顺序是什么？
在本章中，我们主要学习了：
u&&&&&&C#的基本语法
u&&&&&&变量的简单类型
u&&&&&&变量的命名规则
u&&&&&&运算符和表达式
u&&&&&&运算符的优先级
练习项目：
学过变量和表达式，请大家发挥自己的想象，做一个和本章紧密相连的项目：
需达到效果如下：
&&&& 在这个项目中，每种运算符至少用一个说明你掌握了此类运算符；运算中要考虑运算符的优先级；声明的变量类型要恰当。
加入asp.net QQ群() ，共同交流进度!
版权所有 爱编程 (C) Copyright 2012. . All Rights Reserved.
闽ICP备号-3
微信扫一扫关注爱编程，每天为您推送一篇经典技术文章。