(7)C#传智：方法及参数、重载(第7天)

最新推荐文章于 2024-05-14 22:33:43 发布

dzweather

最新推荐文章于 2024-05-14 22:33:43 发布

阅读量393

点赞数

分类专栏： C#传智入门文章标签： c# 开发语言

本文链接：https://blog.csdn.net/dzweather/article/details/129203218

版权

C#传智入门专栏收录该内容

23 篇文章 15 订阅

订阅专栏

一、方法作用域
被调用者需要调用者的值,方法有二:
1.传参数.

        private static void Main(string[] args)
        {
            int m = 3;
            Console.WriteLine(m);
            Console.ReadKey();
        }

        public static int GetMax(int m)
        {
            return m + 3;
        }

   2.使用静态字段模拟全局.
       多个方法都需要时，可以用静态字段/全局变量避免传递参数.

       若调用者需要被调用者的值，方法二：
       1）.返回值。return 值;

        private static void Main(string[] args)
        {
            int a, m = 0;
            a = Test(m);//返回值可以作用于a
            Console.WriteLine("{0},{1}", m, a);//0,3
            Console.ReadKey();
        }

        public static int Test(int m)
        {
            m += 3;
            return m;//此中m仅作用于本函数
        }

   3.全局或静态变量
       形参与实参名称相同与否，无关紧要。两者类型一一对应，均需在内存开辟空间。

       break语句将终止最接近的封闭迭代语句（即for、foreach、while 或do循环）或switch语句。
       break语句将控制权转交给已终止语句后面的语句（若有）。

       方法的功能一定要单一，只能做一件事。
       方法最忌讳的就是出现提示用户输入的字眼。因为有些仅限于控制台，尽量避免。


二、三个高级参数
   out、ref、param

   1.out 必须在方法内部赋值
       返回多个相同类型的值时，可以用返回数组的方式：

        private static void Main(string[] args)
        {
            int[] num = { 1, 2, 3, 4, 5, 6 };
            int[] res = GetM(num);
            Console.WriteLine("{0},{1},{2},{3}", res[0], res[1], res[2], res[3]);
            Console.ReadKey();
        }

        public static int[] GetM(int[] num)
        {
            int[] res = new int[4];//0最大1最小2总和3平均
            res[0] = num[0]; res[1] = num[0]; res[2] = 0;
            for (int i = 0; i < num.Length; i++)
            {
                if (num[i] > res[0]) { res[0] = num[i]; }
                if (num[i] < res[1]) { res[1] = num[i]; }
                res[2] += num[i];//总和
            }
            res[3] = res[2] / num.Length;//平均
            return res;
        }

但如果是返回多个不同类型时，数组就不适用了。这时用out参数
形参与实参必须都要带out关键字。out的个数与类型必须一一对应.
实参可以不必先赋值，因为在调用的返回时会赋值（与方法返回值无关）。

        private static void Main(string[] args)
        {
            int[] num = { 1, 2, 3, 4, 5, 6 };
            int max1, min1, sum1, avg1;//要接收返回值的多个不同类型，不必赋初值.
            Test(num, out max1, out min1, out sum1, out avg1);//out不得省略
            Console.WriteLine("{0},{1},{2},{3}", max1, min1, sum1, avg1);
            Console.ReadKey();
        }

        public static void Test(int[] num, out int max, out int min, out int sum, out int avg)
        {
            max = num[0]; min = num[1]; sum = 0; //out参数已经声明，不能再次声明，但必须赋值.
            for (int i = 0; i < num.Length; i++)
            {
                if (num[i] > max) { max = num[i]; }
                if (num[i] < min) { min = num[i]; }
                sum += num[i];//总和
            }
            avg = sum / num.Length;// 无需再写return，这就是out返回多参数的优点
        }

提示登陆

        private static void Main(string[] args)
        {
            Console.WriteLine("请输入用户名:"); string user = Console.ReadLine();
            Console.WriteLine("请输入密码:"); string password = Console.ReadLine();
            LandState(user, password, out string state);//可以out中声明
            Console.WriteLine(state);
            Console.ReadKey();
        }

        public static void LandState(string user, string password, out string state)
        {
            if (user == "admin" && password != "8888") state = "密码错误";
            else if (user != "admin" && password == "8888") state = "用户名错误";
            else if (user == "admin" && password == "8888") state = "登录成功";
            else state = "登陆错误"; // 一条语句可省略{}
        }

下面的正则写法(bool与ourt中的stirng，不同类型)

        public static bool LandState(string user, string password, out string state)
        {
            if (user == "admin" && password != "8888")
            {
                state = "密码错误";
                return false;
            }
            else if (user != "admin" && password == "8888")
            {
                state = "用户名错误";
                return false;
            }
            else if (user == "admin" && password == "8888")
            {
                state = "登录成功";
                return true;
            }
            else
            {
                state = "登陆错误"; // 一条语句可省略{}
                return false;
            }
        }

注：int.Tryparse("3333",out n)
           将字串转为整形：成功返回true,n为整数;失败返回false,n为0.
           实际上这个也是用了out参数调用，在方法中用了try-catch进行捕获赋值.

   2.ref 引用传参
       能将变量带入方法中，并接受其中的变化。类似于指向内存地址的指针，
       所以变量在内存必须分配空间，故在使用ref调用前必须赋值，out则不必但在方法内赋值.
       注意：尽管类似指针，但不是指针值，还是实际的数，其中的指向由vs自己指定

        private static void Main(string[] args)
        {
            double a = 500, b = 500;
            RefTest(ref a);//加了ref表示指针引用，可以带回主函数
            Test(b);//Test方法中的b无法带回到主函数
            Console.WriteLine("{0},{1} ", a, b);//502,500
            Console.ReadKey();
        }

        public static void RefTest(ref double a)//引用
        {
            a += 2;
        }

        public static void Test(double b)
        {
            b += 1;
        }

不借助第三变量，交换两个数：

            int a = 10, b = 20, temp;
            a = b + (b = a) * 0;//(b=a)先b=a,再返回b，即先b=10,返回整体10.

            (a, b) = (b, a);//元组tuple

            a = a ^ b;//异或
            b = a ^ b;
            a = a ^ b;

            a = a + b;//和值
            b = a - b;
            a = a - b;

            a = a - b;//差值
            b = a + b;
            a = a - b;

3.params 把实参序列组成形参中的长度可变数组.params必须只能在参数最后.
这样让实参序列可长可短。由此可知参数中最有只能有一个可变参数.

        private static void Main(string[] args)
        {
            int[] n = { 1, 3, 4, 5, 6 }; //无params时需要用此句为实参
            GetSum("大王", n);//也可直接传数组
            GetSum("张三", 88, 22, 99);
            GetSum("李四", 22, 33, 44, 5, 66, 77, 8);//最后长度可变
            Console.ReadKey();
        }

        public static void GetSum(string name, params int[] n)
        {//params把后继的序列作了数组n的元素,故params必须在形参最后
            int sum = 0;
            for (int i = 0; i < n.Length; i++) sum += n[i];//仅一句时也可不用{}
            Console.WriteLine("{0}的总成绩为{1}", name, sum);
        }

三、方法的重载
   方法的名称相同，但参数不同。
   避免同样的方法，使用不同的方法，把调用时统一起来.

   参数不同的情况：
   1.参数个数相同，类型不差异；
   2.参数类型相同，个数不能相同.
   注：方法的返回值与重载没有关系。

        private static void Main(string[] args)
        {
            int a = 1, b = 2;
            double c = 1.1, d = 1.2;
            Console.WriteLine(GetPlug(a, b));
            Console.WriteLine(GetPlug(c,d));
            Console.ReadKey();
        }

        public static int GetPlug(int a, int b)
        { return a + b; }

        public static double GetPlug(double a, double b)
        { return a + b; }

        public static string GetPlug(string a, string b)
        { return a + b; }

        public static int GetPlug(int a, int b, int c)
        { return a + b + c; }

四、方法的递归
       方法自己调用自己，必须有终点。
       例如用静态来计数判断终点。