函数

一般构成

访问修饰符 静态 返回值 函数名(参数...){ 函数体 };

访问修饰符有三个可选值：public / protected / private。决定了对于另一个类的可见性

静态: static。可有可无

返回值: 函数最终会返回的数据类型

参数: 可有可无。理论上可以有无数参数。声明时：数据类型 变量名

函数体: 一些可执行的代码

访问修饰符如果不写的话默认是private的

public class App
{
  static void add(int a, int b) // 声明函数的时候要声明参数
  {
    Console.WriteLine(a + b);
  }
  static void Main()
  {
    add(1, 2);

    Console.ReadKey();
  }    
}

参数数组、数组参数

参数数组：传进多个参数形成一个数组

数组参数：传进一个参数，类型为数组

public class App
{
  static void add(params int[] numbers)
  {
    Console.WriteLine(numbers[0] + numbers[1]);
  }

  static void add2(int[] numbers)
  {
    Console.WriteLine(numbers[0] + numbers[1]);
  }
  static void Main()
  {
    add(1, 2);
    add2(new int[2] {3,4});

    Console.ReadKey();
  }    
}

函数重载

上面的例子里写了两个add方法，实际上，这种参数个数不同、类型不同的函数可以写成同名的。这叫做函数重载。

就像回家一样，可以有多种不同的方式(看做参数)回家，但实际上都是"回家"

public class App
{
  static void add(params int[] numbers)
  {
    Console.WriteLine(numbers[0] + numbers[1]);
  }

  static void add(float[] numbers)  // 类型改成了float，否则类型相同，会报错
  {
    Console.WriteLine(numbers[0] + numbers[1]);
  }
  static void Main()
  {
    add(1, 2);
    add(new float[2] {3.2F,4.3F});  // 创建的类型当然也要修改

    Console.ReadKey();
  }    
}

递归

函数调用自己可以达到递归计算的效果。

例如：写个递归函数，可以从1累加到10

public class App
{
  static void add(int a, int b)
  {
    b = b + 1;
    a = a + b;
    Console.WriteLine(a);

    if (b != 10) {  // 注意控制，不要陷入无限的递归调用。良好的习惯是先写好终结语句
      add(a, b);
    }
  }
  static void Main()
  {
    add(1, 1);

    Console.ReadKey();
  }    
}