Unity基础之C#基础篇笔记5：变长参数和参数默认值，函数重载_unity graphview 实现默认值

变长参数和参数默认值

1.函数语法复习

	1			2			3					4
static	返回类型	函数名(参数类型参数名1，参数类型参数名2，.......)
{
		函数的代码逻辑;
		函数的代码逻辑;
		函数的代码逻辑;
		.........;
			5
		return返回值;(如果有返回类型才返回)
}
1.静态关键词可选,目前对于我们来说必须写
2.返回值,没有返回值填void 可以填写任意类型的变量
3.函数名，帕斯卡命名法
4.参数可以是0~n个，前面可以加ref和out用来传递想要在函数内部改变内容的变量
5.如果返回值不是void，那么必须有return对应类型的内容，return可以打断函数语句块中的逻辑，直接停止后面的逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.变长参数关键字

变长参数关键字 params
1

        static int Sum(params int[] arr)
        {
            int sum = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                sum += arr[i];
            }
            return sum;
        }
        
        static void Main(string[] args)
        {
            Sum(1,2,3,4,5,6,7,8,9);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

params int[]意味着可以传入n个int参数，n可以等于0，传入的参数会存在arr数组中。
注意：
1.params关键字后面必为数组
2.数组的类型可以是任意的类型

        //static void Eat(params string name, params string[] things,int a)//报错
        //static void Eat(params string name, params string[] things)//报错
        static void Eat(string name,params string[] things)
        {

        }
1
2
3
4
5
6

3.函数参数可以有别的参数和 params关键字修饰的参数
4.函数参数中只能最多出现一个params关键字并且一定是在最后一组参数，前面可以有n个其它参数。

3.参数默认值

有参数默认值的参数—般称为可选参数
作用是当调用函数时可以不传入参数，不传就会使用默认值作为参数的值
1
2

        static void Speak(string str = "没话说！")
        {
            Console.WriteLine(str);
        }
        static void Main(string[] args)
        {
            Speak();
        	//打印结果：没话说！
            Speak("123123");
        	//打印结果：123123
        }
1
2
3
4
5
6
7
8
9
10
11

//注意:
1.支持多参数默认值每个参数都可以有默认值
2.如果要混用可选参数必须写在普通参数后面

4.总结

1：变长参数关键字 params
	 作用：可以传入n个同类型参数，n可以是0
	 注意：
		1. params后面必须是数组，意味着只能是同一类型的可变参数
		2．变长参数只能有一个
		3．必须在所有参数最后写变长参数
2：参数默认值(可选参数)
	 作用：可以给参数默认值使用时，可以不传参，不传用默认的，传了用传的
	 注意：
		1．可选参数可以有多个
		2．正常参数比写在可选参数前面，可选参数只能写在所有参数的后面
1
2
3
4
5
6
7
8
9
10
11

5.练习题

1.练习题1

使用param参数,求多个数字的和以及平均数
1

        static void CalcSumAvg(params int[] arr)
        {
            if(arr.Length==0)
            {
                Console.WriteLine("没有参数");
                return;
            }
            int sum = 0;
            float avg = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                sum += arr[i];
            }
            avg = (float)sum / arr.Length;
            Console.WriteLine("总和{0}，平均数{1}", sum, avg);
        }
        
        static void Main(string[] args)
        {
            CalcSumAvg(1, 2, 35, 9 , 6, 4, 8, 9);
			//打印结果：总和74，平均数9.25
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.练习题2

使用param参数,求多个数字的偶数和奇数的和
1

        static void Calc(params int[] arr)
        {
            if(arr.Length==0)
            {
                Console.WriteLine("没有参数");
                return;
            }
            int sum1 = 0;
            float sum2 = 0;
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] % 2 == 0)
                    sum2 += arr[i];
                else
                    sum1 += arr[i];
            }
            Console.WriteLine("奇数和{0}，偶数和{1}", sum1, sum2);
        }
        
        static void Main(string[] args)
        {

            Calc(12, 5, 6, 7, 8, 456, 78);
           //打印结果：奇数和12，偶数和560

        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

函数重载

1.基本概念

重载概念
在同一语句块(class或者struct)中
函数(方法)名相同
参数的数量不同
或者
参数的数量相同，但参数的类型或顺序不同
作用:
1.命名一组功能相似的函数，减少函数名的数量，避免命名空间的污染/
2.提升程序可读性 
1
2
3
4
5
6
7
8
9

2.实例

//注意:
1.重载和返回值类型无关,只和参数类型，个数，顺序有关
2.调用时程序会自己根据传入的参数类型判断使用哪一个重载
1
2
3

1.函数名相同，参数数量不同

        static int CalcSum(int a,int b,int c)
        {
            return a + b + c;
        }
        static int CalcSum(int a, int b)
        {
            return a + b;
        }
        static void Main(string[] args)
        {
            CalcSum(1, 2);
            CalcSum(1, 2, 3);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

2.参数数量相同，类型不同

        static int CalcSum(int a, int b)
        {
            return a + b;
        }

        static float CalcSum(float a,float b)
        {
            return a + b;
        }
         static float CalcSum(int a, float b)
        {
            return a + b;
        }
        static void Main(string[] args)
        {
            CalcSum(1, 2);
            CalcSum(1.1f, 2.3f);
            CalcSum(1, 2.3f);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.参数数量相同，顺序不同

		static float CalcSum(float f,int a)
        {
            return a + f;
        }
         static float CalcSum(int a, float f)
        {
            return a + f;
        }
        static void Main(string[] args)
        {
            CalcSum(1.1f, 2);
            CalcSum(1, 2.3f);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

4.ref 和out

ref和out可以理解成他们也是一种变量类型，所以可以用在重载中，但是ref和out不能同时修饰。
1

3.总结

总结
概念：同一个语句块中，函数名相同，参数数量、类型、顺序不同的函数就称为我们的重载函数
注意：和返回值无关
作用：—般用来处理不同参数的同一类型的逻辑处理
1
2
3
4

4.习题

1.练习1

请重载一个函数
让其可以比较两个int或两个float或两个double的大小并返回较大的那个值
1
2

        static int GetMax(int a,int b)
        {
            return a > b ? a : b;
        }
        static float GetMax(float a, float b)
        {
            return a > b ? a : b;
        }
        static double GetMax(double a, double b)
        {
            return a > b ? a : b;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(GetMax(1, 2));//2
            Console.WriteLine(GetMax(1.1f, 2.3f));//2.3
            Console.WriteLine(GetMax(10.3, 3.4));//10.3
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.练习2

请重载一个函数
让其可以比较n个int或n个float或n个double的大小
并返回最大的那个值。(用params可变参数来完成)
1
2
3

        static int GetMax(params int[] arr)
        {
            if(arr.Length==0)
            {
                Console.WriteLine("没有传入任何参数");
                return -1;
            }
            int max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (max < arr[i])
                    max = arr[i];
            }
            return max;
        }
        static float GetMax(params float[] arr)
        {
            if (arr.Length == 0)
            {
                Console.WriteLine("没有传入任何参数");
                return -1;
            }
            float max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (max < arr[i])
                    max = arr[i];
            }
            return max;
        }
        static double GetMax(params double[] arr)
        {
            if (arr.Length == 0)
            {
                Console.WriteLine("没有传入任何参数");
                return -1;
            }
            double max = arr[0];
            for (int i = 1; i < arr.Length; i++)
            {
                if (max < arr[i])
                    max = arr[i];
            }
            return max;
        }
         static void Main(string[] args)
        {
            Console.WriteLine(GetMax(1, 2,3,6,5,4));//6
            Console.WriteLine(GetMax(1.1f, 2.3f,5.3f));//5.3
            Console.WriteLine(GetMax(10.3, 3.4,56.3,3.2));//56.3
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

遗留问题：重载代码重复，后续泛型讲解会解决该问题