c#学习笔记

c#笔记

游戏开发之路

基础理论

数据结构和算法

设计模式

计算机网络 计算机图形学

操作系统 编译原理

基础技能

C#Unity

就业必备

UI系统

热更新技术

平台相关

网络游戏开发

程序基础

主流语言的应用领域

C:嵌入式硬件开发

C++:（虚幻）游戏客户端、服务器、软件

C#:（unity）游戏客户端、服务器、软件、网站

Java:安卓、服务器、软件、网站

JavaScript: H5游戏、网站、服务器

PHP:网站、服务器

Python:网站、服务器、辅助开发

SQL:数据库

Go:服务器

Objective-C:苹果(mac、ios）相关

Swift:苹果(mac、ios)相关

市场需求——手游，unity，c#

常用的IDE(集成开发环境)软件

Visual Studio:一般Windows操作系统使用的软件都由它来进行开发，可用于开发基于C、C++、C#等等语言的软件

一个解决方案，，多个项目

Eclipse和IntelliJlDEA:一般主要用于开发Java语言的相关软件

Android Studio:谷歌推出，主要用于开发安卓应用

Xcode:苹果推出，主要用于开发苹果应用

API

程序代码之间的相互调用——API的相互调用
API: (Application Programming Interface，应用程序接口)是一些预先定义的代码逻辑。
用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。

注释

1.两杠注释://用于注释一行信息
2.星号注释:/*用于注释多行信息/*
3.三杠注释:///用于注释类class、命名空间namespace等等

工具栏

快捷键

1.注释Ctrl+k，ctrl+c

2.取消注释Ctrl+k，ctrl+u

代码块

1.命名空间（面向对象）——工具包

引用工具包：using System;

2.类（面向对象）——工具

3.函数——可以做的事情

主函数：程序的主入口main

c#入门

C#基础语法
环境搭建、变量、类型转换、运算符条件分支语句、循环语句

控制台 输入输出

打印内容 自动换行

——通过+号 拼接打印

双引号“”字符串

变量不用引号

//不输入内容 只换行

Console.WriteLine();
Console.WriteLine("hello");

打印内容 不换行

Console.Write("please input");

读取输入(回车——输入完毕)

//等待玩家输入完毕后(按回车键)才会继续执行后面的代码

//可以输入很多信息直到回车结束

Console.ReadLine();

检测玩家是否按键

//只要按了键盘上的任意键就会认为输入结束

Console.ReadKey();

折叠代码

#region``````#endregion配对出现
//将中间包裹的代码折叠起来，避免代码太乱

输入#region之后按tab键 自动补全

//本质是编辑器提供给我们的预处理指令
//它只会在编辑时有用，发布了代码或执行代码它会被自动删除

#region 知识点一
//折叠代码
Console.WriteLine("hello");
#endregion

变量

申明变量

变量类型 变量名 = 初始值；

变量类型（14种）

——关键字，存储的类型，存储的范围

1. 有符号的整形变量（正负数包括0）

• sbyte -128~127

• int -21亿~21亿多

• short -32768~32767

• long -900万兆~900万兆

2. 无符号的整形变量（正数和0）

• byte 0~255

• uint 0~42亿多的一个范围

• ushort O~65535之间的一个数

• ulong 0~18百万兆之间的数

3. 浮点数(小数)

四舍五入

根据编译器不同有效数字也可能不一样

有效数字是从左到右从非0数开始算有效数字的

• float

存储7/8位有效数字

在后面加f或者F——c#中申明的小数默认是double的类型，加f是告诉系统它是float类型

• double

存储15~17位有效数字

• decimal

存储27~28位的有效数字，不建议使用

在后面加m或者M

4. 特殊类型

• bool 真假

• char 字符 单个字符——单引号’‘

• string 字符串 多个字符——双引号”“

——

——

数字用int，小数用float，字符串用string，真假用bool

多个同类型变量申明：
变量类型变量名=初始值,变量名=初始值,变量名=初始值…;

变量的存储空间(内存中)

单位转换

1byte = 8bit

1KB =1024byte

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

通过sizeof方法可以获取变量类型所占的内存空间(单位:字节)

int size = sizeof(double);

变量类型——内存空间

变量类型	范围	内存空间
//有符号
sbyte	-128~127	1
int	-21亿多~21亿多	4
short	-3万多~3万多	2
long	-9百万兆多~9百万兆多	8
//无符号
byte	0~255	1
uint	0~42亿多	4
ushort	0~6万多	2
ulong	0~18百万兆多	8
//浮点数
float	7~8位有效数字	4
double	15~17位有效数字	8
decimal	27~28位有效数字	16
//特殊
bool	true,false	1
char	单个字符	2
string	字符串长度是可变的，不定	sizeof不能得到string类型所占的内存大小

变量的本质

变量的本质是2进制

计算机中所有数据的本质都是二进制，0和1
数据传递只能通过电信号，只有开和关两种状态。用0和1来表示这两种状态

• bit(位)

计算机中的存储单位最小为bit，只能表示0和1
1bit就是1个数，要不是0要不是1

• byte(字节)

由8个bit组成的存储单位。一个字节为8位

十进制》二进制——对二取余，倒着

二进制》十进制——从右往左看最右边的一位为第0位，如果该位不为0则加上2的n位次方

有符号 无符号 整形 区别——有符号 第一位 表示符号（符号位）

变量命名规范

1.不能重名

2.不能以数字开头

3.不能使用程序关键字命名

4.不能有特殊符号（下划线_除外)

建议的命名规则:变量名要有含义—>用英文(拼音)表示变量的作用

不建议的命名规则:用汉字命名

驼峰命名法——首字母小写，之后单词首字母大写(变量)

帕斯卡命名法——所有单词首字母都大写（函数、类)

——c#区分大小写

常量

申明常量

const 变量类型 变量名 = 初始值；

1.必须初始化

2.不能被修改

用处：数学相关固定的数

转义字符

\字符

enter上面的反斜线\

目标	写法	结果
//常用转义字符
单引号	\’	’
双引号	\"	"
换行	\n
斜杠（计算机文件路径）	\\	\
//不常用转义字符
制表符	\t	tab键（4个空格）
光标退格	\b	光标退格再继续输出
空字符	\0	没用
警报音	\a	系统发出声音

取消转义字符：

在字符串“”之前加@

shift+2

类型转换

隐式转换

不同类型之间自动转换

大范围装小范围

• 相同大类型之间的转换
  //可以用大范围装小范围的类型
  //不能够用小范围的类型去装大范围的类型

类型	规则（大——>小）
有符号	long——>int——>short——>sbyte
无符号	ulong——>uint——>ushort——>byte
浮点数	double——>float
	decimal这个类型没有办法用隐式转换的形式
特殊类型	bool char string不存在隐式转换

• 不同大类型之间的转换

类型转换		条件
//无符号和有符号之间
有符号——>无符号	x	无符号不能装负数
无符号——>有符号	√	大范围装小范围
//浮点数和整数(有、无符号)之间
整数——>浮点数	√	任何类型的整数
		超过一定范围 自动使用科学计数法（e）
浮点数——>整数	x	整数不能存小数
//特殊类型
bool	x
char——>部分整形和浮点数	√	char类型是一个16位无符号整数，用于表示Unicode字符的编码值
		取值范围是0到65535
		可以隐式转换为比它宽度更大的数值类型int、long、ushort、ulong等
		对应的数字是一个ASCII码
string	x

• 隐式转换规则 总结

double——> float——>整数(无符号、有符号)——>char

decimal——>整数(无符号、有符号)——>char

long——>int——>short——>sbyte

ulong——>uint——>ushort——>byte

string和bool不参与隐式转换规则的

无符号没法隐式存储有符号的
有符号的可以隐式存储无符号（范围大小)

显示转换

手动处理强制转换

1.括号强转

将高精度的类型强制转换为低精度

常用于转数值

变量类型 变量名 = ( 变量类型 ) 变量;

注意:精度问题 范围问题

相同大类的整形——范围问题

无符号和有符号——范围问题

浮点和整形——精度问题（浮点数强转成整形时，直接抛弃掉小数点后面的小数

char和数值类型

bool和string不能括号强转

2.Parse法

把字符串类型转换为对应的类型

变量类型.Parse("字符串")
字符串必须能够转换成对应类型，否则报错

string不用

3.Convert法

更准确的将各个类型之间进行相互转换

Convert.To目标类型(变量或常量)

填写的变量或常量必须正确否则出错

每一个类型都存在对应的Convert中的方法

sbyte sb5 = Convert. ToSByte( "1");
short s5 = Convert.ToInt16("1");
int i5 = Convert.ToInt32("1");
long 15 = Convert.ToInt64( "1");

byte b6 = Convert.ToByte( "1");
ushort us5 = Convert.ToUInt16( "1");
uint ui5 = Convert.ToUInt32( "1");
ulong ul5 = Convert. ToUInt64( "1");

float f5 = Convert.ToSingle( "13.2");
double d5 = Convert.ToDouble( "13.2");
decimal de5 = Convert.ToDecimal( "13.2");

bool bo5 = Convert.ToBoolean( "true" );
char 5 = Convert.ToChar("A");
string str5 = Convert.ToString(123123);

字符串转对应类型，要合法合规

精度比括号强转好一点，会四舍五入
bool类型可以转成数值类型，true对应1，false对应0

4.其它类型转string

拼接打印
变量.toString();

字符串拼接时自动会调用tostring

Console.WriteLine( "123123"+1 + true);

异常捕获

避免当代码报错时，造成程序卡死的情况

try——catch——finally

//必备部分
try
{
//希望进行异常捕获的代码块,放到try中
//如果try中的代码报错了,不会让程序卡死
}
catch//catch(Exception e)
{
//如果出错了会执行catch中的代码来捕获异常
//catch(Exception e)具体报错跟踪,通过e得到具体的错误
}
//可选部分
finally
{
//最后执行的代码,不管有没有出错都会执行其中的代码
}

代码基本结构中不需要加分号; 在里面写代码逻辑时每一句代码才加:

try
{
string str = Console.ReadLine();
int i = int.Parse(str);
console.writeLine(i);
}
catch
{
Console.WriteLine("请输入合法数字");
}

运算符

算数运算符

1.赋值符号

先看右侧再看左侧

把右侧的值赋值给左侧的变量

2.算数运算符

算数运算符，用于数值类型变量计算的运算符

返回结果是数值

用自己计算：先算右侧结果再赋值给左侧变量
连续运算：先算右侧结果再赋值给左侧变量
初始化时就运算：先算右侧结果再赋值给左侧变量

• 加+

• 减-

• 乘*

• 除/

默认的整数是int，除法运算会丢失小数点后的小数

用浮点数来存储除法结果，在运算时要有浮点数

• 取余%

3.算数运算符的 优先级

在混合运算时的运算顺序

乘除取余，优先级高于加减——先算乘除取余，后算加减

括号可以改变优先级，优先计算括号内内容——多组括号，先算最里层括号，依次往外算

4.算数运算符的 复合运算符

固定写法——

• +=

• -=

• *=

• /=

• %=

复合运算符：用于自己—自己进行运算

复合运算符只能进行一种，不能混合运算

5.算数运算符的 自增减1

a = a + 1;
a += 1;

• a++;//先用再加

• ++a;//先加再用

• a–;//先用再减

• –a;//先减再用

字符串拼接

1. 方法1

用加号+拼接

用复合运算符+=拼接（先看右边结果）

自动调用toString

string str = "";
str += "1"+4 + true;//14true
str += 1 +2 +3 + 4;//10 先计算右边
str += ""+ 1+ 2 + 3 + 4;//1234
str += 1 +2 +""+3 +4;//334
str += 1 +2 +""+（3 +4）;//37 括号改变运算顺序

2. 方法2

string . Format("待拼接的内容",内容1,内容2,......)

要被拼接的内容，用占位符替代，{数字}

数字:0~n 依次往后

自动调用toString

3. 控制台打印拼接

Console.WriteLine(“A{0}B{1}C{2}”，1，true，false);

Console.Write(“A{0}B{1}C{2}”，1，true，false);

可以多，不能少填

条件运算符

1. 条件运算符的基本应用

用于比较两个变量或常量

• 大于>

• 小于<

• 等于==

• 不等于!=

• 大于等于>=

• 小于等于<=

条件运算符一定存在左右两边的内容

左边内容 条件运算符 右边内容

比较的结果返回的是一个 bool类型的值，true和false

如果比较的条件满足那就返回true，不满足就返回false

=先算右边再赋值给左边

2. 各种应用写法

变量和变量比较

变量和数值(常量)比较

数值和数值比较

计算结果比较
//条件运算符的优先级低于算数运算符
//先计算再比较

3. 不能进行范围比较

判断是否在某两个值之间

1< a< 6//在C#都不能这样写

要判断一个变量是否在两个数之间，要结合逻辑运算符的知识点

4. 不同类型之间的比较

不同数值类型之间可以随意进行条件运算符比较

只要是数值就能够进行条件运算符比较，比较大于小于等于等等

特殊类型char string bool只能同类型进行==和!=比较

不仅可以和自己类型进行== !=还可以和数值类型进行比较还可以和字符类型进行大小比较

逻辑运算符

对bool类型进行逻辑运算

逻辑运算符优先级，低于 条件运算符，算术运算

1. 逻辑与

符号&& 并且
有假则假，同真为真

在没有括号的情况下从左到右

有括号先看括号内

2. 逻辑或

符号|| 或者
有真则真，同假为假

3. 逻辑非

符号!
取反，真变假，假变真

逻辑非的优先级较高

4. 混合使用 优先级问题

逻辑非！优先级最高

&&(逻辑与)优先级高于||(逻辑或)

逻辑运算符 优先级， 低于 算数运算符， 条件运算符（逻辑非除外）

5. 短路规则

逻辑或||有真则真

逻辑与&&有假则假

只要逻辑与或者逻辑或，左边满足了条件
右边的内容已经不重要，抛弃后面不去计算

位运算符

用数值类型进行计算

连接两个数值

将数值转换为2进制再进行

对位运算

位数不同 补0

1. 位与 &

有0则0

结果 小于等于最小数

2. 位或 │

有1则1

3. 异或 ^

相同为0 不同为1

4. 位取反 ～

写在数值前面

0变1，1变0

某个类型完整的二进制，补全，完全取反

如int32位，第一位符号位，1》负数，负数二进制》转码 补码

5. 左移<< 右移>>

数字 << 移动的位数

左移几位，右侧加几个0
右移几位，右侧去掉几个数

三目运算符

套路:3个空位2个符号

空位 ? 空位 : 空位;
bool类型 ? bool类型为真返回内容 : bool类型为假返回内容;

三目运算符会有返回值，这个返回值类型必须一致，并且必须使用!

第一个空位始终是结果为bool类型的表达式， bool变量，条件表达式，逻辑运算符表达式

第二三个空位什么表达式都可以，只要保证他们的结果类型是一致的

条件分支语句

if

满足条件时执行一些代码

if( bool类型值)
{
满足条件要执行的代码写在if代码块中;
}

1.if语句的语法部分，不需要写分号

2.if语句可以嵌套使用

if…else

产生两条分支，满足条件做什么，不满足条件做什么

if( bool类型值)
{
满足条件执行的代码;
}
else
{
不满足条件执行的代码;
}

if…else if. …else

产生n条分支，选择最先满足的一个条件，就做什么

if( bool类型值 )
{
满足条件执行的代码;
}
else if( bool类型值 )
{
满足条件执行的代码;
}
else
{
不满足条件执行的代码:
}

中间可以有n个else if语句代码块

else是可以省略的

条件判断从上到下，执行满足了第一个后，之后的都不会执行了

switch

switch(变量)
{
//变量==常量执行case和break之间的代码
case常量:
	满足条件执行的代码逻辑;
	break;
case常量:
	满足条件执行的代码逻辑;
	break;
//case可以有无数个
default:
	如果上面case的条件都不满足就会执行default中的代码;
	break;
}

常量1.必须初始化2.不能修改

只能写一个值，不能去写一个范围，不能写条件运算符，逻辑运算符

switch只判断变量是否等于某一个固定值

default可省略

可自定义常量const

满足某些条件时做的事情是一样的，可以使用贯穿

贯穿，不写case后面配对的break
满足break前其中一个条件就会执行之后的代码

循环语句

while

让顺序执行的代码，不停的循环执行某一代码块的内容
让代码可以被重复执行

bool类型，变量，条件运算符，逻辑运算符

while(bool类型的值)
{
//当满足条件时就会执行while语句块中的内容
//当代码逻辑执行完会回到while循环开头，再次进行条件判断
}

死循环
不停的执行循环中的逻辑
死循环只有在学习控制台程序时，会频繁使用

进入Unity过后基本不会使用死循环

1.可能因为内存问题造成程序崩溃闪退2.造成程序卡死

流程控制关键词

break:跳出循环

continue:回到循环开始，继续执行while(true)

break和continue和循环配合使用的，和if语句没关

do while

while循环是先判断条件再执行
do while循环是先斩后奏，先至少执行一次循环语句块中的逻辑，再判断是否继续do

do
{
//循环代码逻辑;
}while (bool类型的值);

while语句存在一个重要的分号

for

for(初始表达式	;	条件表达式	;	增量表达式){
//循环代码逻辑;
}

第一个空(初始表达式):一般声明一个临时变量，用来计数用

第二个空(条件表达式)︰表明进入循环的条件一个bool类型的结果 (bool变量，条件运算符，逻辑运算符，算术运算符)

第三个空(增量表达式):用第一个空中的变量进行自增减运算

第一次进入循环时，才会调用第一个空中的代码
每次进入循环之前，都会判断第二个空中的条件，满足才会进入循环逻辑
执行完循环语句块中的逻辑后，最后执行第三个空中的代码

每个空位规则

• 第一个空位：申明变量，可以连续申明——可以写在for前
• 第二个空位：进入条件，只要是bool结果的表达式都可以——不写可以写死循环
• 第三个空位：执行—次循环逻辑过后要做的事情——可以写在循环语句内

for循环可以准确得到一个范围中的所有数

项目补充

//输入一个键并赋值
char c = Console.ReadKey().KeyChar;
//输入一个键并赋值 且不在控制台显示
char c = Console.ReadKey(true).KeyChar;
//清除控制台
Console.Clear();
//设置光标位置 控制台左上角为0，0 右侧是x正方向 下方是y正方向
Console.SetCursorPosition(10,5);
//设置文字颜色
Console.ForegroundColor = ConsoleColor.Red;
//设置背景色 配合Clear使用 填充窗口颜色
Console.BackgroundColor = ConsoleColor.White;
Console.Clear();
//光标显隐
Console.CursorVisible = false;
//关闭控制台
Environment.Exit(0);

c#基础

复杂数据类型

复杂数据(变量)类型特点

1.数据集合
一般是多个数据（变量)集合在一起构成的数据

2.自定义
一般可以自己取名字，可以自定义的数据（变量)

枚举：整形常量的集合，可以自定义

数组：任意变量类型顺序存储的数据

结构体：任意变量的数据集合，可以自定义

枚举

被命名的整形常量的集合

—般用它来表示状态 类型等等

申明枚举，申明枚举变量，是两个概念
申明枚举：创建—个自定义的枚举类型
申明枚举变量：使用申明的自定义枚举类型，创建一个枚举变量

申明枚举
枚举名 以E或者E_开头

枚举中包裹的整形常量，第一个默认值是0，下面会依次累加1

可以自定义数值

自定义枚举项名字 = 100，

enum E_自定义枚举名
{
自定义枚举项名字，
自定义枚举项名字1,
自定义枚举项名字2,
}

1. namespace语句块中(常用)

2. class语句块中 struct语句块中

枚举不能在函数语句块中申明

申明枚举变量
自定义的枚举类型变量名 = 默认值;//自定义的枚举类型.枚举项

函数内

与switch配合使用

类型转换

1.枚举和int互转

• 枚举转int

int i = (int)playerType;

• int转枚举

playerType = 0;

2.枚举和string互转

• 枚举转string

string str = playerType. Tostring();

• string转枚举

Parse后第一个参数︰你要转为的是哪个枚举类型

第二个参数:用于转换的对应枚举项的字符串

转换完毕后是一个通用的类型，用括号强转成我们想要的目标枚举类型

playerType = (E_PlayerType) Enum.Parse( typeof(E_PlayerType), "other""):

作用

在游戏开发中，对象很多时候会有许多的状态

比如玩家动作状态——需要用一个变量或者标识来表示，当前玩家处于的是哪种状态

可能会使用int来表示他的状态，1行走2待机3跑步4跳跃……等等

枚举可以帮助我们清晰的分清楚状态的含义

数组

存储一组相同类型数据的集合

分为一维、多维、交错数组

一般情况，一维数组就简称为数组

一维数组

1数组的申明

变量类型，数组名，数组长度，数组内容

变量类型[] 数组名;

int[]arr1;

只是申明了一个数组，但是并没有开房

变量类型可以是所有变量类型

类型一致

变量类型[]数组名= new 变量类型 [数组的长度]

int[] arr3 = new int[5] ;//后面必须申明，初始化

arr1=new int[5];

变量类型[] 数组名= new 变量类型 [数组的长度] {内容1,内容2,内容3,.......;

int[] arr3 = new int[5] {1,2,3,4,5 };

变量类型[] 数组名= new 变量类型[] {内容1,内容2,内容3,.......);
int[] anr4 = new int[] {1,2,3,4,5,6,7,8,9};

后面的内容就决定了数组的长度 “房间数""
5.

变量类型[] 数组名= {内容1,内容2,内容3,.......];
int[] arr5 = {1,3,4,5,6};

2数组的使用

1.数组的长度
数组变量名.Length
array. Length

2.获取数组中的元素
数组的下标和索引，从0开始的
不能越界 范围 0~（length-1）

array[0]

3.修改数组中的元素

类型不能变

4.遍历数组

for 循环

下标自增 0 ~ array. Length

for (int i =0; i < array . Length; i++)
{
	Console.WriteLine(array[i]);
}

5.增加数组的元素

数组初始化以后是不能够直接添加新的元素

搬家——使用新的数组，再改变原来数组的指向

int[]array2 = new int[6];
for (int i = 0; i < array.Length; i++)//遍历搬家
{
	array2[i]= array[i];
}
array = array2;//原数组指向新数组空间（原空间自动销毁）
//原数组和新数组 都指向 新数组空间
array[5] = 999;//增加新元素

6.删除数组的元素

数组初始化以后，不能够直接删除元素的

搬家

int[]array3 = new int[5];
for (int i = 0; i < array3.Length; i++)
{
	array3[i] = array[i];
}
array = array3;

7.查找数组中的元素

遍历，才能确定数组中是否存储了一个目标元素

int a = 3;
for (int i = 0; i < array. Length; i++)
{
	if( a == array[i] )
	{
		Console.WriteLine(""和a相等的元素在{0}系引位置"，i);
		break;
	}
}

二维数组

使用两个下标(索引引)来确定元素的数组

行标和列标——矩阵

控制台小游戏》地图格子

1数组的申明

变量类型[,] 二维数组变量名;
int[,]arr;

申明过后，初始化
2.

变量类型[,] 二维数组变量名= new 变量类型 [行,列];

int[,]arr2 = new int[3,3];
3.

变量类型[,〕 二维数组变量名= new 变量类型 [行,列] { {0行内容1，0行内容2......},{1行内容1，1行内容2......}};

int[,]arr3 = new int[3,3]{

{ 1,2,3 },
{ 4,5,6},
{ 7,8,9}};

变量类型[,] 二维数组变量名= new 变量类型 [,] { {0行内容1，0行内容2......},{1行内容1，1行内容2.....}};

int[,]arr4 = new int[,]{

{ 1,2,3 },
{ 4,5,6},
{ 7,8,9}};

变量类型[,] 二维数组变量名= { {0行内容1，0行内容2.......},{1行内容1，1行内容2.....}};

int[, ]arr5 = {

{ 1,2,3 },
{ 4,5,6},
{ 7,8,9}};

2数组的使用

1.二维数组的长度
行数 array.GetLength(0)

列数 array. GetLength(1)

2.获取二维数组中的元素

第一个元素的索引是0，最后一个元素的索引是长度-1

array[行索引,列索引]

3.修改二维数组中的元素
array[0，0] = 99;

4.遍历二维数组

嵌套循环

for (int i = 0; i < array. GetLength(0); i++)
{
	for (int j = 0;j < array.GetLength(1); j++)
	{
		Console.WriteLine(array[i.j]);
	}
}

5.增加数组的元素
数组声明初始化过后，不能再原有的基础上进行添加或者删除

增加一行 或者一列

搬家——使用新的数组，再改变原来数组的指向

int[,]array2 = new int[3，3];
for (int i = 0; i < array.GetLength(0); i++)
{
	for (int j = 0; j < array. GetLength(1); j++)
    {
		array2[i，j]= array[i，j];
	}
}
array = array2;

array[2，0]= 7;
array[2，1] = 8;
array[2，2]= 9;

6.删除数组的元素

数组初始化以后，不能够直接删除元素的

搬家

7.查找数组中的元素

遍历，才能确定数组中是否存储了一个目标元素

交错数组

交错数组是数组的数组，每个维度的数量可以不同
二维数组的每行的列数相同，交错数组每行的列数可能不同

1数组的申明

变量类型[][] 交错数组名;

int [][] arr1;
2.

娈量类型[][] 交错数组名= new 变量类型 [行数][];

int[][] arr2 = new int[3][];[][]

娈量类型[][] 交错数组名= new 变量类型 [行数][] {一维数组1，一维数组2,........ };

int [][] arr3 = new int[3][0] {

new int[]{1,2,3},
new int[] {1,2 },

new int[] { 1}};
4.

变量类型[][] 交错数组名= new 变量类型 [][] {一维数组1，一维数组2,........ };

int [][] arr3 = new int[][0] {

new int[]{1,2,3},
new int[] {1,2 },

new int[] { 1}};

变量类型[][] 交错数组名= {一维数组1，一维数组2,........ };

int [][] arr5 ={

new int[]{1,2,3},
new int[] {1,2 },

new int[] { 1}};

2数组的使用

1.数组的长度

行 array. GetLength(0)

得到某一行的列数 array[0].Length

2.获取交错数组中的元素
不要越界
array[0][1]

3.修改交错数组中的元素
array[0][1] = 99;

4.遍历交错数组

for (int i = 0; i < array.GetLength(0); i++)
{
	for (int j = 0; j < array[i].Length; j++)
	{
		Console.write(array[i][j]+”“);
	}
	Console.writeLine();
}

5.增加交错数组的元素

6.删除交错数组的元素

7.查找交错数组中的元素

与一维数组，二维数组类似

值类型和引用类型

引用类型：string，数组(—维、二维、交错)，类
值类型：无符号整形，有符号整形，浮点数，char ，bool ，结构体

• 赋值区别：

值类型 把内容拷贝给了对方，它变我不变

引用类型 让两者指向同一个值，它变我也变

• 存储区别：

值类型和引用类型 存储的内存区域是不同的，存储方式是不同的

值类型 栈空间—— 系统分配，自动回收，小而快

引用类型 堆空间—— 手动申请和释放，大而慢；；；；栈空间 存储 引用类型在堆空间中 的地址

• 特殊的引用类型 string：它变我不变

重新赋值时，会在堆空间中 重新分配空间，栈空间存的地址 指向 新的堆空间地址

频繁的改变string重新赋值，会产生内存垃圾

函数

函数基础

函数(方法)

本质 一块具有名称的代码块

可以使用函数(方法)的名称，来执行该代码块

函数(方法)是，封装代码，进行重复使用 的一种机制

函数(方法)的主要作用

1.封装代码

2.提升代码复用率(少写点代码)

3.抽象行为

函数写在

1.class语句块中

2.struct语句块中

函数定义基础

static 	返回类型	函数名		(参数类型参数名,参数类型参数名2,.......)
{
	函数的代码逻辑;
	return 返回值;(如果有返回类型才返回)
}

1. static 不是必须的

2. 返回类型

   • 关键字void(表示没有返回值)
   • 任意的变量类型14种变量类型＋复杂数据类型（数组、枚举、结构体、类class)

3. 函数名，帕斯卡命名法//MyName(帕斯卡命名法)

4. 参数

   • 不是必须的，可以有0~n个参数

   • 参数的类型可以是任意类型14种变量类型＋复杂数据类型(数组、枚举、结构体、类class)

   • 多个参数，用逗号隔开

   • 参数名 驼峰命名法 //myName(驼峰命名法)

5. 返回值