12.unity编程基础
目录
编程入门
一：语法基础
1-1.VS的使用
1-2.程序编写规范
1-3.数据类型（共15种）
1-4.常量和变量
1-5.表达式和运算符
二：控制语句
2-1.顺序结构
2-2.选择语句
2-3.循环语句
三：数组和方法
3-1.数组
3-2.方法
编程基础
一：面向对象基础
1-1.补：面向对象简介
1-2.抽象
1-3.访问修饰符
1-4.封装
1-5.继承
1-6.多态
二：附加修饰符
2-1.Static
三：接口和索引器
3-1.接口
3-2.索引器
编程进阶
一：字符串处理
1-1.字符串创建
二：枚举和结构体
2-1.枚举
2-2.结构体
三：数据结构
3-1.数据结构简介
3-2.Array（数组）
3-2.Arraylist
12.unity编程基础
编程入门
一：语法基础
1-1.VS的使用
创建C#脚本
- （Unity中-右键-即可创建）
脚本内容简介
using System.Collections;
using System.Collections.Generic;
using UnityEngine; //（命名空间）（1.引用本文件没有的内容：类库文件或其他程序文件）
/** //（这是多行注释）
* XXX
* XXX
*/
public class a : MonoBehaviour //（2.类：继承）（方法之家）（这里类的名称要与外面的名称相同）
{
// Start is called before the first frame update
void Start() //（3.方法：在方法里面写指令）
{
}
// Update is called once per frame
void Update()
{
return; //（返回）
}
}
代码简介
- （如果出现红线-则表示脚本出错了）
基本语法
- 1.（区分大小写：A 和 a 是不一样的）
- 2.（代码结尾必须有分号 ;）
- 2.（注释：是对代码进行说明）-（注释就是随意些文字-且不会运行这部分）
- （单行注释“//”）-（常用这个）
- （多行注释“/****/”）-（这个上面有实例）-（一般放在开头-注释一些个人信息）
- （自动注释“///”）-（一般放在方法上面-对方法进行注释）
项目结构
- 解决方案（solution）：项目之家
- 项目 （project） ：程序文件之家
- 程序文件（.cs） ：命名空间之家
- 命名空间（namespace）：类之家
- 类 （class） ：方法之家
- 主方法 （Main） ：语句之家 （一个项目只能有一个Main方法）
代码结构
1-2.程序编写规范
1.命名规则
- 1.以（字母 、 _ 、 @）开头，后面随意
- 2.不要与系统中的关键字重复
- 3.注意大小写
- 4.同一区域不可同名
2.命名规范
- 1.命名尽量有意义
- 2.命名方式：（变量命名：首字母小写、后续单词的首字母大写、eg：myCube）
- （方法命名：所有单词首字母大写、eg：MyCube）
- 3.编程规范：
- 命名空间、类、方法 -所有单词首字母大写、eg：MyCube
- 局部变量 -首字母小写、后续单词的首字母大写、eg：myCube
- 代码结尾必须有分号 ;
- 建议：一个指令语句放一行
- 必须为英文输入法
1-3.数据类型（共15种）
补充（控制台）-（用来打出代码）
补：注释方法-区域注释（可以 展开/收起 的一种注释方法） （作用：方便整理）
void Start()
{
#region AAA //（这是展开的样子）-（AAA：自己输入名称）
Debug.Log(111); //（在中间区域输入代码语句）
#endregion //（当收起来后便只剩下名称：AAA）
}1.基本类型
- 1.整数（常用 int） //（值类型-8个整数）
public class a : MonoBehaviour
{
//（值类型-8个整数）
public sbyte my1; //（8位有符号的整数） （取值范围-共255个字符：-128～+127）-（位数越多取值范围越多）
public short my2; //（16位有符号的整数）（取值范围-共XXX个字符：-32768～+32767）
public int my3; //（32位有符号的整数）（取值范围-很大）-（常用这个）
public long my4; //（64位有符号的整数）（取值范围-非常大）
public byte my5; //（8位无符号的整数） -（注：无符号就是指没有负数）
public ushort my6; //（16位无符号的整数）-（注：无符号就是指没有负数）
public uint my7; //（32位无符号的整数）-（注：无符号就是指没有负数）
public ulong my8; //（64位无符号的整数）-（注：无符号就是指没有负数）- 2.浮点小数（常用float） （不精确的小数）（就是无限趋近于一个小数、但永远没有精确的值）
void Start()
{
//（以下是声明的局部变量）
double d1 = 0.012345678912345d; //（双精度小数）（可显示到小数点后的15位）（注：在结尾加 D/d）
float f1 = 0.0123456f; //（单精度小数）（可显示到小数点后的7位） （注：在结尾加 F/f）-（常用这个）
}- 3.精确小数 （注：货币运算时会用到精确小数）
void Start()
{
//（以下是声明的局部变量）
decimal d2 = 0.123456789m; //（精确小数）-（可显示到小数点后28未）（注：在结尾加 M/m）
}- 4.字符-单个 / 字符串-多个字符（常用 string）
void Start()
{
//（以下是声明的局部变量）
char c1 = 'A'; //（单个字符）-（字母、数字、汉字、特殊符号等都可以）（但只是一个字符）
string s1 = "AAAA"; //（字符串-多个字符）（string/String 都可以）
}- 5.布尔 （bool）
//（以下是声明的局部变量）
bool b1 = true; //（bool布尔）-（true 真 / false 假）
b1 = false;1-4.常量和变量
补：声明变量的步骤
- 步骤：声明变量 → 赋值 → 使用
1.常量和变量
- 变量：运行时可以改变的量
void Start()
{
//（以下是声明的局部变量）
int i1 = 18;
i1 = 19;
}- 常量：运行期间保持不变的量
void Start()
{
//（以下是声明的局部变量）
const int i2 = 18; //（在类型前加个“const”可以将变量变为常量）-（常量是不可以改变的）
i2 = 19; //（会报错-这是句错误的语句）-（常量无法修改）
}- 用户交互（eg：按下键盘按键）
void Update()
{
//（以下是声明的局部变量）
bool b2 = Input.GetKeyDown(KeyCode.Space); //（当按下空格时-就会返回 true）
}类型转换-
- 可兼容类型的转换（eg：数字类型之间的转换）
- （隐式转换：某些类型会直接自动转换） （强制转换/显式转换：需要添加转换语句-数据有可能损失）
void Update()
{
//（以下是声明的局部变量）
int i1 = 1;
float f1 = 1.123f;
//隐式转换：某些类型会直接自动转换
f1 = i1; //（整数-可自动转换为小数）-（因为小数包括了整数）
//强制转换/显式转换：需要添加转换语句-数据有可能损失（需在前面加上(要转换成的类型)）
i1 = (int)f1; //（小数-强制转换为了整数）-（但会损失小数点后面的部分）
}- 不可兼容类型的转换（eg：数字类型 与 字符类型 之间的转换） （ 类型.Parse(XXX) ）
void Update()
{
//（以下是声明的局部变量）
string myString = "AAA";
int.Parse(myString); //（eg：强制将字符类型-转换为了整数类型）
int myInt = 1;
myString = myInt.ToString(); //（方法二：eg：将整数类型-强制转换为字符类型）
}1-5.表达式和运算符
1.表达式和运算符
- 运算符
void Update()
{
//（以下是声明的局部变量）
int myInt1 = 1;
int myInt2 = 2;
//（以下是基础赋值运算符）
myInt1 = myInt2; //（直接赋值）
myInt1 = myInt1 + myInt2; //（这和下面的方法是相同的）
myInt1 += myInt2; //（加法）（这种是简化的写法-节省空间）
myInt1 = myInt1 - myInt2; //（这和下面的方法是相同的）
myInt1 -= myInt2; //（减法）
myInt1 *= myInt2; //（乘法）
myInt1 /= myInt2; //（除法）
myInt1 %= myInt2; //（横赋值）（好像是求余数）（eg：11/3=3 -- 余数2）
//（自增减运算符）
myInt1++; //（就是 myInt1 = myInt1 + 1;）（简化的写法比较节省空间）
myInt1--; //（就是 myInt1 = myInt1 - 1;）
Debug.Log(myInt1++); //（如果符号在后 - 就是先整体运算再自运算）（打出 1）
Debug.Log(++myInt1); //（如果符号在前 - 就是先自运算再整体运算）（打出 2）
//（算数运算符）
myInt1 = myInt1 + myInt2; //（加）
myInt1 = myInt1 - myInt2; //（减）
myInt1 = myInt1 * myInt2; //（乘）
myInt1 = myInt1 / myInt2; //（数除）（注：整数除 与 浮点数除 都是这个符号）
myInt1 = myInt1 % myInt2; //（取横）（就是求余数）
//（逻辑运算符）
if(myInt1 == 1 && myInt2 == 2) //（与）
if (myInt1 == 1 || myInt2 == 2) //（或）
if (!(myInt1 == 1)) //（非）
//（关系运算符）
if (myInt1 == 1) //（等于）
if (myInt1 != 1) //（不等）
if (myInt1 > 1) //（大于）
if (myInt1 < 1) //（小于）
if (myInt1 >= 1) //（大于等于）
if (myInt1 <= 1) //（小于等于）
//（位运算符）-（针对二进制的每一位bit进行操作）-（先跳过这个）
//（三元运算符/三目运算符：取值运算“ ?: ”）-（会返回一个值或数值等）
myInt1 = myInt1 > myInt2 ? myInt1 : myInt2; //（如果?问号左侧的条件为真、则返回:冒号左侧、否则返回:冒号右侧）
}2.运算符的优先级（只需记住加（）括号优先即可）
- 1.一元运算符： [] . () (方法调用)
- ！ ~ ++ -- + - new () (强制类型转换)
- 2.算数运算符： * / % + -
- 3.关系运算符： < <= > >= == !=
- 4.逻辑运算符： && ||
- 5.赋值运算符： ==
- += -= *= /= %=
二：控制语句
2-1.顺序结构
（按顺序从上往下执行）
2-2.选择语句
1.单分支（if）
public int myInt1;
void Update()
{
if (myInt1 == 1) //（当条件为真时-会执行下面的语句块、否则跳过-不执行）（可嵌套多个if）
{
//（把要执行的语句写这里）
}
}2.双分支（if - else）
public int myInt1;
void Update()
{
if (myInt1 == 1) //（当条件为真时-会执行下面的语句块）（可嵌套多个if）
{
}
else //（否则执行这部分的语句块）
{
}
}3.多分支（if - else if）
public int myInt1;
void Update()
{
if (myInt1 == 1) //（如果XXX）
{
}
else if (myInt1 == 2) //（否则如果XXX）（可添加多个否则如果）
{
}
else if (myInt1 == 2) //（否则如果XXX）（可添加多个否则如果）
{
}
else //（否则）（上面都不成立时就会执行这个）
{
}
}4.switch case 等值对比分支
void Update()
{
int myInt1 = 1; //（申明局部变量）
switch (myInt1) //（这个括号里放 变量 / 表达式）（注：括号里为：整型、char、布尔、string、枚举）
{
case 10: //（如果 myInt1 = 10 成立）（注：不能有相同的 case、 且必须对应上面条件的类型）
Debug.Log(10); //（就执行这部分语句块）
break; //（结束 switch 语句）
case 100: //
Debug.Log(100); //
break; //
default: //（如果上面的都不成立）
Debug.Log(1); //（就执行这部分语句块）
break; //（结束 switch 语句）
}
}2-3.循环语句
1.do - while 循环语句
void Update()
{
int myInt1 = 1; //（申明局部变量）
do //（不管条件是否成立-都会首先执行一次 do 下面的语句块）
{
myInt1++;
Debug.Log(myInt1); //（注：语句块一定要与下面的条件相关-否则会进入死循环）
} while (myInt1 < 10); //（直到条件不成立-才停止循环）
Debug.Log(myInt1);
}2.while
void Update()
{
int myInt1 = 1; //（申明局部变量）
while (myInt1 < 10) //（首先会判断条件是否成立）
{
myInt1++; //（只要条件成立-就会循环语句块）
} //（直到条件不成立-才停止循环）
Debug.Log(111);
}3.for 函数
- ┏→ ━━━━━→ ━━━━→ ┓
- ①申明变量并赋值→②循环条件←③变量自加←④要循环的函数
for (int i = 0; i < 100; i++) { this.transform.Translate(.1f, 0f, 0f); }
（若 ②循环条件返回ture-则执行一次后面的函数、直到返回false-结束循环）
4.中断循环
void Update()
{
int myInt1 = 1; //（申明局部变量）
while (myInt1 < 10) //（首先会判断条件是否成立）
{
myInt1++; //（只要条件成立-就会循环语句块）
break; //退出当前的循环
continue; //立即执行下一次的循环
} //（直到条件不成立-才停止循环）
Debug.Log(111);
}三：数组和方法
3-1.数组
1.引例
2.存储格式
- 数组是储存相同类型元素的固定大小的顺序集合
- 数组是通过索引来访问的、从0开始
3.数组申明（数据类型 [ ] 数组名）
void Update()
{
int[] myInts; //（声明数组）
string[] myStrs; //
bool[] mybools; //
//数组初始化/赋值（1.给空间大小赋值 2.给内容赋值）
myInts = new int[3] { 1, 2, 3 }; //（注：空间大小是3个 - 后面的内容也必须是3个）
myStrs = new string[] { "a", "b", "c" }; //（方法2：先不必给空间大小赋值 - 可根据后面内容的个数自动算出大小）
float[] myFloats = { 1f, 2f, 3f }; //（方法3：当申明 和 赋值 在同一步完成时-不用new、直接写内容即可）
//数组的默认值（当不给数组内容赋值的时候-他也是有默认值的）
Debug.Log(myInts[0]); //（当没有给该数组的内容赋值时）-（会打出 0 ）（所以数字型的数组默认值为0）
//（布尔类型的数组 - 默认值为 false）
//（字符类型的数组 - 默认值为 /0 ）（/0 就是什么都不显示）
//（字符串类型的数组 - 默认值为 null ）（null 表示无）
}4.访问数组
- 通过索引值来访问数组（索引从 0 开始）
5.操纵数组
6.练习
3-2.方法
1.方法概述
2.定义方法
- 开头大写
public void Aaa(int a, int b, int c) //（申明方法 Aaa）（开头大写）（括号可放参数、 或不输入）
{ //（入括号中放入参数的话 - 调用方法时 - 也必须输入参数）
}3.使用方法
void Update()
{
Aaa(1, 2, 3); //（调用方法）（括号中输入对应的参数）
}- 参数数组 （申明方法时-括号中可写入数组）
//（申明一个方法）-（括号中 写上 数组） (注：当括号中写多个参数时、参数数组必须放到后面)
public void Aaa(params string[] myStrs) //（注：数组前要加个前缀 params）-（这样才可以调用方法时不出错）
{
return;
}调用这个方法时
void Update()
{
//（当调用这个方法时）
Aaa(); //（括号中可不输入）
Aaa("a"); //（括号中可输入1个值）
Aaa("a", "b"); //（括号中可输入多个值）
Aaa(new string[] { "a", "b" }); //（括号中可输入给数组赋值）赋值方法上面you
}- 值类型和引用类型 （存储位置不同）（栈比堆的速度要快-因为是直接调用的）（）
| 栈内存 （值类型存在于这里） Int a = 1； Int b = 2； int[] myInts = { 1, 2, 3 }; →→→ |
堆内存：程序管理的内存（需要从栈出发）-（其实就是栈内存的二级菜单）
|
- ref 和 out
（ref 和 out 传递的都是地址而不是值）
void Start()
{
int[] aaas = new int[2];
Aaa(ref aaas ); //（括号里 ref / out）
Debug.Log(aaas.Length); //（如果不加 ref 会打出2、因为无法传递出方法内部的信息）
} //（如果加了 ref 会打出10、因为可以传递出方法内部的信息）
public void Aaa(ref int[] aaas ) //（括号里 ref / out）
{
aaas = new int[10];
}
编程基础
一：面向对象基础
1-1.补：面向对象简介
1.面向对象编程简称 OOP
- 面试答案：（封装、继承、多态、即为面向对象）
2.面向对象的方法包括：
- 面向对象的分析（OOA）
- 面向对象的设计（OOD）
- 面向对象的程序设计（OOP）
3.面向对象技术主要围绕以下几个概念：
- 对象、抽象数据类型、类、继承性、多态性
4.面向对象 VS 面向过程：相辅相成
- 面向过程：先有算法，后有结构
- 面向对象：先有结构，后有算法
5.面向对象的优点
- 可重用性（类）
- 可扩展性（继承）
- 可管理性（接口）
6.OPP的4个机制
- 抽象
- 封装
- 继承与派生
- 多态性
1-2.抽象
1.抽象出 类（数据类型）
- 类（class）的定义：（类是程序的基本单元）
- [访问修饰符] [修饰符] class 类名 [:<基类名>] [,<接口列表>]
- {
- 构造方法;
- 析构方法;
- [<访问控制符>] [<修饰符>] 数据类型 <变量名>;
- [<访问控制符>] [<修饰符>] 数据类型 <属性名>;
- ...
- [<访问控制符>] [<修饰符>] <返回值类型> <方法名> ([参数列表]);
- }
public class a : MonoBehaviour //（从unity中创建的脚本、会自动生成一个类）
{
//（在里面可声明变量 / 申明方法）- this 的用法（this就是当前挂脚本的物体） （一般省略this）
1-3.访问修饰符
1.访问修饰符
- public //（公共成员，完全公开，没有访问限制）
- private //（私有成员，在类的内部才可以访问）
- internal //（当前程序集内可以访问）
- protected //（保护成员，该类内部和继承类中可以访问）
- internal protected //（就是上面两个的结合）
2.（注：类(class)只能用public 和 internal 来修饰）
- （方法、变量 等可以用以上5个来修饰）
- （如果没有写访问修饰符）-（类(class) 和 结构(struct) 的访问修饰符默认为 internal）
- （类里面的 变量、方法 的访问修饰符默认为 private）
3.补充：变量与方法是类的下级．（通过类来访问变量与方法）
1-4.封装
1.封装
- 含义：将字段（数据成员） 和行为（代码成员） 相结合的一种机制
- 目的：1.控制对象状态的范围
- 2.加强对象自身的内联（联动）性
- 3.增强对象使用的安全性
- 基本要求：1.特定边界：所有的内部变化都限制在此边界内（类定义的{}）
- 2.特定访问权限：在对象外部不能访问或修改受保护的内部实现细节（private成员）
- 3.有外部接口（方法）：此对象利用它与其他对象发生关联（Public成员）
//（新建脚本A）（A也是一个类class）-（A就是封装）
public class a : MonoBehaviour //（类class）-（类里面是 变量 和 方法）
{
public int myInt; //（申明变量）
public int Ddd() //（申明方法）-（int类型）
{
return myInt; //（返回 XXX）-（return 后面可写任何类型、也可不写）
this.myInt = 1000; //（this 表当前类、即当前脚本）-（通过this访问到当前脚本/类中的 变量和方法）
}
public void Eee() //（申明方法）
{
this.myInt = 500;
}//（新建脚本B）（B也是一个类class）-（通过B访问到A类(class)中的 变量 和 方法）
public class b : MonoBehaviour //（类class）-（类里面是 变量 和 方法）
{
a A = new a(); //（首先：这样可获取到上面那个类、即脚本A）
// Start is called before the first frame update
void Start()
{
A.myInt = 1000; //（可以给脚本A中的变量赋值）（注：是Public公开变量才可以访问到）
Debug.Log(A.Ddd()); //（可以访问到脚本A中的方法） (会打出1000)
A.Eee(); //（可以调用脚本A中的方法）
Debug.Log(A.myInt); //（可以访问到脚本A中的变量） (会打出500)
}2属性封装（就是封装变量） //（不太会）
- 属性的定义：属性代表了 Set 个 Get 方法
- [访问修饰符 eg：public] [new | virtual | verride ] 属性类型 属性名
- {
- get
- {
- //取值：返回属性对应的字段的值
- }
- Set
- {
- //赋值：设定属性对应的字段的值、参数值由隐参value接收
- //（自动执行：value = 传入的参数值）
- }
- }
- 属性的作用：快速封装字段
- 属性分类：读写（set + get）、只读（get）、只写（set）
- 使用属性：对象引用.属性 = 属性值：自动调用get方法
- 对象引用.属性：自动调用get方法
private int myInt; //（申明变量）-（选中这一段--右键--快速操作和重构--封装字段）-（就会自动展开下面的部分）
public int MyInt { get => myInt; set => myInt = value; } //（这部分就是自动展开的）（属性封装：get取值、set赋值）1-5.继承
1.继承
- 继承的概念：继承是由已有的类-创建新的类的机制
- 由继承得到的类-称为子类（派生类）
- 被继承的类-称为父类（超类）（基类）
- 继承的作用：实现软件可重用的重要方式
- 增强软件的可扩充性
- 提高软件的可维护性
- 申明继承：[<修饰符>] class <子类名> ： （extends） <基类名>
- 可继承的内容：变量、方法、析构、等（注：私有XX是不可继承的）
public class a : MonoBehaviour //（脚本/类class ：A）
{
public string myStr; //（申明变量）
public int myInt; //（申明变量）//（以下是脚本/类class ：B）-（当B继承A后 - 在B中即可直接访问A 的变量和方法）
public class b : a //（脚本/类class ：B）-（：继承A）
{
// Start is called before the first frame update
void Start()
{
myInt = 1000; //（当B继承A后 - 在B中即可直接访问A 的变量和方法）
myStr = "AAA"; //
}2.is 和 as
- is： 作用：用来检测对象引用是否某个类型或其父类型 返回值：true/false
- as 作用：尝试转换对象引用为具体类型的引用 返回值：对象引用/null
Is
public class A : MonoBehaviour //（脚本/类class ：A）
{
public int myInt; //（申明变量）
void Start()
{
bool mybool = myInt is A; //（如果变量myInt属于类A）-（则返回true）-（否则返回false）
}
}
as
public class A : MonoBehaviour //（脚本/类class ：A）
{
public GameObject myGame; //（申明变量）
void Start()
{
A p = myGame as A; //（这段有报错-不会改）（尝试将变量 放入 类中）-（失败则返回null）
}1-6.多态
1.多态
- 类的多态表现为-方法的多态：重载 和 覆盖
//重载（同一个类中、方法同名、参数不同(参数的个数、类型、次序不同)）
public void Ddd() //（申明方法 Ddd）
{
}
public void Ddd(int time) //（申明方法 Ddd）
{
}
public void Ddd(string str) //（申明方法 Ddd）
{
}//覆盖（子类中的方法覆盖父类中的方法）
public class a : MonoBehaviour //（脚本/类class ：A）
{
public virtual void Ddd() //（申明方法 Ddd）（注：使用 virtual 修饰）
{
}
//（以下是脚本b）
public class b : a //（脚本/类class ：B）-（使B继承A）-（B就是子类、 A就是父类）
{
public override void Ddd() //（申明方法 Ddd）（注：使用 override 修饰）
{ //（这个子类中的方法即可覆盖父类中的方法）
}二：附加修饰符
2-1.Static
补.（static静态）（当给 类、变量、方法等 - 加上 static 后 - 就会变成静态的XXX）
1.静态成员、类成员： 类成员由static关键字修饰
- 特点：可以在未创建类的对象前就用类名直接调用类成员 （多个对象共用同一个变量）
三：接口和索引器
3-1.接口
1.接口的定义
- 格式：[访问修饰符] interface 接口名
- {
- 返回值类型 方法名([参数列表])；（只有申明而无方法体）
- }
- 或：（多继承模式）（C#默认只能继承一个父类、 使用接口可实现继承多个类）
- [访问修饰符] interface 派生的接口名 ：父接口名列表
- {
- 返回值类型 方法名([参数列表])；（只有申明而无方法体）
- }
-（注：接口中申明的方法都是默认public的、 不能自定义访问级别）
//（以下是脚本A） （这一步主要是将要变化的值封起来）
//（interface接口 与 class类 同级别）
public interface IC //（申明接口）-（interface接口 与 class类 同级别）-（可直接将class改为interface但有点问题、所以重新写接口）
{
void XXX(int myInt); //1.（申明方法）（接口内部直接写方法名 与 参数 即可）-（不能写访问修饰符 和 修饰符）
}
public interface D //（申明接口）
{
}
public interface E //（申明接口）
{
}//（以下是脚本B） （这一步主要是上面那个值怎样运算）
public interface A : IC, D, E //（实现接口A-继承了多个interface接口）
{
}//（以下是脚本C）
public class c : MonoBehaviour, IC, D, E //（实现类C-继承了多个interface接口）-（而之前类C只能继承一个父类）
//2.（使用接口时-首先要展开接口）-（选中其中的一个接口IC--右键--快速操作和重构--实现接口）-（即可展开下面的）
{
public int Hp = 100; //（申明变量）
public void XXX(int myInt) //3.（这就是展开的接口）-（即打开了接口C中的方法）
{
throw new System.NotImplementedException(); //（这句话是自带的好像是防止报错的 - 可删除）
Hp = Hp - myInt;
Debug.Log("受到随机伤害，扣除" + myInt + "健康值！");
if (Hp <= 0)
{
Debug.Log("销毁物体");
}
}//（以下是脚本D） （这一步主要是怎样给上面那个值-赋值）
public class d : MonoBehaviour
{
void Update()
{
if (Input.GetMouseButtonUp(0)) //（如果鼠标左键弹起-调用一次）
{
int hp = Random.Range(0, 50); //（返回的是0-50的一个随机数）
IC imyInt = GetComponent(); //（这样即可获取到接口IC）
imyInt.XXX(hp); //（这样给接口IC中的参数赋值）
}
}
} //（运行脚本-单击鼠标左键-就会打出下面的字符）
（注：接口 与 类 的继承都是可嵌套的）-（eg：B继承A、C又继承B、那么C实际上是继承了B和A）
3-2.索引器
1.索引器（就是数组的“[ ]”）
- [访问修饰符] 返回值类型this [任意数据类型index] {set{} get{}}
- 实质：方法的变异品种
- 作用：访问方法从对象.方法名（参数） => 对象[参数]
- 自定义索引器 VS 数组索引器：
- 索引器的索引值（Index）类型不受限制
- 索引器允许重载
- 索引器不是一个变量
- 索引器 VS 属性
- 属性以名称来标识，索引器以函数形式标识
- 索引器可以被重载，属性不可以
- 索引器不能声明为static，属性可以
编程进阶
一：字符串处理
1-1.字符串创建
1.字符串创建
using System; //（命名空间）
public class a : MonoBehaviour
{
//直接赋值（常用这个）
static string s1 = "1234";
//构造（必须是静态变量）
public static char[] chs = { '1', '2', '3', '4' }; //申明静态变量-单个字符 数组
String s2_1 = new string(chs); //这样也是返回：1234
//构造2（必须是静态变量）
static char ch = 'a'; //申明变量-单个字符
String s2_2 = new string(ch, 20); //这样是返回：20个a
//复制（必须是静态变量）
String s3 = string.Copy(s1); //（复制到了s1的内容）
//克隆（必须是静态变量）
String s4 = s1.Clone() as string; //（克隆到了s1的地址）（所以s4 与 s1 全等）
//对字符串进行插入处理
String s5 = s1.Insert(0, "abc"); //（括号中是：位置,要插入的字符）（0：表开头）（那么返回的是：abc1234）二：枚举和结构体
2-1.枚举
1.枚举
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//（以下是脚本A）（也可放到一个脚本里）
enum Gender //（申明枚举）（enum枚举 与 class类 同级）（把 calss 改为 enum 即可）（枚举本身的修饰符只能用 public 和 internal）
{ //（枚举本身可以有修饰符、 但枚举的内容始终是公共的）
男 = 1, 女, 中性 //（枚举的内容默认为 int 类型）（可赋值、也可不赋值）
}
//（以下还是脚本A）
class Student //（类）
{
public Gender gender; //（申明变量-枚举）-（这样可获取到上面那个枚举）
}//（以下是脚本B）
public class b : MonoBehaviour
{
Student s = new Student(); //（这样即可获取到上面那个类）
void Start()
{
s.gender = Gender.中性; // 给枚举赋值
Debug.Log(s.gender); //（这个会打出中性）
}- 枚举（进阶使用）
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//（以下是脚本A）
enum Gender : int //（申明枚举）（即可加上整数参数的类型：默认就是 int）
{
男, 女, 中性 //（可赋值、也可不赋值）（不可有一样的内容：eg只能有一个男）
}
//（以下还是脚本A）
class Student //（类）
{
public Gender gender; //（申明变量-枚举）-（这样可获取到上面那个枚举）
//（枚举 与 swith循环 的结合）-（天生的组合）
public void XXXX() //（申明方法）
{
switch (gender) //（eg：如果 gender = 男、就执行对应的部分）（这里按回车后-应该能自动展开、但失败了）
{
case Gender.男:
Debug.Log("1111");
break;
case Gender.女:
Debug.Log("2222");
break;
case Gender.中性:
Debug.Log("3333");
break;
default:
break;
}
}
}
//（以下是脚本B）（把这个挂到物体即可）
public class b : MonoBehaviour
{
Student s = new Student(); //（这样即可获取到上面那个类）
void Start()
{
s.gender = Gender.男; //（给 gender 赋值）
s.XXXX(); //调用方法
}- 内部枚举（可在 类 里面-申明枚举）
2-2.结构体
1.结构体是值类型（与类同级）（结构体不能被继承）（类是引用类型 ）
//（以下是脚本A）
struct Dddd //申明结构（结构与类同级）
{ //（结构体内可放 变量 和 方法 等等）-（剩余的不懂）
public String str; //申明变量
public void Eeee() //申明方法
{
Debug.Log(str);
}
}class Eeee
{
Dddd d = new Dddd(); //（获取到结构体）
void Start()
{
d.str = "aaa"; //（可访问到上面结构体中的变量）
d.Eeee(); //（可访问到上面结构体中的方法）
}
}三：数据结构
3-1.数据结构简介
3-2.Array（数组）
1.Array 数组 与 多维数组
using System;
void Start()
{
//直接申明数组
int[] arr;
string[] arr2;
//用 Array 声明数组
Array arr3 = Array.CreateInstance(typeof(string), 100); //（括号中是 数组类型 ， 空间大小）
//（但是不支持使用索引器访问到数组的内容）
string[] arr4 = new string[100]; //（这个数组等同于上面那个）
//Debug.Log(arr3[0]); //（这句是错误的）-（因为用 Array 声明的数组-是不支持使用索引器访问到数组的内容）
Debug.Log(arr3.GetValue(0)); //（用 Array 声明的数组-是这样来访问内容的）
arr3.SetValue("abc", 0); //（将内容放入数组）-（eg：将“abc”-放入数组arr3的-第0个位置）
//多维数组、用 Array 声明多维数组
Array arrArr = Array.CreateInstance(typeof(int), 5, 5); //（括号中是数组类型，行，列）-（eg：5行5列-共有25个）
Debug.Log(arr3.GetValue(1, 1)); //（访问到 Array 数组中-第1行的第1个）
int[,] arrArr2 = new int[5, 5]; //（这样申明的二维数组、与上面那个是一样的）
Debug.Log(arrArr2[1, 1]); //（访问到数组中-第1行的第1个）
}
3-2.Arraylist