using UnityEngine;

// 注释是写给人看的
public class Hello : MonoBehaviour
{
    void Start()
    {
        Debug.Log("这是一个普通日志。");
        Debug.LogWarning("这是一个警告日志。");
        Debug.LogError("这是一个错误日志。");
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        //变量的声明：类型 变量名 = 初始值;
        string myName = "Lickba"; //字符串的使用，需要加双引号
        int age = 18;           //非字符串的使用，不需要加引号
        float num = 15.654787354f; //浮点数的使用，后面加f表示这是一个浮点数

        //使用或输出变量的时候，不需要加双引号,f等
        Debug.Log(myName);
        Debug.Log(age);
        Debug.Log(num);
    }
}   

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        // +号拼接
        // 我是AA，我今年18岁

        string name = "AA";
        int age = 18;
        // int类型和字符串相加时，int会自动转换为字符串
        string info = "我是" + name + "，我今年" + age + "岁";
        Debug.Log(info);

        // $格式化输出，用{}去包裹变量
        // $格式化输出时，@符号会对整体进行取消转义
        string info2 = $"我是{name}，我今年{age}岁";
        Debug.Log(info2);
    }
}   

int age = 25;
Int32 age2 = 30; // Int32 等于 int

int a = 1;
int b = a++; // b = 1

int a = 1;
int b = ++a; // b = 2

int a = 3;
a += 4; // 7  等同于a = a + 4;
a -= 2; // 5  等同于a = a - 2;
a *= 2; // 10 等同于a = a * 2;
a /= 5; // 2  等同于a = a / 5;
a %= 3; // 2  等同于a = a % 3;

Debug.Log(a); // 输出结果为2

 string userName = "User2";
 string password = "Password123";

 bool checkUserName = userName == "User";
 bool checkPassword = password == "Password123";

 bool online = true; // 当前网络在线

 bool canLogin = checkUserName & checkPassword & online; // 能登录 = 用户名正确 同时 密码正确
 // bool canLogin = (checkUserName & checkPassword) & online;
 Debug.Log($"玩家可以登录: {canLogin}");

 bool admin = true; // 是否是管理员
 bool adminCanLogin = checkUserName | admin; // 管理员可以登录 = 用户名正确 或者 是管理员
 Debug.Log($"管理员可以登录: {adminCanLogin}");

 Debug.Log(!false);
 Debug.Log(!true);
 // ! 是逻辑非运算符，用于取反布尔值。
 // 它会将 true 变为 false，将 false 变为 true。

// &  // 按位与运算符
// && // 逻辑与运算符
// |  // 按位或运算符
// || // 逻辑或运算符
// & 跟 && 的区别：
// & 是按位与运算符，会对每一位进行比较，只有当两个操作数的对应位都为1时，结果才为1。
// && 是逻辑与运算符，只有当两个操作数都为true时，结果才为true，并且如果第一个操作数为false，则不会计算第二个操作数（短路求值）。
// | 跟 || 的区别：
// | 是按位或运算符，会对每一位进行比较，只要有一个操作数的对应位为1，结果就为1。
// || 是逻辑或运算符，只要有一个操作数为true，结果就为true，并且如果第一个操作数为true，则不会计算第二个操作数（短路求值）。

int value = -80;
int num = value < 0 ? 0 : value; // 如果num小于0，则num赋值为0，否则不变
Debug.Log(num);

// 最多是100
int num2 = value > 100 ? 100 : value; // 如果num大于100，则num2赋值为100，否则num2赋值为num
Debug.Log(num2);

// 控制在0到100之间
int num3 = value < 0 ? 0 : value;
num3 = num3 > 100 ? 100 : num3;
Debug.Log(num3);

if(3==3)
{

}
else if (a2 > a3)
{

}

// 案例：1+2+3+4+5....+100
int res = 0;
for (int i = 1; i <= 100; i++)
{
    res += i; // 将i的值累加到res中
    Debug.Log($"i = {i}, res = {res}");

}
Debug.Log($"1+2+3+4+5....+100 = {res}");

// 避免死循环
// 从1加到100
int num = 1;
int res = 0;
while (num<=100)
{
    res += num;
    num++;
    Debug.Log($"当前num={num}, res={res}");
}
Debug.Log(res);

// 至少执行一次
do
{
    // 首先执行一次
    // 循环体
    Debug.Log("至少执行一次");
} while (false); // 如果条件满足才会执行下一次

private void Start()
{
    int num = 100;
    Function(num,"Test"); //调用函数
    Debug.Log($"实参num = {num}"); //输出 num 的值

    int num2 = 33;
    num2 = Add(num2, 333);
    Debug.Log($"Add(100, 333) = {num2}"); // 输出 Add 函数的返回值

}

// 函数的参数名称理论是无所谓是什么的，但是还是要见名知意
// 函数的参数叫做形参，也就是形式参数，和外部调用处的函数变量名称没有关系
// 实参和形参没有关系：一方改变不影响另外一方，相当于变成了两个类型一致但是数值没有关联的变量
void Function(int num,string info)
{
    num += 200;
    for (int i = 0; i <= 100; i++)
    {
        //Debug.Log($"{i}");
    }
    Debug.Log($"形参num : {num}");
}

// 一个返回值类型为int的函数
int Add(int a, int b)
{
    int res = a + b;
    return res; // return的结果要跟函数的返回值类型一致
}
void Do()
{
	return; //return意味着不执行之后的逻辑
}

private void Start()
{
    int res = Add(1, 2);
    int res2 = Add(1, 2, 3);
    int res3 = Add(1, "2");
}

int Add(int a, int b)
{
    int res = a + b;
    return res; // return的结果要跟函数的返回值类型一致
}

// int.Parse：转为int类型
int Add(int a, string b)
{
    int res = a + int.Parse(b);
    return res;
}

int Add(int a, int b, int c)
{
    int res = a + b + c;
    return res;
}

private void Start()
{
    int a = 3;
    RefFunction(ref a);    // 实参
    Debug.Log($"实参： {a}");

    // 需求：
    // 1.请求登录，提供一个账号
    ///2.如果有此账号，返回true，并且返回密码
    if (CheckLogin("user123", out string password)) // 相当于定义在if的外面
    {
        Debug.Log($"登录成功，密码是：{password}");
    }
    else
    {
        Debug.Log("登录失败，账号不存在");
    }

    TestFunction(100,200);
    TestFunction(10);
    TestFunction(1);
}

void RefFunction(ref int a)    // 形参
{
    a += 1000;
    Debug.Log($"形参： {a}");
}

/// <summary>
/// 检查登录
/// </summary>
/// <param name="account">用户名</param>
/// <param name="password">密码</param>
/// <returns>是否登录成功</returns>
bool CheckLogin(string account, out string password)
{
    // 模拟账号和密码
    if (account == "user123")
    {
        password = "password123"; // 返回密码
        return true; // 登录成功
    }
    else
    {
        password = null; // 无效账号
        return false; // 登录失败
    }
}

// 测试可选参数（默认参数）
// 如果你传递，则使用传递的值；如果不传递，则使用默认值
void TestFunction(int c,int a = 10099, int b = 9999)
{
    Debug.Log(a+b+c);
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        Hero tanke = new Hero(); // 构造一个结构体
        tanke.Name = "超级坦克"; // 修改结构体的成员变量
        Debug.Log($"英雄: {tanke.Name}");
        tanke.Show(); // 调用结构体的成员函数

        Hero tanke2 = new Hero("X刺客", 30, 500); // 构造另一个结构体
        tanke2.Show(); // 调用另一个结构体的成员函数
    }

}
/// <summary>
/// 英雄结构体
/// </summary>
struct Hero
{
    // 成员
    // 成员字段（变量）
    // 访问修饰符
    // 1. public: 公共的，可以被外部访问
    // 2. private: 私有的，只能在结构体内部访问
    public string Name; // 默认值是 null
    public int Attack;  // 成员存在默认值，数值类型（int, float, double）默认值是 0
    public int Hp;

    // 默认有一个无参构造函数
    // 构造函数
    public Hero(string name, int attack, int hp)
    {
        Name = name;
        Attack = attack;
        Hp = hp;
    }

    // 成员函数
    public void Show()
    {
        Debug.Log($"英雄: {Name}, 攻击力: {Attack}, 生命值: {Hp}");
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        Hero tanke2 = new Hero("X刺客", 30, 500); // 构造另一个结构体
        tanke2.Show(); // 调用另一个结构体的成员函数

        HeroClass mage = new HeroClass("法师", 50); // 构造一个类
        mage.Show(); // 调用类的成员函数
        // 结构体和类的区别
        // 1. 结构体是值类型，类是引用类型
        // 2. 结构体的实例在栈上分配内存，类的实例在堆上分配内存
        // 3. 结构体的实例在赋值时会复制所有成员，类的实例在赋值时只复制引用
        // 4. 结构体不能继承其他结构体或类，但可以实现接口
    }
}
/// <summary>
/// 英雄结构体
/// </summary>
struct Hero
{
    // 成员
    // 成员字段（变量）
    // 访问修饰符
    // 1. public: 公共的，可以被外部访问
    // 2. private: 私有的，只能在结构体内部访问
    public string Name; // 默认值是 null
    public int Attack;  // 成员存在默认值，数值类型（int, float, double）默认值是 0
    public int Hp;

    // 默认有一个无参构造函数
    // 构造函数
    public Hero(string Name, int attack, int hp)
    {
        // 同名变量的就近原则，就近：定义的位置
        Name = Name;
        this.Name = Name; // this 关键字指代当前结构体实例
        Attack = attack;
        Hp = hp;
    }

    public Hero(string name,int attack, int hp,int attackBuff)
    {
        Name = name;
        Hp = hp;
        Attack = attack + attackBuff; // 攻击力加上攻击增益
    }

    // 成员函数
    public void Show()
    {
        Debug.Log($"英雄: {Name}, 攻击力: {Attack}, 生命值: {Hp}");
    }

}

/// <summary>
/// 英雄类
/// </summary>
public class HeroClass
{
    public string Name;
    public int Attack;

    public HeroClass(string name, int attack)
    {
        Name = name;
        Attack = attack;
    }
    public void Show()
    {
        Debug.Log($"英雄: {Name}, 攻击力: {Attack}");
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        Animal animal = new Animal("动物");
        animal.Name = "小动物";
        animal.Eat();

        Dog daHuang = new Dog("大黄","柯基");
        Debug.Log(daHuang.Name);
        daHuang.Eat();

        Cat xiaoBai = new Cat("小白");
        Debug.Log(xiaoBai.Name);
        xiaoBai.Eat();
    }

    // 基类/父类
    public class Animal
    {
        public string Name;

        public Animal(string name)
        {
            Name = name;
        }

        // 函数也是对象的成员
        public void Eat()
        {
            Debug.Log($"{Name}Eating");
        }
    }

    // 派生类/子类
    public class Dog : Animal // 获得 Animal 的所有属性和方法
    {
        public string dogType;
        // 我们已经约束了，实例化一个Animal必须有名字
        // 但是这里出现了冲突，因为实例化一个Dog却没有名字

        // this:谁调用了这个函数，谁就是this
        // base:当前类的基类
        // this和base都是对象，但是程序上认为这个结构（类）不一样
        // 要调用当前类型的成员，用this
        // 要调用父类的成员，用base，但是一般不太会用，除非需要特别声明是基类中
        public Dog(string name,string dogType):base(name)
        {
            // base.dogType 不能通过base访问当前类的成员
            Debug.Log($"名字：{name}，品种：{dogType}诞生了！");
            this.dogType = dogType;
        }
    }

    public class Cat : Animal
    {
        public Cat(string name) : base(name)
        {
        }
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        Dog daHuang = new Dog("大黄","汪汪汪！","柯基");
        Cat xiaoBai = new Cat("小白","喵喵喵~");
        daHuang.Cry();
        xiaoBai.Cry();
    }

    // 基类/父类
    public class Animal
    {
        public string Name;
        public string CryString;

        public Animal(string name, string cryString)
        {
            Name = name;
            CryString = cryString;
        }

        // 虚函数
        // 1.提供默认逻辑，因为有一些子类不想要重写可以不重写
        // 2.提供可选的逻辑
        public virtual void Cry()
        {
            // 下列是可选的
            // 可选的：就是子类想要就可以要，不想要也可以不要
            Debug.Log($"{Name}张嘴了！");
        }
    }

    // 派生类/子类
    public class Dog : Animal // 获得 Animal 的所有属性和方法
    {
        public string dogType;

        public Dog(string name,string cryString,string dogType):base(name,cryString)
        {
            Debug.Log($"名字：{name}，品种：{dogType}诞生了！");
            this.dogType = dogType;
        }

        // 重写
        // 重载：是同名函数，但是不同参数
        // 重写：是同名函数，参数相同，但是实现不同
        public override void Cry()
        {
            Debug.Log($"{Name}开始蓄力！");
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"{Name}：{CryString}");
            Debug.Log($"它是一只狗！");
        }
    }

    public class Cat : Animal
    {
        public Cat(string name,string cryString) : base(name,cryString)
        {

        }
        public override void Cry()
        {
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"{Name}：{CryString}");
            Debug.Log($"它是一只猫！");
        }
    }

}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        // Animal animal = new Animal("小动物", "吱吱吱~"); // 不允许实例化抽象类
        KeJiDog daHuang = new KeJiDog("大黄","汪汪汪！","柯基");
        Cat xiaoBai = new Cat("小白","喵喵喵~");
        daHuang.Move();
        xiaoBai.Move();
    }

    // 基类/父类
    // 抽象类
    public abstract class Animal
    {
        public string Name;
        public string CryString;

        public Animal(string name, string cryString)
        {
            Name = name;
            CryString = cryString;
        }

        // 虚函数
        // 1.提供默认逻辑，因为有一些子类不想要重写可以不重写
        // 2.提供可选的逻辑
        public virtual void Cry()
        {
            // 下列是可选的
            // 可选的：就是子类想要就可以要，不想要也可以不要
            Debug.Log($"{Name}张嘴了！");
        }

        // 抽象函数
        // 业务上存在飞翔、跑步、游泳等各种情况，我们并不知道具体的子类如何实现
        // 没有函数体
        public abstract void Move(); // 抽象方法，子类必须实现
}

    // 派生类/子类
    // 第二层，Dog也是抽象类
    // 抽象类不需要实现基类中的抽象函数（我也不知道我下面的子类会怎么实现）
    public abstract class Dog : Animal // 获得 Animal 的所有属性和方法
    {
        public string dogType;

        public Dog(string name,string cryString,string dogType):base(name,cryString)
        {
            Debug.Log($"名字：{name}，品种：{dogType}诞生了！");
            this.dogType = dogType;
        }

        // 重写
        // 重载：是同名函数，但是不同参数
        // 重写：是同名函数，参数相同，但是实现不同
        public override void Cry()
        {
            Debug.Log($"{Name}开始蓄力！");
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"{Name}：{CryString}");
            Debug.Log($"它是一只狗！");
        }

        // 重写的是基类中的抽象函数
        public override void Move()
        {
            Debug.Log($"{Name}开始奔跑！");
        }
    }

    public class KeJiDog : Dog
    {
        // 他的构造函数约束是自身基类的
        public KeJiDog(string name, string cryString, string dogType) : base(name, cryString, dogType)
        {
        }
        public override void Cry()
        {
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"抖了抖小短腿！");
        }
        public override void Move()
        {
            base.Move(); // 调用基类的 Move 方法
            Debug.Log($"抖了抖柯基翘臀！");
        }
    }

    public class Cat : Animal
    {
        public Cat(string name,string cryString) : base(name,cryString)
        {

        }
        public override void Cry()
        {
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"{Name}：{CryString}");
            Debug.Log($"它是一只猫！");
        }

        public override void Move()
        {
            Debug.Log($"{Name}开始跳跃！");
        }
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    private void Start()
    {
        // Animal animal = new Animal("小动物", "吱吱吱~"); // 不允许实例化抽象类
        KeJiDog daHuang = new KeJiDog("大黄","汪汪汪！","柯基");
        Cat xiaoBai = new Cat("小白","喵喵喵~");

        DoCry(xiaoBai); // 里氏转换-隐式转换，子类转父类
        KejiMove(daHuang); // 传递参数时依然是子类转父类
    }

    public void DoCry(Animal animal)
    {
        Debug.Log("开始叫");
        animal.Cry();
    }

    public void KejiMove(Animal animal) // 此处约定传递过来的参数要么是Animal，要么是Animal的子类通过隐式转换传递过来的
    {
        // 强制转换，会报错
        KeJiDog keji = (KeJiDog)animal; // 显式转换，父类转子类，有风险，要确保类型兼容
        keji.Move(); // 调用子类特有的方法

        //Cat cat = (Cat)animal; // 类型不兼容，会立刻报错
        //cat.Move();

        // as转换，不会报错
        Cat keji2 = animal as Cat; // 安全转换，如果类型不兼容，不会立刻报错，但是返回的是 null
        keji2?.Move(); // 使用安全转换后，调用 Move 方法前需要检查是否为 null
    }

    // 基类/父类
    // 抽象类
    public abstract class Animal
    {
        public string Name;
        public string CryString;

        public Animal(string name, string cryString)
        {
            Name = name;
            CryString = cryString;
        }

        // 虚函数
        // 1.提供默认逻辑，因为有一些子类不想要重写可以不重写
        // 2.提供可选的逻辑
        public virtual void Cry()
        {
            // 下列是可选的
            // 可选的：就是子类想要就可以要，不想要也可以不要
            Debug.Log($"{Name}张嘴了！");
        }

        // 抽象函数
        // 业务上存在飞翔、跑步、游泳等各种情况，我们并不知道具体的子类如何实现
        // 没有函数体
        public abstract void Move(); // 抽象方法，子类必须实现
        

}

    // 派生类/子类
    // 第二层，Dog也是抽象类
    // 抽象类不需要实现基类中的抽象函数（我也不知道我下面的子类会怎么实现）
    public abstract class Dog : Animal // 获得 Animal 的所有属性和方法
    {
        public string dogType;

        public Dog(string name,string cryString,string dogType):base(name,cryString)
        {
            Debug.Log($"名字：{name}，品种：{dogType}诞生了！");
            this.dogType = dogType;
        }

        // 重写
        // 重载：是同名函数，但是不同参数
        // 重写：是同名函数，参数相同，但是实现不同
        public override void Cry()
        {
            Debug.Log($"{Name}开始蓄力！");
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"{Name}：{CryString}");
        }

        // 重写的是基类中的抽象函数
        public override void Move()
        {
            Debug.Log($"{Name}开始奔跑！");
        }
    }

    public class KeJiDog : Dog
    {
        // 他的构造函数约束是自身基类的
        public KeJiDog(string name, string cryString, string dogType) : base(name, cryString, dogType)
        {
        }
        public override void Cry()
        {
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"抖了抖小短腿！");
        }
        public override void Move()
        {
            base.Move(); // 调用基类的 Move 方法
            Debug.Log($"抖了抖柯基翘臀！");
        }
    }

    public class Cat : Animal
    {
        public Cat(string name,string cryString) : base(name,cryString)
        {

        }
        public override void Cry()
        {
            base.Cry(); // 调用基类的 Cry 方法
            Debug.Log($"{Name}：{CryString}");
            Debug.Log($"它是一只猫！");
        }

        public override void Move()
        {
            Debug.Log($"{Name}开始跳跃！");
        }
    }

}

public string Name; 	// 公开属性，可以在任何地方访问
private string age; 	// 私有属性，只能在 Animal 类内部访问
protected string color; // 受保护属性，可以在 Animal 类及其派生类中访问

using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        // 通过类型名.类型名去访问嵌套类
        Animal.AnimaTest animaTest = new Animal.AnimaTest();
        animaTest.Test();
    }
}

// 没有被嵌套的，只能被定义成公开的
public class Animal
{
    public void Test()
    {
        // 内部使用和平时没什么区别
        AnimaTest animaTest = new AnimaTest();
        animaTest.Test();
    }

    // 嵌套类可以修改访问修饰符
    // private:只能被嵌套自身的上级访问
    public class AnimaTest
    {
        public void Test()
        {
            Debug.Log("Hello from AnimaTest!");
        }
    }
}

namespace Animal // 包裹的内容归属这个命名空间
{
    public abstract class AnimalObject
    {
        public string name;
        public override string ToString()
        {
            return $"我是动物：{name}";
        }
    }

}

namespace Animal // 包裹的内容归属这个命名空间
{
    public class Dog : AnimalObject
    {

    }
}

using Animal; // 在这个文件引入命名空间
using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        AnimalObject animal = new Dog();
    }

}

using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        Robot robot = new Robot();
        Person person = new Person();
        Parrot parrot = new Parrot();
        Talk(robot);    // 隐式转换
        Talk(person);   // 隐式转换
        Talk(parrot);   // 隐式转换

        ITalk talker = robot; // 隐式转换
        Robot robot2 = (Robot)talker; // 显式转换，
    }
    // 让某个对象进行说话
    public void Talk(ITalk talker)
    {
        talker.Talk();
    }

}

public interface ITalk
{
   void Talk(); // 实际上是抽象函数，不需要定义访问修饰符，因为没意义，因为如果不公开就不可能被访问到了
}

using UnityEngine;

public class Robot : ITalk
{
    public void Talk() // 实现接口不需要写override，因为接口方法本身就是抽象的，不需要再声明为抽象
    {
        Debug.Log("机器人说话了！");
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        Hero hero = new Hero();
        hero.HP = 100;
        hero.MP = 50;
        hero.HP -= 1;
        hero.Hurt();
        hero.HP -= 12;

        hero.MP -= 35;      // 修改属性意味着 访问 属性的 set 方法
        Debug.Log(hero.MP); // 获取属性意味着 访问 属性的 get 方法
        hero.MP -= 35;
        Debug.Log(hero.MP);

        hero.FlySpeed = 100; // 访问 FlySpeed 的 set 方法
        Debug.Log(hero.FlySpeed); // 访问 FlySpeed 的 get 方法
    }


}

public class Hero : Unit
{
    public int HP;
    private int mp;

    // 成员属性
    // 属性在外部和变量是类似的
    // 属性相当于提供了两个函数，分别是 get 和 set，但是也可以只保留其中一个
    // 属性的类型决定了get 和 set 的返回类型
    public int MP
    {
        get 
        {
            Debug.Log("有人在获取MP，我怀疑他要检查能不能放技能");
            return mp; 
        }
        set 
        {
            Debug.Log("有人在设置MP，我怀疑他要放技能");
            if(value < 0)
            {
                Debug.LogError("MP不能小于0");
                mp = 0;
                return; // 直接返回，避免后续代码执行
            }
            if (value < mp)
            {
                Debug.Log("MP减少了！MP:"+value);
            }
            else if(value > mp)
            {
                Debug.Log("MP增加了！MP:"+value);
            }
            else
            {
                Debug.Log("MP没有变化！");
            }

            mp = value; 
        }
    }

    public void Hurt() 
    {
        Debug.Log("我受伤了！" +HP);
    }

    private int lv;

    public override int LV
    {
        get
        {
            return lv + 1;
        }

    }

    private int moveSpeed;
    public override int MoveSpeed 
    {
        get => 23;
        set => moveSpeed = value; 
    }
}

public abstract class Unit
{
    public virtual int LV { get { return 0; }}
    public abstract int MoveSpeed { get; set; }

    // 简写，相当于提供了默认的成员变量
    // 并且自动在get的时返回、set的时赋值，但是无法直接访问这个成员变量，相当于只能通过属性访问
    public int FlySpeed
    {
        get;            
        set;
        // private set;    // 保护起来，给get或set单独设置访问修饰符
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        Hero hero = new Hero("张三");
        TestFunction(hero);

        Debug.Log(hero.name); // Start中的hero其实就是TestFunction中的unit

        Hero hero3 = hero;
        Debug.Log(hero3);

        // 如果修改hero3，等于修改hero，因为他们指向同一个对象
        hero3.name += "_修改一下";
        Debug.Log(hero.name); // 输出: 张三_TestFunction_修改一下
        Debug.Log(hero3.name); // 输出: 张三_TestFunction_修改一下
        hero = null; //让hero无效
        Debug.Log(hero3.name);  // 如果一个引用 = null，其他引用仍然有效
        Debug.Log(hero.name);   // 如果对象是null，是不能调用任何成员的，否则会报错，要避免

        Hero hero4; // 只有变量，没有实际引用的默认就是null
        // Debug.Log(hero4.name); // 这会报错，因为hero4没有被初始化

        // 目前的测试只对class类型有效，int、float等值类型不会影响原对象
    }

    void TestFunction(Hero unit)
    {
        unit.name += "_TestFunction";
        unit = null; // 这只是让unit指向null，不影响原对象
    }

}

public class Hero
{
    public string name;

    public Hero(string name)
    {
        this.name = name;
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        int num1 = 3;
        int num2 = 3;
        Debug.Log(num1 == num2); // True，值类型只比较数值是否相等

        Hero hero1 = new Hero("张三");
        Hero hero2 = new Hero("张三");
        // 引用的比较
        // 
        Debug.Log(hero1 == hero2); // False，虽然他们的成员相等，但是不是一个对象
        if (hero1 != null) // 如果英雄存在（是否不为null），则可以XXX
        {
            
        }

        // object.ReferenceEquals方法比较两个对象是否是同一个对象
        Debug.Log(object.ReferenceEquals(hero1, hero2)); // False
        Debug.Log(object.ReferenceEquals(null, null));   // True
        Debug.Log(object.ReferenceEquals(hero1, null));  // False，hero1不是null

        // 类.Equals()实际上就是objectade函数，静态函数（后续学习）
        Debug.Log(Hero.Equals(hero1, hero2));
        Debug.Log(Hero.Equals(null, null));
        Debug.Log(Hero.Equals(hero1, null));

        // 对象.Equals()
        Hero hero3 = hero1;
        Hero hero4 = new Hero("李四");
        Hero hero5 = new Hero("张三"); // 不同对象但是逻辑上同名
        Debug.Log(hero1.Equals(hero3));
        Debug.Log(hero1.Equals(hero4));
        Debug.Log(hero1.Equals(hero5)); // True
    }
}

public class Hero
{
    public string name;

    public Hero(string name)
    {
        this.name = name;
    }

    // 我们就强行要求，同名且同类型就是相等的（当然它们实际上还是两个对象，但是我们希望得到相等的结果）
    public override bool Equals(object obj)
    {
        Hero temp = obj as Hero;
        // 如果这个obj不是Hero类型，会转换失败，temp将为null
        // 既然类型都不相同，当然不相等
        if (temp == null)
        {
            return false;
        }
        else //else说明转换成功了，obj是 Hero 对象
        {
            return this.name == temp.name; // 如果名字相同，则认为是相等的
        }
    }
}

using UnityEngine;

public class Hello : MonoBehaviour
{
    void Start()
    {
        int a = 3;
        int b = a;

        b = 4; // 此时a依然=3
        Test(b); // Test(int num = 4) 函数调用的过程也是复制

        // hero1和hero2其实是一个对象的引用
        Hero hero1 = new Hero("张三",4);
        Hero hero2 = hero1;

        hero1 = null;
        hero2 = null; // 此时张三这个英雄相当于无名，无名就意味着无用，等待销毁

        TestHero(hero1);
        SetHeroLv(hero1.friendHero);
        Test(hero1.lv); // 相当于Test函数中的num= hero1.lv，但是两者依然无关联
        // 引用类型的变量在除了它的有限范围（作用域）时候会失效，但是不意味着他引用的对象也失效
    }

    void SetHeroLv(Hero hero)
    {
        hero.lv = 10086;
        // class中的值类型：修改对象内的成员都要用对象名.成员名称去做到
        // 引用类型，因为指向引用的对象，所以修改对象内的成员变量，直接修改即可
    }
    void Test(int num)
    {
        int num2 = -1;
        for (int i = 0; i < 100; i++)
        {
            num2 = i;
            if (i==88)
            {
                SaveNum(i); // 复制给SaveNum函数中的num
            }
        }
    }

    private int num;
    void SaveNum(int num)
    {
        this.num = num; // this关键字指向当前类的成员变量
    }
    void TestHero(Hero hero)
    {
        Debug.Log(hero.name);
    }
}
public class Hero
{
    public string name;
    public int lv;
    public Hero friendHero;

    public Hero(string name, int lv)
    {
        this.name = name;
        this.lv = lv;
    }
}

string str1 = "ddd";
string str2 = "ddd";
str1 = "CCC"

// 这些函数都是返回一个新的字符串，不会修改原有的字符串，因为使用了常量池的技术
//Length: 字符串长度
//IndexOf：A字符串在B字符串中第一次出现的位置
//LastIndexOf：A字符串在B字符串中最后一次出现的位置
//Replace：替换字符串中指定的字符
//ToUpper：将字符串转换为大写
//ToLower：将字符串转换为小写

string name1 = "张三Abc";
string name2 = "张三Abc";
string name3 = new string("张三Abc");

// C#中允许重载运算符，如果一定要看它们的引用是否相等，要用object.ReferenceEquals
Debug.Log(name1 == name3); // 字符串的==被修改，不再是对比是否同一个引用，而是值是否相等
Debug.Log(object.ReferenceEquals(name1, name3));
Debug.Log(object.ReferenceEquals(name1, name2));

using UnityEngine;
public class Hello : MonoBehaviour
{
    void Start()
    {
        // 定义数组
        // 定义时如果不确定值，数组内是默认值
        int[] nums1 = new int[10];
        int[] nums2 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 定义时就填充数据
        Hero[] heros = new Hero[] {
            new Hero(),new Hero(),new Hero()
        };

        int num;
        // 修改数据，编程领域普遍情况下，计数从0开始
        nums1[0] = 33;

        // 获取数据
        Debug.Log(nums1); // 33

        // 理论上不存在删除数据的情况，但是可以让数据无效
        nums1[0] = 0;
        heros[0] = null; // 让数组中的数据无效

        Test(nums1);
        Test(nums2);
        // Debug.Log(nums2[nums2.Length]); Length是数组的长度，但是索引从0开始，所以最后一个元素的索引是Length - 1

        object[] objs = new object[] {1, "hello", new Hero() };
    }
    private void Test(int[] nums)
    {
        // 数组的长度，但是注意，不是有效长度，而是定义时的长度
        for (int i = 0; i < nums.Length; i++)
        {
            var num = nums[i];
            Debug.Log(num);
        }
    }
}
public class Hero
{

}

int[] nums = new int[] {0,1,2,3,4,5,6,7,7,7 }; // 10个int
// 交错数组只是约束成员都是某个类型，但是不约束里面的内容
int[][] nums2 = new int[][] // 元素是int[]
{
    new int[] {0,1,2,3,4,5,6,7,7,7 },
    new int[] {0,1,2,3,4,5,6,7,7,7 },
    new int[] {0,1,2,3,4,5,6,7,7,7 },
    new int[] {0,1,2,3},
};
int num = nums2[0][3]; // 访问nums2[0]的第三个元素
Debug.Log(num); // 输出3

    // 多维数组
    int[,] nums3 = new int[2, 3] // 4行3列
    {
        {1,2,3},
        {4,5,6},
    };
    Debug.Log(nums3.Length); // 输出6 多维数组元素的总长度
    Debug.Log(nums3[0, 0]); // 输出1
    Debug.Log(nums3[1, 0]); // 输出4
    Debug.Log(nums3[0, 1]); // 输出2

    for (int i = 0;i < nums3.GetLength(0);i++)
    {
        for (int j = 0; j < nums3.GetLength(1); j++)
        {
            Debug.Log(nums3[i, j]);
        }
    }
}

using UnityEngine;
public class Hello : MonoBehaviour
{
    void Start()
    {
        Animal[] animals = new Animal[3];
        animals[0] = new Dog();
        animals[1] = new Cat();
        animals[2] = new Fish();

        for (int i = 0; i < animals.Length; i++)
        {
            animals[i].Eat();
        }

        for (int i = 0; i < animals.Length; i++)
        {
            // 如果动物实现了IRun接口，则调用Run方法
            IRun runer = animals[i] as IRun;
            if (runer != null)
            {
                runer.Run();
            }
            else
            {
                Debug.Log("该动物不能跑！");
            }
        }
    }
}

public abstract class Animal
{
    public abstract void Eat();
    public virtual void Cry()
    {
        Debug.Log("");
    }
}

public interface IRun
{
    void Run();
}

public class Dog : Animal,IRun
{
    public override void Eat()
    {
        Debug.Log("小狗吃东西！");
    }
    public void Run()
    {
        Debug.Log("小狗跑！");
    }
}

public class Cat : Animal, IRun
{
    public override void Eat()
    {
        Debug.Log("小猫吃东西！");
    }
    
    public void Run()
    {
        Debug.Log("小猫跑！");
    }
}

public class Fish : Animal
{
    public override void Eat()
    {
        Debug.Log("小鱼吃东西！");
    }
    
}