C#函数

//以一个demo开始吧
//Main方法，程序的入口
static void Main(string[] args)
        {
            int a = 3;
            int res = Test(a);
            Console.WriteLine(res);
        }
//自定义一个简单的方法，传值+5返回
public static int Test(int a)
        {
            a = a + 5;
            return a;
        }

1、我们在Main()函数中，调用Test()函数，我们管Main()函数称之为调用者，管Test()函数称之为被调用者。

如果被调用者想要得到调用者的值有两种方式：
1)、传递参数。
2)、使用静态字段来模拟全局变量。

如果调用者想要得到被调用者的值：
1)、通过返回值

这里有几个说明的：
1、不管是实参还是形参，都是在内存中开辟了空间的。
2、方法的功能一定要单一，方法中最忌讳的就是出现提示用户输入的字眼。

——out、ref、params参数
1)、out参数。
如果你在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组。
但是，如果返回多个不同类型的值的时候，返回数组就不行了，虽然可以返回一个ArrayList，但是在调用的时候一般要发生拆箱，影响性能，那么这个时候，我们可以考虑使用out参数。
out参数就侧重于在一个方法中可以返回多个不同类型的值。

//写一个方法来计算一个数组的最大值，最小值，平均值，并返回
//当然这里可以返回数组来返回多个值，但是我们还是用out来返回吧
static void Main(string[] args){
     double min;
            double max;
            double avg;
            GetMinMaxAvg(new double[] { 1, 2, 3, 4, 5 }, out min, out max, out avg);
            Console.WriteLine("最小值:{0};最大值:{1};平均值:{2}",min,max,avg);
            Console.ReadKey();
//输出   最小值:1;最大值:5;平均值:3
}

public static void GetMinMaxAvg(double[] nums,out double min,out double max,out double avg) {
            double sum = 0;
            min = nums[0];
            max = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] > max)
                    max = nums[i];
                if (nums[i] < min)
                    min = nums[i];
                sum += nums[i];
            }
            avg = sum / nums.Length;
            //注意一下，out修饰的参数形参和传递实参都要用out修饰
            //out 修饰的形参必须保证在方法结束前赋值
            //out修饰的参数不能给方法传带有值的实参，就算有值也传递不进去，在方法内使用也需要提前赋值
        }

2)、ref参数
能够将一个变量带入一个方法中进行改变，改变完成后，再将改变后的值带出方法。
ref参数要求在方法外必须为其赋值，而方法内可以不赋值。

//把交换两个数的过程封装成方法
static void Main(string[] args){
//ref参数要求在方法外必须为其赋值
 int n1 = 10;
 int n2 = 9;
 Test(ref n1,ref n2);
 Console.WriteLine("{0}------{1}",n1,n2);
 //输出  9------10
}

public static void Test(ref int n1,ref int n2){
    n1 += n2;
    n2 = n1 - n2;
    n1 -=n2;
}

3)、params可变参数
将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理。
params可变参数必须是形参列表中的最后一个元素。

//一个方法，传入一个人名，再传入任意多个int类型的成绩，最后返回成绩
static void Main(string[] args){
        Test("张三", 99, 100, 100, 100);
        //输出  张三这次考试的总成绩是300,学号是99
}

public static void Test(string name, int id, params int[] score)
        {
            int sum = 0;
            for (int i = 0; i < score.Length; i++)
            {
                sum += score[i];
            }
            Console.WriteLine("{0}这次考试的总成绩是{1},学号是{2}", name, sum, id);
        }

一般在对任意多个参数做相同的处理的时候，就考虑使用怕params可变参数

——方法的重载
概念：方法的重载指的就是方法的名称相同给，但是参数不同。

参数不同，分为两种情况：
1)、如果参数的个数相同，那么参数的类型就不能相同。
2)、如果参数的类型相同，那么参数的个数就不能相同。
注意：方法的重载跟返回值没有关系

        public static double M(double d1, double d2)
        {
            return d1 + d2; //双精度浮点数相加
        }
        public static void M(int n1, int n2, int n3)
        {
            int result = n1 + n2 + n3;//整数相加
        }
        public static string M(string s1, string s2)
        {
            return s1 + s2;//字符串拼接
        }

方法在调用的时候会根据参数的类型和数目不同自动选择对应方法进行执行

——方法的递归
递归的概念很简单：就是方法自己调用自己。

来举个例子，讲一个很老的故事

 public static int i = 0;//这是全局的变量
public static void TellStory()
        {
            Console.WriteLine("从前有座山");
            Console.WriteLine("山里有座庙");
            Console.WriteLine("庙里有个老和尚和小和尚");
            Console.WriteLine("有一天，小和尚哭了，老和尚给小和尚讲了一个故事");
            i++;
            if (i >= 10)
            {
                return;
            }
             TellStory();
        }
//哈哈哈，写到这里我都笑了，打印上面的方法会给你讲十个故事，跟循环很像哈，只是这个例子跟循环的结果很像而已，递归可不止这点魅力