Unity超基础学习笔记（三）

• 1） 功能和数据分离，使用的建模概念不能直接映射到问题域中的对象，不符合人们对现实世界的认识和思维方式。
• 2） 自顶向下的设计方法限制了软件模块的可复用性，降低了开发效率。
• 3） 当系统需求发生变化时，维护和扩展都变得非常困难。

面对对象的思想：
将软件的各个模块进行分割，形成一个一个独立的部分。就像现实世界里的一个个人，一个个物体一样。我们将其称为对象。就像每个人一样，对象有自己的属性，能执行特定的操作。比如一个人，有姓名，职业，身份证号，身高等称之为他的属性。这个人能够吃饭，看书，写字等称之为其特定的操作。
这个世界上有各种各样的人（对象），他们有不同地名字，职业等等。因此我们将这些共同特征抽象出来，就形成了“人”类（class）。
类就是指具有相同属性和操作的对象的模板。它描述的是一类对象的共同特征。
类是面向对象技术中最重要的结构，支持信息隐藏和封装，支持对抽象数据类型的实现。
信息隐藏是指对象的私有信息（包括属性和操作，例如人的身份证号）不能由外界直接访问，而是只能通过该对象公开的操作来间接访问，有助于提高程序的可靠性和安全性。

面向对象的三大特征：封装，继承，多态
1） 封装：（类的定义）
如之前所述，类是对一组具有相同属性和行为对象的抽象描述。换句话说，类就是将一些相关联的数据和方法封装在了一起，方便使用。
类的定义：

[类修饰符] class 类名
{
   
	数据类型 变量;
	void 函数名（方法名）(){
   ...}
}

例如：

public class A
{
   
		int a;
		void Func()
		{
   }
}

类的访问修饰符：

• 1） public: 同一程序集中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。
• 2） internal：是类默认的访问修饰符。同一程序集中的任何代码都可以访问该类型或成员，但其他程序集中的代码不可以。例如打包在dll里的类库，如果某个类是internal的话，外部就不能引用。

类成员包括成员变量和成员方法：
1） 成员变量：
类要处理的数据，包括常量和字段。
常量：代表与类相关的常数值，是在类中声明的值不变的变量。
字段：类中的变量。
2） 成员方法：
属性：定义类的值，并对它们提供读写操作。
事件：由类产生的通知，用于说明发生了什么事情。
索引器：又称下标指示器，允许编程人员通过索引来访问类中的成员。
运算符：可以重载运算符方便类的实例的运算。
构造函数：在类被实例化时调用的函数，主要完成对象的初始化操作。
析构函数：在对象被销毁之前最后执行的函数，主要完成对象结束时的收尾工作。
例如：

public class Person 
{
   
    public const float PI = 3.14f;//这个是类的常量
    public int id;//这个是类的变量
    private int _age;
    public int Age//这个是类的属性
    {
   
        get {
    return _age; }
        set {
    _age = value; }
    }
    public void Eat()//这个是类的方法
    {
    Debug.Log("吃饭"); }
    public int this[int index]//这个是类的索引器
    {
   
        get 
        {
   
            if (index == 0) return id;
            if (index == 1) return Age;
            return -1;
        }
        set 
        {
   
            if (index == 0) id = value;
            if (index == 1) Age = value;
        }
    }
    public Person()//这个是类的构造函数
    {
    }
    ~Person()//这个是类的析构函数
    {
    }
}

1） 常量的调用：
常量在声明是就应赋值。
在类中，常量的调用跟普通变量一样，就是不能再赋值了。
在类外，调用一个常量只能用“类名.常量名”获取，不能通过类实例获取。

2） 变量声明和调用
变量之间不能相互声明，因为都不确定。

class A
{
   
	int a;
	int b = a;//不允许互相声明
}

使用方法跟之前变量和方法一样，就是调用方式是：类实例化的对象.变量/方法。例如：

Person p=new Person();//类对象的实例化
	   p.Eat();//调用方法

3）成员的访问修饰符：
public 公有成员，类外部可以访问。
private 私有成员，是默认的访问修饰符，只能被类中的成员访问。
protected 保护成员，只能被类中和派生类中的成员访问。
internal 内部成员，只能同一工程文件中访问。
4） 方法的重载（多态）：
可以声明多个同一方法名，但形参的个数或者形参的类型不一样的方法。在调用时，程序自动根据实参的个数和类型选择调用的方法。

public void Eat()
    {
    Debug.Log("吃饭"); }
public void Eat(string str)
{
   
    Debug.Log($"吃{str}");
}
public void Eat(int n, string str)
{
   
    Debug.Log($"吃{n}个{str}");
}

调用：

p.Eat();//调用第一个方法
p.Eat(“饼”);//调用第二个方法
p.Eat(3,”饼”);//调用第三个方法

注意：由于形参名无意义，形参名不同不能形成重载：

public void Eat(string str)
{
   
    Debug.Log($"吃{str}");
}
public void Eat(string name)//错误
{
   
    Debug.Log($"和{name}吃");
}
返回值类型不同也无法形成重载：
public string Eat(string str)//错误
{
   
   return "吃{str}";
}

public Person(){
   }//名字必须与类名相同

2） 构造函数可以带参数，但没有返回值：

public Person(int Id){
   id = Id;}//有参数，但没有返回值

3） 构造函数只能在实例化对象时调用，不能直接调用。

var p = new Person();//这里会调用构造函数

4） 构造函数可以重载，重载的构造函数之间也可以相互调用，但不能被继承。

class A
{
   
	int a;
	int b;
	int c;
	public A(){
   }//无参的构造函数
	public A(int _a){
   a = _a;}//一个参数的构造函数
public A(int _a，int _b){
   a = _a;b = _b;}//两个参数的构造函数
public A(int _a，int _b,int _c){
    a = _a;b = _b;c = _c;}//三个参数的构造函数
}

构造函数可以用this关键字来互相调用

public A