C#基础篇第七天

方法使用时注意

我们在Main()函数中调用Test()函数，我们称Main函数为调用者，称Test函数为被调用者。
如果被调用者想要得到调用者的值：

1. 传递参数
2. 使用静态字段来模拟全局变量

如果调用者想要得到被调用者的值：

1. 返回值

不管是形参还是实参都是在内存中开辟空间的。形参和实参必须保证类型一样，个数一样。
方法的功能一定要单一。

方法中的高级参数

1. Out参数
   如果你在一个方法中，返回多个相同类型的值得时候，可以考虑返回一个数组，但是，如果返回多个不同类型的值的时候，返回数组就不行了，那么这个时候，我们可以考虑使用out参数
   out参数就侧重于在一个方法中可以返回多个不同类型的值。
   示例：

namespace Out参数
{
    class Program
    {
        static void Main(string[] args)
        {
            //写一个方法，求一个数组中的最大值，最小值，总和，平均值
            //int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            将要返回四个值，放到一个数组中返回
            //int[] res = GetNumber(numbers);
            //Console.WriteLine("最大值是{0}，最小值是{1}，总和是{2}，平均值是{3}",res[0],res[1],res[2],res[3]);

            int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int max;
            int min;
            int sum;
            int avg;
            string name;
            Test(numbers, out max, out min, out sum, out avg,out name);
            Console.WriteLine(max);
            Console.WriteLine(min);
            Console.WriteLine(sum);
            Console.WriteLine(avg);
            Console.WriteLine(name);
            Console.ReadKey();
        }

        //方法一--当传出的参数是同一类型的时候可以用数组传参
        /// <summary>
        /// 求数组中的最大值，最小值，总和，平均值
        /// </summary>
        /// <param name="nums">传入一组数字</param>
        /// <returns>传出一个四元数组，表示最大值，最小值，总和，平均值</returns>
        public static int[] GetNumber(int[] nums)
        {
            int[] res = new int[4];
            //假设res[] 中{0}是存的最大值，{1}是存的最小值，{2}总和，{3}平均值
            res[0] = nums[0];    //max
            res[1] = nums[0];    //min
            res[2] = 0;          //he

            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] = res[2] + nums[i];
            }
            res[3] = res[2] / nums.Length;   //平均值
            return res;
        }

         //方法二--当传的参数是多个不同类型的时候用out方法
        /// <summary>
        /// 计算一个整数数组的最大，最小，平均，总和
        /// </summary>
        /// <param name="nums">要求值得数组</param>
        /// <param name="max">多余返回的最大值</param>
        /// <param name="min">多余返回的最小值</param>
        /// <param name="sum">多余返回的总和</param>
        /// <param name="avg">多余返回的平均值</param>
        /// <param name="name">多余返回string型的姓名</param>
        public static void Test(int[] nums, out int max, out int min, out int sum, out int avg,out string name)
        {
            max = nums[0];
            min = nums[0];
            sum = 0;
            name = "张三";
            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;
        }
    }
}

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

namespace @ref
{
    class Program
    {
        static void Main(string[] args)
        {
            double salary = 5000;
          JiangJin(ref salary);
          Console.WriteLine(salary);
          Console.ReadKey();
        }

        public static void JiangJin(ref double s)
        {
            s = s + 500;
        }

        public static void FaKuan(double s)
        {
            s = s - 500;
        }
    }
}

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

namespace Params可变参数
{
    class Program
    {
        static void Main(string[] args)
        {
            GetSum("李四", 10, 20, 30, 40);
            Console.ReadKey();
        }
        public static void GetSum(string name,int id,params int[] score)  //这样id就是10,score数组就是{20,30,40}
        {
            int sum=0;
            for (int i = 0; i < score.Length; i++)
            {
                sum += score[i];
            }
            Console.WriteLine("{0}的总成绩是{1},id是{2}",name,sum,id);
        }
    }
}

方法的重载

方法的重载指的就是方法的名称相同，参数不同。
如果参数的个数相同，那么参数的类型就不能相同
如果参数的类型相同，那么参数的个数就不能相同
和方法的返回值类型无关。

方法的综合练习例题

namespace 方法的综合练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //提示用户输入两个数字，计算这两个数字之间所有整数的和。用户只能输入数字,并且第一个数字要小于第二个数字
            Console.WriteLine("请输入第一个数字");
            string strNumberOne = Console.ReadLine();
            int NumberOne=GetNumber(strNumberOne);
            Console.WriteLine("请输入第二个数字");
            string strNumberTwo = Console.ReadLine();
            int NumberTwo = GetNumber(strNumberTwo);
            JudgeNumber(ref NumberOne,ref NumberTwo);
            int sum = GetSum(NumberOne, NumberTwo);
            Console.WriteLine(sum);
            Console.ReadKey();
        }

        /// <summary>
        /// 求两个整数之间所有整数的和
        /// </summary>
        /// <param name="n1">第一个整数</param>
        /// <param name="n2">第二个整数</param>
        /// <returns>两个整数之间所有整数的和</returns>
        public static int GetSum(int n1, int n2)
        {
            int sum = 0;
            for (int i = n1; i <=n2; i++)
            {
                sum += i;
            }
            return sum;
        }


        /// <summary>
        /// 判断两个整数的大小，并保证第一个小于第二个
        /// </summary>
        /// <param name="n1">输入的第一个整数</param>
        /// <param name="n2">输入的第二个整数</param>
        public static void JudgeNumber(ref int n1,ref int n2)
        {
            if (n1 <n2)
            {
                return;
            }
            else
            {
                Console.WriteLine("两个数字的大小输入有误。");
                Console.WriteLine("请输入第一个数字：");
                string s1=Console.ReadLine();
                n1 = GetNumber(s1);
               
                Console.WriteLine("请输入第二个数字");
                string s2 = Console.ReadLine();
                n2 = GetNumber(s2);
            }
        }


        /// <summary>
        /// 将输入的字符串转换成整形
        /// </summary>
        /// <param name="s">输入的字符串</param>
        /// <returns>整形的数字</returns>
        public static int GetNumber(string s)
        {
            while(true)
            {
                try
                {
                int Number=Convert.ToInt32(s);
                    return Number;
                }
                catch
                {
                    Console.WriteLine("输入有误，请重新输入！");
                    s = Console.ReadLine();
                }
            }
        }
    }
}

欢迎评论区留言讨论