c基础笔记
*********************
C#语言
*********************
计算机语言分类：
按编程思想分类：面向过程、面向对象
按语言分类：机器语言、汇编语言、高级语言
编程语言：编写可被计算机运行的一系列指令的人工语言
机器语言：
1.到主存中去找简单的数据
2.执行简单的操作
3.存放简单的数据
4.寻址，告知到哪里找数据
汇编语言：
每条语句大大致对应一条机器语言
借助易于记忆的命令编写
高级语言：
利用人类语言听词和语法的一套相对复杂的语句
使用时，必须利用其它程序翻译成机器语言
ASCII码：
也叫计算机的内码（code）
制定了计算机每个符号对应的代码
一个ASCII码以一个字节储存
0到127代表不同的常用字符（符号，数字，字母）
.NET一种多语言开发平台
Java单语言平台
运行平台：
电脑--->操作系统--->公共语言运行库（CLR）--->.NET Framework 类库（FCL）--->编程语言
程序运行：
应用程序--->.NET Framework--->CLR --->操作系统
.NET Framework 类库：方法库
Web窗体Web ServiceWinForms
ADO.NET和XML类
基本框架类
CLR公共语言库 Common Language Runtime解释执行，运行程序
CLS公共语言规范Common Language Speification
CTS通用类型系统Common Type System
JIT即时编译器Just-In-Time
MSIL（Microsoft Inter Language）微软中间语言
C#特点：
面向对象的高级编程语言
由c/c++，java等语言演变过来的，属于c语言家族中的一种
运行于.NET环境
C#于2001年正式发布
IDE(Integrated Development,集成开发环境)
VS:Visual Studio
一套完整的开发工具集
用于开发桌面应用程序、ASP.NET Web应用程序、XML、Web Service、移动应用程序
VS的版本：VS2002-VS2010
.Net 1.0----VS2002
.Net 1.1----VS2003
.Net 2.0----VS2005
.Net 3.x----VS2008
.Net 4.x----VS2010
MSDN帮助文档
C#的应用：
Winform开发（桌面应用程序，运行在Windows下的窗口应用程序）
ASP.NET/WebService开发（WEB应用程序、WEB服务）
wp7开发（移动Web应用程序，运行于手机）
C/S:客户机(Client)/服务器模式(Server)桌面网络应用程序
B/S:浏览器(Browser)/服务器模式(Server)网站应用
C#的特点：
简单性、面向对象、运行在托管平台中
项目的操作：
Ctrl + shift + N 新建项目
解决方案中可含多个项目，项目可含多个文件，文件中是文件和程序.cs （命名空间---类---方法）
解决方案--->项目--->应用程序
有多个项目，应设置启动项
卸载项目(停止编译，不同于删除和移除)
加载项目（激活卸载项目的项目）
基本技巧：
Home光标到行首 End 光标到行尾
PgUp 向上翻页 PgDn向下翻页
Shift + 方向键对文字进行选中操作！！
Ctrl + Home光标到文档开头
Ctrl + End光标移到文档尾部
对话框中可用 Ctrl + C 可对其中的内容进行复制！！
Ctrl + Z撤销
字符使用半角英文字符
F5调试F6生成
#region和#endregion折叠代码段
cw 按TAB键，可以变成Console.Writeline();
Ctrl + K + F 自动对齐，自动排版
F9设置断点
F11按两次逐句执行
return;停止执行
goto跳转到标签，用于循环
Console.Clear();清屏命令
命名空间：namespace 名字
用于建立类并解决类的重名（类的文件夹）
System 是根命名空间
不同命名空间下类的访问：
1.using 命名空间名（引用命名空间）
2.命名空间名.类名
命名空间-->>类-->>方法
创建开发环境，新建项目：
//引用命名空间
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//定义命名空间
namespace 第一个项目
{
class Program //定义类
{
static void Main() //静态无返回值的主方法
{
Console.WriteLine("Hello Word!");
}
}
}
关键字：系统已定义的具有特殊意义的符号！（using/namespace/class/static/void）
C#程序的基本结构：
引用命名空间：using...
定义命名空间：namespace...{}
定义类：class...{}
主方法：static void Main(){}
一个C#程序中有且仅有一个Main()方法，程序的入口和出口，
包含在类的定义中，必须是静态无返回值
string value:字符串参数
C#中严格区分大小写
重置开发环境恢复默认状态：工具--导入导出--重置所有设置----C#
.cs类文件只能修改，不能运行
.csproj项目文件
.sln解决方案文件 一般打开此文件
Main方法：是程序的执行入口，一个程序有且只有一个主方法。
语句类型：
条件语句、循环语句、赋值语句、操作语句
加法运算，只要有字符串都会有拼接效果：
"a"+"b"="ab"
1 + 2 = 3
"a" + 2 ="a2"
"1" + "2" = "12"
以@开头的字符串中\c没有转意字符的功能
字符串的//，只会输出/
ctrl + shift + b 编译，检查语法错误
标识符-------名字（类名、对象名、命名空间、方法名、变量名等）
以字母和下划线开头，可以包含数字，关键字做标识符时要在前面加@
C#严格区分大小写，不能有重名，age和Age是两个不同的标识符
命名规则：
1.有意义，全用英文，不充许有空格
2.必须以字母或下划线开头，后面可以跟字母，数字和下划线
3.不能取C#的关键字
4.不能重复定义，可重复赋值
5.要区分大小写
Camel命名法（骆驼命名法）：首字母小写，其它单词的首字母大写，如：studentName
Pascal命名法（帕斯卡命名法）：首字母都大写/英文缩写都大写，如：SoftwareName用于全局变量
匈牙利命名法：strName 类型 + 变量名
（一般常用Camel命名法）
命名空间和类名开头大写
关键字全部小写
注：string 字符串引号内书写时，不能折行书写
int整型iAge
string字符串strName
Button按钮btnSubmit
int变量iweigh
使用空格:
（1）双目操作符的前后加空格(+, =, && 等)，index = index + 1;
（2）单目操作符前加空格(!, ++, ~ 等)， index ++;
（3）逗号、分号只在后面加空格
（4）使用空行，在一段功能代码、或者函数、属性之间插入空行，这样会很直观
（5）每一完整的语句以冒号 ; 结尾
白空间
空格和额外的换行tab都不被编译
不对引号内的任何保空白做忽略，引号内的空格作为字符串存在
转义字符：
\'单引号\"双引号
\\单斜杠\0空
\a警告\b退格
\n换行\t空4个字符，水平制表符，用于对齐
\r回车\v垂直制表符
@符号的功能：
1. 命名时，放在前面可以命名关键字
2. 放在字符串前面可以让其中的转义字符失效正常输出
3.可使字符串能够换行
4.字符串前面有@符号，字符串中""会只输出一个"
运算符
=赋值运算符，将右边的值赋给左边的变量
+加法运算变量都是数值型则加法运算：1 + 2 = 3
连接，变量有一个是字符则连接运算 : 1 + "abc" = 1abc
输入与输出：
Console.WriteLine ("Hello word!");换行输出(并返回一个string字符串)
Console.Write("aaa");不换行输出
Console.ReadLine();暂停，读取用户输入的一行字符串直到用户按下回车后返回结果
Console.Read();从控制台读取用户输入的第一个字符，以ASCII码返回，返回的值为Int类型
Console.ReadKey();等待用户键入一个键，之后再继续执行（相当于按任意键继续或退出）
Console.WriteLine(Console.ReadLine()); 输出用户的输入
完整形式：System.Console.Write();
调用System命名空间下的Console类中的静态方法Write()方法
修改及错误调试：
项目解决方案\bin\Debug\
生成解决方案F6：检查语法错误，修改后生成，重新生成应用程序
调试F5：先生成后运行
双击错误，可定位到错误，也可按行号寻找
设置字体与行号：
工具-->选项-->字体与颜色
工具-->选项-->所有语言-->行号
注释：
单行注释：//要注释的内容
多行注释：/*要注释的内容*/
文档注释：敲///，对方法、类和参数等注释
注释功能快捷按钮
-----------------------------------
******数据类型******
-----------------------------------
C#中的变量的数据类型：（值类弄存储在堆栈中，引用类型存储在托管堆上）
值类型：-->>>存储于堆栈中
1.整型
sbyte微整型byte无符号微整型8位1字节
-128~1270~255
short短整型ushort无符号短整型16位2字节
-32768~327670~65535
int(i)整数类型uint无符号整型32位4字节
-2147483648~21474836470~429497295
long(lng)长整型ulong无符号长整型64位8字节
9223372036854775808~92233720368547758070~18446744073709551
2.浮点类(实数类)
float 单精度浮点数32位4 赋值时结尾应加上F或f(float i = 123.54F;)共7位
double(dbl)双精度浮点数64位8 (含小数时的默认类型，只有16位有效数据）共15位
3.decimal型（货币类型）
高精度十进制数128位 16字节 精确到29位
赋值时结尾应加上M或m(decimal i = 123.540M;)
精度高，存储财务型数据(dec)
4.布尔类型：
bool(bln) 表示true或false
(用于表示：关系运算和逻辑运算的结果)
5.字符类型：
char(chr)单个字符变量16位 2字节
变量赋值时，字符应该以单引号引起来
6.枚举/结构
引用类型：-->>>数据存储于托管堆上，堆栈中存储引用地址
1.字符串类型：string (存储字符串)---缩写str
2.根类型：Object
注：
在C#中，写一个小数，默认为double类型
在给double和decimal类型赋值时，值要加后缀f(F)或m(M)
char的值用单引号，string用引号
变量：
代表着一块内存空间，可通过变量名向内存中存/取数据！！
有变量名，就不需要记忆复杂的内存地址了！！
用来存储特定的值
变量具有不同的类型
变量中的值可以改变，可多次赋值。
常量：其值在程序的运行的过程中不能改变的值
const 类型 常量名 = 常量值
常量在初始化时就必须赋值，在使用过程中不能发生改变的量
**常量的类型：
字符常量const string="aaa";
符号常量const int i=10;
枚举类型
**注意：
常量必须被初始化，不能分步赋值。
变量的值不能赋值给常量
常量的值可以赋值给常量
常量的值不可以改变
使程序更易阅读，更易修改
例：const double PI=3.1415926;
变量这定义和赋值：
1.先定义，再赋值数据类型 变量名; 变量名=值;
int iFirstVar, iSecondVar, iThirdVar
iFirstVar = 1; iSecondVar = 2; iThirdVar = 3;
2.定义时赋值数据类型 变量名=值;
int iFirstVar = 1, iSeconVar = 2, iThird = 3;
string i = null; //表示空值，不占内存空间
string j = "";//给j赋空值，但占一定的内存空间
string f = " "; //给f赋空值，占一定的内存空间，一个空格，对应的有ASCII码
作用域：从定义开始到大括号结束为止，全局变量和局部变量
变量的互换的三种方法：
中间量int a, b，c;
a = 100; b = 200;
c = a;
a = b;
b = c;
Console.WriteLine("a = {0} b = {1}",a,b);
//{0}（占位符） :
为占位符，替后面的变量值占位，数字从0开始，0表示从后面的第一个变量
占位符不能比后面的变量多，变量可以比占位符多
占位符可以重复使用
加减法等价于
int a=100, b=200;
a = a + b;
b = a - b;
a = a - b;
Console.WriteLine("a = {0} b = {1}",a,b);
乘除法等价于
a = a * b; //乘除法互换变量
b = a / b;
a = a / b;
Console.WriteLine("a={0} b={1}",a,b);
一次输出多个变量：
string a = "Hello",b = "Jack";
Console.Writeline ("{0},{1}",a,b);
等价于
合并字符串1Console.Writeline (a+","+b);
等价于
合并字符串2string c = a +"," +b;
Console.Writeline (c);
格式化输出的字符串：
Console.WriteLine(“{N[,M][:格式化字符串]} ”);
C或c:货币数据类型格式D或d：整数数据类型格式
E或e：科学计数法格式F或f：浮点数据类型格式默认保留两位
例：
int m = 123;
double n = 123.66666;
Console.WriteLine("{0:f2}",n); //将n以保留两位小数输出
Console.WriteLine("m={0,8:D}\n n={1,10:f2}", m, n);//将m的值以占8位字符,整数型输出
//将n的值以占10位字符,保留两位小数的浮点型输出！
Console.WriteLine("m={0,-8:d}over\n n={1,-10:f2}over",m,n);
Console.ReadKey();
枚举：
重新定义一种新类型，并指定该类型所有的值
语法：
enum 类型名 {值1, 值2, 值3...值n};
值的默认编号是从0开始递增，（也可值1=1，这样是从1开始）
如：
定义：enum Gender {男,女}//定义了一个枚举类型为Gender，这个类型只有两个值
用法：Gender sex;
sex = Gender.男;
int i = (int)sex
注：
枚举一般和类定义在同一个级别即命名空间中
定义枚举里，字符不需要加引号
定义枚举时，值不能是int类型
枚举类型都可以转换为int类型
优点：可限定变量的取值范围
限制用户只能选择枚举中的值
提示用户选择相应的值
字符串类型===>为枚举类型：
(定义的枚举型)(Enum.Parse(typeof(定义的枚举型),"(待转换的字符串)");
如：
try
{
sex = (Gender)(Enum.Parse(typeof(Gender),Console.ReadLine()))
Console.WriteLine ("你输入的性别为："+sex)
}
catch
{
Console.WriteLine ("你输入的性别有误！")
}
数据类型的转换：
一、显式转换（强制转换）：Convert.ToInt32()/i.ToString()/(int)2.0/string i=""+1;/int.Parse(i);
字符串与数值之间的转换
丢失精度的转换
1. string x = "12";
double a = Convert.ToDouble (x);
或
double a = Convert.ToDouble(Console.ReadLin(););
2. 用int.Parse ( ); //只能转换string字符串类型的数值
string x = "12";
double a = double.Parse(x);
3. 对数值型取整(少用,值类型间转换)
int a = (int)1.98; //对小数取整会丢失精度a=1
char z=(char)Console.Read();
char x=(char)98;
注：Convert.ToInt32()用于小数时，会四舍五入
二、隐式转换：系统默认，不需要声明，两种类型必须相兼容，即数值型之间可以转换，低精度-->高精度
int i = 'a'; //字符型隐式转换为整形
long j = 12345;
double u = 12223; //int类型隐式转换为double类型
decimal x = 12; //in类型隐式转换为decimal类型
先转换，后运算
取值范围大的类型不能转换为取值范围小的类型
取值范围小的类型可以转换为取值范围大的类型
decimal 类型不能隐式转换为其它类型decimal 类型精度最高
double 类型不能隐式转换为其它类型double 类型取值范围最大
注：凡是会丢失精度的转换都不能完成隐式转换
如果一个表达式中有一个是double类型，则结果一定为double类型
取值范围大小：
sbyte < byte < ushort < short < uint< int < long < decimal < float < double
注：在C#默认类型与类型运算
没有小数点的数值，默认为整型
有小数点的数值，默认为double类型
整型相除，只要有一个小数，结果为浮点型
整型相除，都为整型，结果为整型
如：
int i, j;
double m, n;
n = 12.3 / 4;//n为浮点型
n = 12 / 4;//n为整型
数值型转换为字符串类型三种方法：
方法一：
double a = 3.14;
string x =Convert.Tostring(a);
方法二：
double a = 3.14;
string y = a.ToString();
方法三：
double a = 3.14;
string z = a + "";
日期与时间转换：
DateTime：日期类型（值类型，一种结构体）
Console.WriteLine("请输入一个日期：");
//将用户输入的日期转换为日期类型：输入格式1999/9/9 或 2000 2 2 或 2000-2-2
DateTime d = DateTime.Parse(Console.ReadLine());
int month = d.Month;//获取用户输入的月份
int day = d.Day; //获取用户输入的日期
int year = d.Year; //获取用户输入的年份
Console.WriteLine("你输入日期的是:{0}年{1}月{2}日",year,month,day);
Console.WriteLine("你现在的当前日期时间是：{0}",DateTime.Now);//获取当前时期时间
Console.WriteLine("你现在的当前日期是：{0}", DateTime.Now.ToLongDateString());
//获取当前日期以长日期字符串表示
Console.WriteLine("你现在的当前时间是：{0}", DateTime.Now.ToLongTimeString());
//获取当前时间以长时间字符串表示
-------------------------------------------
输出结果:
请输入一个日期：
2002.2.2
你输入日期的是:2002年2月2日
你现在的当前日期时间是：2012/5/28 12:54:02
你现在的当前日期是：2012年5月28日
你现在的当前时间是：12:54:02
--------------------------------------------
C#中常见运算符：
按对象(操作数)分类：单目运算符(+/-/--/++/!/=)、双目运算符、三目运算符（一元/二元/三元）
算术运算符
+-*/%模（取余）
注：若要改变优先级，用小括号，小括号可以无限次使用
1%2=1; 0%2=0;5%2=1;
自运算符
++--
int i=1,y;
y=i++; 等价于y=i; i=i+1; 结果y=1
y=++i;等价于i=i+1; y=i; 结果y=2
++a 先运算，后赋值 a=a+1 <=> a++ ++a
a++ 先赋值，后运算
自增与自增，a的值都会加1或减1，式子的值会有区别
关系运算符
><<=>===!=
逻辑运算符
&&与||或！非
优先级： ！非 > &&与 > ||或
&&：有假必假（当第一个表达式为假，第二个表达式不再执行）if(x>10 && x<5)
||：有真必真（当第一个表达式为真，第二个表达式不再执行）if(x>10 || x<5)
！：非真必假，非假必真 if(x != 5 )
与和或的短路：
&&与：当第一个表达式为假，第二个表达式不再执行
||或：当第一个表达式为真，第二个表达式不再执行
(year%400==0||year%4==0&&year%100!==0)?"润年":"平年";
赋值运算符
a = ba+=ba-=ba*=ba/=ba%=b
a+=b相当于a=a+b;
赋值运算，从右向左赋值
条件运算符
A ？ B : C
A如果成立，则执行B，否则执行C
A的结果必须是Bool类型，B和C的类型必须兼容
条件运算符依然是从右到左执行 例：A?B:C<F？M:N
逻辑运算和关系运算符的结果为Bool类型，结果只能是true或false
优先级：带()[]的自运算符 ＞ 算述运算符 > 关系运算符 ＞ 逻辑运算符&&|| > 条件运算符 ＞ 赋值运算符=
1.带（）[]的，new,typeof,sizeof,checked,x++,x--
2.++x,--x,+,!
3.算术 > 关系 > 条件 > 赋值
注：赋值运算符的优先级最低
异常捕获（错误提示）：
try
{ 可能出错的代码 }
catch
{ 出错后的处理或报错信息 }
如果try中的代码正确，则正常运行，跳过catch
如果try中代码一旦出错，则执行catch中的代码
————————————————
**结构化程序设计**
————————————————
程序的三种结构：
顺序结构
分支结构(选择结构)：if/if-else，switch，A？B:C
循环结构：while，do-while，for
-------------------------------
分支结构
ifif-elseswitch
-------------------------------
==== if 结构的基本语法：
布尔表达式/条件表达式/逻辑表达式
结构1：简单(单分支)
if (条件表达式)
{执行语句1;}//当表达式成立时，执行语句
结构2：标准（双分支）
if (条件表达式)
{执行语句1;}//当表达式成立时，执行语句
else//相当于否则
{执行语句2;}//当表达式不成立时，执行的语句
结构4：else if(多分支)
if (条件表达式1)
{执行语句1;}//表达式1成立时，执行此语句
else if(条件表达式2)//当表达式1不成立时，判断表达式2
{执行语句2;}//表达式2成立时，执行此语句
else//
{执行语句3;}//以上条件都不成立时，执行此语句
结构3：if嵌套
if(布尔表达式1)
{
if(布尔表达式2)
{语句1;}
else
{语句2;}
}
else if(布尔表达式3)
{
if(布尔表达式4)
{语句3;}
else
{语句4;}
}
注： else 与离它最近的 if 是一对！
==== switch case 多分支选择语句：
表达式的值与case相比，若匹配，则执行case后面的语句，
否则执行default后面的语句
结构1：
switch (表达式或变量) //表达式的值可以是浮点数以外的作何类型（不能是小数点类型）
{
case 值1：
语句块1; //值一定要和表达式或变量的类型相兼容
break;//return
case 值2：
语句块2;
break;//return
case 值3：
语句块3;
break;//return
case 值4：
语句块4;
break;//return
default：
语句块5;
break;//return
}
结构2：
switch (表达式)
{
case 值1：
case 值2：
case 值3：
case 值4：
语句块4;
break;
default：语句块5;
break;
}
注：
匹配时，与default的位置没有关系，只和其中的值有关系
任何两个case后面的值都不同
浮点型等带小数的值不能用在case后面
一个switch语句中必须有一个default,且只能有一个！！
switch与if - else if 的区别：
switch: 一般只用于等值比较
if - else if :可以处理范围
sizeof(int)=4
-------------------------------------------------
循环
whiledo……whileforforeach（数组循环）
-------------------------------------------------
===== while 循环:***先判断，后执行***
while (循环条件)
{循环体;}
注：
循环条件为true，继续循环
循环条件为false,循环结束
循环条件一定可以终止，避免死循环的出现！！！
可能一次都不执行循环体
===== do while 循环：***先执行，后判断***
do{循环体;}
while (循环条件);
注：至少执行一次循环体
==== for循环已知循环次数的循环
结构1：基本结构
for (表达式1; 表达式2; 表达式3)
{
循环体语句;
}
表达式1：循环变量初始值
表达式2：循环终止条件
表达式3：改变循环变量，自增或自减
结构2：for循环的嵌套
for (1; 2; 3)
for (4; 5; 6)
A;//内层循环体，其它的都属于外层循环
B;
//整体是两个语句，for和B两个语句
//循环顺序：1→2
2成立时2→4→5
5成立时 5→A→6→5
5成立时，5不成立时
5不成立时 5→3→2
2成立时，2不成立时
2不成立时2→B //到此循环结束
//小知识//
{2:00}:表示数值不足两位，在前面补0，超过两位不受00的控制，正常显示
重点：
for循环嵌套：外循环控制行，内循环控制列
跳转语句：
break/return/countinue/goto/throw
break:
用于switch，终止其后语句的执行，退出switch语句。
用于循环，跳出当前层次的循环（离它最近的循环）
注：放在其它位置，会出错！
continue:
必须用于循环中，用于结束当前一次循环，继续下次循环
while (1)
{A; B; continue; C; D}
//执行到cotinue,不再执行C和D,直接进入下一次循环条件的判断
例：
for(int i = 1; i <= 100; i++)
{
if(i % 3!=0)
{ continue; }
Console.WriteLine( i );
}
return:
结束当前函数
退出当前方法
goto:
无条件跳转语句
用于从多重循环中跳出
注：不利于阅读规范，慎用！！！
========================================
***数 组***
========================================
一维数组、二维数组、三维数组....（引用类型）
定义：数量固定的相同类型元素的组合
数据类型[] 名称 = new 数据类型[长度];
结构：int[] mylnt = new int[6];//定义一个：名为mylnt的int类型有6个元素的数组
数组的声明和赋值
动态初始化：
int[] nums;
nums = new int[3]{1,2,3}; 或nums[0] = 1,...
int[] nums = new int[3]{1,2,3}
int[] nums = new int[]{1,2,3}
静态初始化：
数据类型[] 名称 = {元素,元素,元素,元素...};
int[] nums = {1,2,3};
一次可声明多个同类型的变量，在内存中连续存储
索引从0开始，通过索引号访问
[]内的值一定要是常量
例：错误 写法：
int j = 3;//j是变量，正确写法为：const
int[] x = new int[j]{1,2,3};
数组在未赋值时默认值：
数值型0
布尔类型False
字符型(空Null)
枚举型0
一维数组的遍历（取值）：
用for循环来给数组赋值和取值：
arrys.Length用来获取数组的长度
int[] nums = new int[] {10,11,12,13,14,15};
for (int i = 0; i <= nums.Length-1; i++)
{
Console.WriteLine(nums[i]);
}
foreach循环：只用于数组值输出，遍历数组，访问数组中的每一个元素
结构：foreach (数据类型 变量名 in 数组名)
用法 ：foreach (int x in arrNames)
{
Console.WriteLine(x);
}
//x是标识符，要符合命名规则，指的是数组中的任意一个元素
随机数生成器：Random x = new Random();//在内存中划取一块新空间生成一个随机数生成器
int n = x.Next(0,10);//在0到10中（不含10）随机取一个整数赋值给整型变量n
例:
string[] arrNames = { "a", "b", "c"};
Random x = new Random();//
int i = x.Next(0, arrNames.Length);
Console.WriteLine(arrNames[i]);
----------------------------
二维数组
============================
格式：int[,] arrNames = new int[3,6]{{1,2,3,4,5,6},{10,20,30,40,50,60,},{100,200,300,400,500,600}};
Console.WriteLine(arrNames.GetLength(0));//获取二维数组的行数
Console.WriteLine(arrNames.GetLength(1));//获取二维数组的列数
//用for赋值
for (int n = 0; n < 6; n++)
{
arrNames[0, n] = n+1;
arrNames[1, n] = (n+1) * 10;
arrNames[2, n] = (n+1) * 100;
}
//两层for循环方法输出
for (int i = 0; i < arrNames.GetLength(0); i++)
{
for (int j = 0; j < arrNames.GetLength(1); j++)
{
Console.Write("{0}\t", arrNames[i, j]);
}
Console.WriteLine();
}
//foreach 方法输出
//foreach (int x in arrNames)
//{
// Console.Write("{0}\t", x);
//}
Console.ReadKey();
查找数组中的元素：
Array.IndexOf与Array.LastIndexOf方法
int first = Array.IndexOf(sort, 99);//在数组中从左向右找99，并返回这个值的下标
int first1 = Array.IndexOf(sort, 32, 3, 3);//指定查找范围：从索引号为3开始起的3个元素中查找
Console.WriteLine("99在数组中从左向右第一次出现的位置：{0}", first);
int last = Array.LastIndexOf(sort, 99);//在数组中从右向左找99，并返回这个值的下标
int last1 = Array.LastIndexOf(sort, 99 ,10,3);
Console.WriteLine("99在数组中从右向左第一次出现的位置：{0}", last);
Console.WriteLine(last1);
数组的排序与反转：
Array.Sort与Array.Reverse方法
//Array.Sort(sort);//由小到大排序
//Array.Sort(sort, 3, 4);//指定排序范围，从索引号为3开始起的4个元素按从小到大排序
//Array.Reverse(sort);//反转数组
//Array.Reverse(sort, 3, 4);//指定范围：从索引号为3开始起的4个元素反转
清空数组中指定元素的值：
Array.Clear(sort, 3, 3);//清空数组的从索引号为3开始起的3个元素的值
=================
动态数组：ArrayList
=================
//using System.Collections;首先导入此命名空间
ArrayList alst = new ArrayList();//定义一个动态数组为alst,长度不定
向动态数组中添加元素
alst.Add("111");//向动态数组中添加元素
alst.Add("222");
alst.Add("aaa");
alst.Add("bbb");
//向动态数组中一次添加多个元素
alst.AddRange(new string[] { "01", "02", "03" });
删除动态数组中的元素
//alst.Remove("aaa");//删除数组中为aaa的字符串
//alst.RemoveRange(4,3);//一次删除多个元素
//alst.RemoveAt(1);//删除数组中索引号为1的元素
清空动态数组中的元素
//alst.Clear();//清空数组中的元素
插入元素到指定位置
alst.Insert(1,"555");//在索引号为1的位置插入555字符串
alst.InsertRange(2,new string[]{"gf","fd"});//在索引号为2处，插入多个字符
获取动态数组中元素的个数
Console.WriteLine(alst.Count);//获取动态数组alst的长度，即元素个数
用for循环遍历数组
for (int i = 0; i < alst.Count; i++)
{
Console.WriteLine(alst[i]);
}
用foreach来遍历动态数组
foreach (string x in alst)
{
Console.WriteLine(x);
}
******数组的数组/数组的集合
int[][] numbers = new int[5][]; //长度为5的数组，它的每个元素都是一个数组
for (int i = 0; i < 5; i++)
{
numbers[i] = new int[10]; //长度为5的数组的每个成员都是一个长度为10的数组
for (int j = 0; j < 10; j++)
{
numbers[i][j] = j; //长度为10的数组成员赋值
}
}
string[] answer1 = {"丽江", "拉萨", "昆明", "杭州", "北京", null };
string[] answer2 = { "蛇", "猪", "老鼠", "苍蝇", null, null };
string[][] anSwer = new string[2][];
answer[0] = answer1;
answer[1] = answer2;
=======
结构体
=======
结构是一种用关键字struct声明的自定义数据类型。
与类相似，也可以包含构造函数，常数，字段，方法，属性，索引器，运算符和嵌套类型等
定义：
public struct Person//定义一个名称为Person的结构
{
public string name;//结构成员
public Gender sex;//结构成员
public int age;//结构成员
}
用法：
person onePerson;
onePerson.name = "张三";
onePerson.age = 20;
onePerson.sex = Gender.男;
结构和类的区别：
结构不能从另一个结构继承，结构从Object继承，也可以实现接口
结构是值类型，创建于堆栈中
类是引用类型，创建于托管堆中
结构在引用时，以结构名.实例名访问，且不需要实例化
函数（方法）：
将一堆代码进行重用的一种机制
一般定义大类中
如：Console.WriteLine();
格式：
[访问修饰符][static]返回值类型 方法名([参数])
{
方法体
}
命名规则：方法名开头大写，参数名开头小写
定义方法：
public static void ShowUI()
{
Console.WriteLine ("**********");
Console.WriteLine ("** 界面 **");
Console.WriteLine ("**********");
}
调用：ShowUI();//或写成Program.ShowUI();
如果是静态方法（由static修饰）则使用类名.方法名()
在当前类中调用的方法，可以只写方法名();
注：
方法一般定义在类中
如果方法没有返回值，则返回值类型为void
如果方法没有参数，()不能省略
变量的作用域：
在方法中定义的变量为局部变量，
作用域从定义开始到其所在的大括号结束为止
堆栈与托管堆：
值类型存储于堆栈中
引用类型的值存储于托管堆中
堆栈中存储引用类型的托管堆的地址
Math.Abs()求绝对值函数
Math.Truncate()截取小数的整数部分
Math.sqrt()返回指定数字的平方根（返回类型为double）
冒泡排序法:
int[] arrNum = {4,9,10,27,6,14,11,28,27 };
foreach (int x in arrNum)
{ Console.Write("{0}\t",x);}
for (int i = 0; i < arrNum.Length-1; i++)
{
for(int j=0; j<arrNum.Length-1; j++)
{
if (arrNum[j] < arrNum[j + 1])
{
int temp = arrNum[j];
arrNum[j] = arrNum[j + 1];
arrNum[j + 1] = temp;
}
}
}
Console.WriteLine();
foreach (int x in arrNum)
{Console.Write("{0}\t", x);}
Console.ReadKey();
Array.Sort(arrNum);//从小到到排序
浙公网安备 33010602011771号