【Unity 10】C#的方法和递归的申明及使用

PS:本系列笔记将会记录我此次在北京学习Unity开发的总体过程，方便后期写总结，笔记为日更。
笔记内容均为 自己理解，不保证每个都对。
C#笔记未按照难度排列

Part 1：方法：

1、方法：
方法的申明：

//方法  功能函数  可以反复使用  挺高代码的复用率
//组成： 修饰符 返回类型 方法名 参数
//修饰符：

//内存有  栈，堆，全局静态区，代码区
//全局静态区：const、static
//堆：new的出来的引用类型， 数组, class

//1、全局静态区内的可以互相访问
//2、栈堆可以访问全局静态，全局静态不能访问栈堆


//返回值：
//方法调用后的结果，返回值最多只能有一个（0或1）
//返回值可以是：基本数据类型/数组/枚举/类

//方法名字：
//遵守驼峰命名法  首字母大写

//参数：   完成方法所需要的资源
//组成：基本数据类型/数组/枚举/类
//个数可以是任意个

例如：

static int Add(int a, int b) //加法方法
{
    int result = a + b;
    return result;
}

测试代码：

    int temp = Add(2, 3);
    Console.WriteLine(temp);	//结果为 5      2 + 3 = 5

方法可以赋初值：

static int AddThree(int a, int b, int c = 10)
//int c = 10为默认参数，若调用时没有任何参数传进来则用默认值
//默认参数只能为参数的最后一个,可有多个默认参数

{
    int result = a + b + c;
    return result;
}

测试代码：

    temp = AddThree(1, 10, 30);
    Console.WriteLine(temp);    //41  c = 30      1 + 10 + 30 = 41

    temp = AddThree(1, 10);
    Console.WriteLine(temp);    //21  c = 10默认值		1 + 10 + 10 = 21

不定长参数的申明：

static void AddFive(params String[] str)    //参数params表示要传递多个string参数
{
    Console.WriteLine("AddSix Success!");
}

测试代码：

            AddFive("aa", "bb", "cc");
            string[] str = new string[] { "aa", "bb", "cc" };

方法的重载：

//方法重载
//方法的重载 方法名相同，参数的个数和参数的类型进行区分
//即相同方法可 根据 不同参数或类型执行不同的语句块

重载的声明：

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

测试代码：

            temp = Add(1, 2, 3);    //调用 a + b + c的参数方法
            Console.WriteLine(temp);		//结果为6		1 + 2 + 3 = 6
            
            int temp = Add(2, 3);		//调用a + b的参数方法
            Console.WriteLine(temp);		// 2 + 3 = 5

2、ref和out：
ref和out的定义：

//Ref, Out：引用的数据的地址，相当于C的 int *a;

static void Swap(int a, int b)  //引用的值
{
    int temp = a;
    a = b;
    b = temp;
}

static void RefSwap(ref int a, ref int b)    //引用的地址
{
    int temp = a;
    a = b;
    b = temp;
}
    out传递的是地址
static void AddEight(int a, out int b)
{
        b = 10;
}

测试代码：

    int a = 331;
    int b = 1224;

    Swap(a, b);
    Console.WriteLine("Swap 后：a == {0}   b == {1} ", a, b);

    RefSwap(ref a, ref b);
    Console.WriteLine("RefSwap 后：a == {0}   b == {1} ", a, b);

ref和数组的使用：
PS:这块儿我也不太确定我的理解是不是对的。。。反正我是这么理解的

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a">a的地址 = 传进数组的地址， 所以a[0] = 10操作时访问的地址快等于Array[0] = 10 </param>
        static void AddNumberOne(int[] a)
        {
            a[0] = 10;
            //此时Array = {10, 2, 3, 4}
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="a">传进的本身就是地址所以进行的操作等于 Array[0] = 20</param>
        static void AddNumberTwo(ref int[] a)
        {
            a[0] = 20;
            //此时Array = {20, 2, 3, 4}
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a">new操作后得到了新的内存块，所以a的地址与Array的地址不同，进行的操作是a[0] = 30，</param>
        static void AddNumberThree(int[] a)
        {
            a = new int[10];
            a[0] = 30;
            //此时Array = {20, 2, 3, 4}
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a">传进的是Array数组的地址，所以new操作相当于 Array = new int[10], 后进行 a[0] = 40即Array[0] = 40</param>
        static void AddNumberFour(ref int[] a)
        {
            a = new int[10];
            a[0] = 40;
            //此时Array = {40, 0, 0, 0, 0, 0, 0, 0, 0, 0}
        }



        /// <summary>
        /// 
        /// </summary>
        /// <param name="a">传进的是Array数组的地址，所以new操作相当于 Array = new int[10], 后进行 a[0] = 50即Array[0] = 50</param>
        static void AddNumberFive(out int[] a)
        {
            a = new int[10];
            a[0] = 50;
            //此时Array = {50, 0, 0, 0, 0, 0, 0, 0, 0, 0}
        }

测试代码：

            int[] Array = new int[] { 1, 2, 3, 4 };
            Console.WriteLine(Array.ToString());
            for (int i = 0; i < Array.Length; i++)
            {
                Console.Write("{0} ", Array[i]);
            }
            Console.WriteLine();		


            AddNumberOne(Array);
            Console.WriteLine("One:");
            for (int i = 0; i < Array.Length; i++)
            {
                Console.Write("{0} ", Array[i]);
            }
            Console.WriteLine();


            AddNumberTwo(ref Array);
            Console.WriteLine("Two:");
            for (int i = 0; i < Array.Length; i++)
            {
                Console.Write("{0} ", Array[i]);
            }
            Console.WriteLine();



            AddNumberThree(Array);
            Console.WriteLine("Three:");
            for (int i = 0; i < Array.Length; i++)
            {
                Console.Write("{0} ", Array[i]);
            }
            Console.WriteLine();


            AddNumberFour(ref Array);
            Console.WriteLine("Four:");
            for (int i = 0; i < Array.Length; i++)
            {
                Console.Write("{0} ", Array[i]);
            }
            Console.WriteLine();


            AddNumberFive(out Array);
            Console.WriteLine("Five:");
            for (int i = 0; i < Array.Length; i++)
            {
                Console.Write("{0} ", Array[i]);
            }
            Console.WriteLine();

输出结果为：

ref和out的相同点和不同点：

//ref 和 out
//相同点：都是传递地址
//不同点：被out修饰的变量不用初始化，被ref修饰的必须初始化
//        被out修饰的变量必须方法体内赋初值

Part 2 递归：

1、例子：
斐波那契数列：

static int TestFunc(int a)
{
    if (a == 1 || a == 2)
        return 1;
    else
        return (TestFunc(a - 1) + TestFunc(a - 2));

}

2、二分查找：https://blog.youkuaiyun.com/zb756999355/article/details/97500088