第9天c#可变参数,函数重载和递归

可变参数

概念

定义方法时，形参列表里参数前加params关键字的参数为可变参数

作用

可变参数可以传入零个或多个与可变参数类型相同的参数

注意

1.可变参数必须是数组类型，可以是一维数组和可变数组，方法内可通过索引访问各个传入的参数

        /// <summary>
        /// 交错数组
        /// </summary>
        /// <param name="arr"></param>
        static void Test(params int[][] arr)//参数前加params关键字的参数为可变参数 params 后面跟的一定是数组的形式 ,可以是一维数组和交错数组，二维数组不行
        {                                   
            foreach (int[] item in arr)
            {
                foreach (int tmp in item)
                {
                    Console.Write(tmp+"	");
                }
                Console.WriteLine();
            }
        }
        /// <summary>
        /// 一维数组
        /// </summary>
        /// <param name="arr"></param>
        static void Test1(params int[] arr)//参数前加params关键字的参数为可变参数 params 后面跟的一定是数组的形式 ,可以是一维数组和交错数组，二维数组不行
        {
           
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + "  ");
            }
        }

        static void Main(string[] args)
        {
            int[] arr1 = { 1, 2 };
            int[] arr2 = { 3, 4, 5 };
            int[] arr3 = { 5, 6, 7,8 };
            Test(arr1,arr2,arr3);   //交错数组形式接收参数

            Test1(1, 2, 3, 4, 5);   //一维数组形式接收参数

2.可变参数最多只能有一个

3.只能作为参数列表中，最后一个参数（即：可变参数放最后）。

函数重载

如果一个类或者结构体中有两个相同的函数就会报错

但当一个类或者结构体中存在两个或两个以上同名的函数，当这两个函数满足以下关系时，他们就构成了重载关系：

1.参数个数不同

        static void Test()
        {
            Console.WriteLine("无参的Test");
        }
        static void Test(int num)
        {
            Console.WriteLine("一个参数的Test");
        }
        static void Test(int n1, int n2)
        {
            Console.WriteLine("2个参数的Test");
        }

此时虽然函数名相同，但是构成了重载关系，所以不会报错

2.参数数据类型不同（分先后次序的）

        static void Sum(params float[] num)
        {
            float sum = 0;
            for (int i = 0; i < num.Length; i++)
            {
                sum += num[i];
            }
            Console.WriteLine("float总和是：{0}",sum);

        }
        static void Sum(params double[] num)
        {
            double sum = 0;
            for (int i = 0; i < num.Length; i++)
            {
                sum += num[i];
            }
            Console.WriteLine("double总和：{0}", sum);
        }

        static void Sum(params int[] num)
        {
            int sum = 0;
            for (int i = 0; i < num.Length; i++)
            {
                sum += num[i];
            }
            Console.WriteLine("int总和：{0}", sum);
        }

        static void Sum(params string[] num)
        {
            string sum = "";
            for (int i = 0; i < num.Length; i++)
            {
                sum += num[i];
            }
            Console.WriteLine("string总和：{0}", sum);
        }

        static void Main(string[] args)
        {

            #region 重载
            Sum(1.2f, 3.4f, 4.2f, 4.5f);
            Sum(2.3, 4.5, 6.4, 5, 6.3);
            Sum(1, 2, 3, 4, 5);
            Sum("h", "e", "l", "l", "o");

结果：

函数的递归

概念

函数直接或间接调用函数本身，则该函数称为递归函数

        static void Main(string[] args)
        {
            //Test(0);
            //Console.WriteLine(Factorial(5));
            //Console.WriteLine(FactorialSum(10));
            Console.WriteLine(GetLength(10));
            Console.ReadKey();
        }
        static void Test(int index)
        {
            index++;
            if (index > 10)
            {
                return;
            }
            //递归
            Test(index);
            Console.WriteLine(index);
        }
        //n!=n*(n-1)*(n-2)。。。。。。*1;
        //1.循环的条件是什么  2.结束的条件是什么
        //n*（n-1）  n=1
        static int Factorial(int n)
        {
            //结束的条件
            if (n==1)
            {
                return 1;
            }
            return n * Factorial(n - 1);
            //          
        }
        static int FactorialSum(int num)
        {
            if (num==1)
            {
                return 1;
            }
            //10!9!+8!+····1!
            //10!+(9个的和)
            //9!+(8个的和)
            return Factorial(num) + FactorialSum(num - 1);
        }
        //
        static float GetLength(int day)
        {
            //已知
            if (day==0)
            {
                return 100;
            }
            return  GetLength(day - 1) * 0.5f;

        }