递归函数的使用：

public static int i = 0; //定义一个静态变量
public static void Test()//定义静态函数
{
Console.WriteLine("从前有座山");
Console.WriteLine("山上有座庙");
Console.WriteLine("庙里有一个老和尚，在该小和尚讲故事");
Console.WriteLine("故事的内容是:");
if (i > 5)
{
return; //没有返回任何的返回值，这里仅仅是为了跳出函数
}
i++;
Test(); //函数的递归
}/*1.递归函数简单的理解就是在函数体中调用自己函数本身，相当于一层一层的嵌套，但是在进行返回的时候，也需要一层一层的退出*/

运行结果:

 out参数修饰符的使用：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _03out参数
{
class Program
{
static void Main(string[] args)
{
#region 返回值是同一类型的数据，通常使用数组进行接收
//int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//int[] res = new int[4]; //用于接收返回值
//res = GetMaxMinSumAvg(nums );
//Console.WriteLine("最大值：{0},最小值：{1}，总数：{2}，平均值{3}",res[0],res[1],res[2],res[3]);
//Console.ReadKey();
#endregion

#region 计算数组的最大值、最小值、平均值、总和，并且返回的数据的类型是不同的

//int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
////这里的变量不用进行赋值，在函数调用中将会被赋值
//int max;
//int min;
//int sum;
//int avg;
//string grade;
//GetMaxMInSumAvg(nums, out max, out min, out sum, out avg, out grade);
//Console.WriteLine("最大值：{0}，最小值{1}，平均值{2}，总数{3},等级为{4}", max, min, avg, sum,grade);
//Console.ReadKey();
#endregion

//使用自己编写的数据类型转换函数进行数据的转换：
Console.WriteLine("请输入需要转换的数值：");
string str = Console.ReadLine();
int result;
bool b = MyTryParse(str,out result );
Console.WriteLine("转换后的整数{0}，是否转换成功{1}",result,b );
Console.ReadKey();
}

/// <summary>
/// 计算一个数字中的最大值、最小值、总数、平均值 ,返回的值都是同一类型的数据
/// </summary>
/// <param name="nums">函数的形式参数，需要参与计算的数组</param>
/// <returns>计算结果的返回值</returns>
public static int[] GetMaxMinSumAvg(int[] nums)
{
int[] res = new int[4];
res[0] = nums[0]; //max
res[1] = nums[0]; //min
res[2] = 0; //sum
for (int i = 0; i < nums.Length; i++)
{
if (nums[i] > res[0])
{

res[0] = nums[i];
}
if (nums[i] < res[1])
{

res[1] = nums[i];
}

res[2] += nums[i];
}
res[3] = res[2] / nums.Length;
return res;  //返回一个数组
}
/// <summary>
/// 计算数组的最大值、最小值、平均值 以及总数，并且返回的参数的类型是不同的类型，对于返回参数不同通常使用out修饰符号将不同的参数进行返回
/// </summary>
/// <param name="nums"></param>
/// <param name="max"></param>
/// <param name="min"></param>
/// <param name="sum"></param>
/// <param name="avg"></param>
public static void GetMaxMInSumAvg(int[] nums, out int max, out int min, out int sum, out int avg, out string grade)
{
max = nums[0];
min = nums[0];
sum = 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;
if (sum > 90)
{
grade = "优秀";
}
else
{

grade = "loser";

}
}
/// <summary>
/// 数据类型的转换，实现自己的TryParse()，将字符串转换称为数字
/// </summary>
/// <param name="str"> 需要转换的字符串</param>
/// <param name="result"> 转换以后返回的结果</param>
/// <returns></returns>
public static bool MyTryParse(string str,out int result )
{
result = 0;
try
{
result = Convert.ToInt32(str);
return true ;
}
catch {
return false;
}
}

}
}

ref修饰符的使用：

{
static void Main(string[] args)
{
//交换两个变量
int n1 = 20;
int n2 = 13;
Ecxchange(ref n1,ref n2);
Console.WriteLine("交换后的数据：{0}\t{1}",n1 ,n2);
Console.ReadKey();
}
/// <summary>
/// 交换传入的两个参数值
/// </summary>
/// <param name="n1"> 第一个参数</param>
/// <param name="n2">第二个参数</param>
public static void Ecxchange(ref int n1,ref int n2) {

int temp;
temp = n1;
n1 = n2;
n2 = temp;

}
}

/* 1.总结; ref关键字的作用是将带入的参数进行值的改变，将改变后的结果带出
* 2.在进行参数传入的时候必须进行附初始值*/

params修饰符号的使用：

static void Main(string[] args)
{
int[] nums = { 45, 56, 78, 89, };
int sum=GetSum("张三",2,56,6,78); //虽然该函数的形式参数是数组，但是在使用params的时候可以直接参数一串数字
Console.WriteLine("总分数{0}", sum);
Console.ReadKey();
}
/// <summary>
/// 计算非特定长度数组中的数据的总和
/// </summary>
/// <param name="nums"> 非特定数组</param>
/// <returns>返回的计算结果</returns>
public static int GetSum(string name ,int id ,params int [] nums)
{
int sum = 0;
for (int i = 0; i < nums .Length; i++)
{
sum += nums[i];
}
return sum;
}
}

注意：

/*
1. params 将同一类型的数据转换成为该类型的数组，并且在作为形式参数类型的时候，放在参数列表的最后面，
2.参数列表中有且只有一个这样类型的参数
*/

运行结果：

方法的重载:

static void Main(string[] args)
{
int n1 = 10;
int n2 = 54;
string str1 = "Hello";
string str2 = "World";
Console.WriteLine(GetSum(n1,n2));
Console.WriteLine(Getsum(str1 ,str2));
Console.ReadKey();
}
public static int GetSum(int n1, int n2)
{
return n1 + n2;
}
public static string Getsum(string str1, string str2)
{

return str1 + str2;
}

/*1.方法的重载，其方法的名称必须是相同的，但是参数的类型，和参数的个数必须有一个是不同的，这样才能曾为是方法的重载

2.方法的重载与方法的返回值无关
*/