C#之函数（方法）详解

一、语法介绍

1、为什么使用函数

2、函数体介绍

3、函数的定义和使用

4、带参和无参

5、参数不确定长度的方法

6、结构函数

7、函数的重载（Overload）:函数名相同，参数不同，返回值无所谓

8、委托

二、语法实践

using System;

namespace 函数定义使用
{
    /// <summary>
    /// 结构体函数
    /// </summary>
    struct CalculatDistance
    {
        public float x;
        public float y;
        public float z;

        /// <summary>
        /// 计算向量长度
        /// </summary>
        /// <returns></returns>
        public double Distance()
        {
            return Math.Sqrt(x * x + y * y + z * z);
        }
    }

    delegate double myDelegate(double par1, double par2);

    class Program
    {
        static void Main(string[] args)
        {
            OutPutLog();//无法无返回值

            int num1 = PlusNum(3, 4);//带固定长度参带返回值
            Console.WriteLine("调用PlusNum函数的结果是：" + num1);

            //带不固定参数长度带返回值
            int[] tempArr = new int[] { 32, 5, 866, 23, 9, 76 };
            int num2 = Sum(23, 5436, 547, 235, 658);
            Console.WriteLine("调用Sum函数直接传参的结果是：" + num2);
            int num3 = Sum(tempArr);
            Console.WriteLine("调用Sum函数传递数组的结果是：" + num3);

            //结构体函数实践
            CalculatDistance calculatDistance;
            calculatDistance.x = 3;
            calculatDistance.y = 4;
            calculatDistance.z = 5;
            Console.WriteLine("使用结构体函数计算向量的结果是：" + calculatDistance.Distance());

            //重载
            OverMath(2.3f, 34);
            OverMath(4, 5);

            //委托
            double do1 = 13.45;
            double do2 = 23.67;
            myDelegate de;
            de = Delegate1;
            de(do1, do2);
            de = Delegate2;
            de(do1, do2);

            //递归调用
            int mNum = F(40);
            Console.WriteLine("递归调用40的结果是：" + mNum);

            Console.ReadKey();
        }

        /// <summary>
        /// 不带参数没有返回值的方法
        /// </summary>
        static void OutPutLog()
        {
            Console.WriteLine("这是一个无参的空方法体");
        }

        /// <summary>
        /// 返回值为int,参数类型和参数数量确定的方法
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        static int PlusNum(int a, int b)
        {
            return a + b;
        }

        /// <summary>
        /// 参数为参数数组类型，可用于不确定长度的参数传递
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        static int Sum(params int[] array)
        {
            int temp = 0;
            for (int i = 0; i < array.Length; i++)
            {
                temp += array[i];
            }
            return temp;
        }

        static void OverMath(int a, int b)
        {
            Console.WriteLine("这个是两个int类型的数字相乘的结果：" + (a * b));
        }

        static void OverMath(float a, double b)
        {
            Console.WriteLine("这个是一个float 一个double类型的数字相乘的结果：" + (a * b));
        }

        static double Delegate1(double dou1, double dou2)
        {
            Console.WriteLine("计算两个数相乘的结果是:" + dou1 * dou2);
            return dou1 * dou2;
        }

        static double Delegate2(double dou1, double dou2)
        {
            Console.WriteLine("计算两个数相除的结果是:" + dou1 / dou2);
            return dou1 / dou2;
        }

        /// <summary>
        /// 递归调用
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        static int F(int n)
        {
            //递归终止条件
            if (n == 0) return 2;
            if (n == 1) return 3;
            //返回值
            return F(n - 1) + F(n - 2);
        }
    }
}