首页 > 代码库 > 02.方法的高级参数

02.方法的高级参数

2024-08-18 13:16:03   223人阅读

out ,ref, params

out的用法
(1)out用于在方法的内部必须为外部的变量赋值.
(2)out一般用于函数需要有多个返回值的场合.

如果在方法中,返回多个相同类型的值的时候,可以考虑返回一个数组.
但是,如果返回多个不同类型的值的时候,返回数组就不行了.这个时候
就可以考虑使用out来实现.

out代码示例:
  1. namespace _03.out的使用
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             //写一个方法 求一个数组的最大值,最小值,总和,平均值
  8.             int sum;
  9.             int avg;
  10.             int max;
  11.             int min;
  12.             int[] intArray = new int[] { 12,15,34,75,45,74,354,6,3,7,1};
  13.             Test(intArray, out max, out min, out sum, out avg);
  14.             Console.WriteLine("最大值为:{0},最小值为:{1},总和为:{2},平均值为:{3}",max,min,sum,avg);
  15.             Console.ReadKey();
  16.         }
  18.         /// <summary>
  19.         /// 计算一个整数数组的最大值,最小值,平均值,总和 
  20.         /// </summary>
  21.         /// <param name="a">需要计算的数组</param>
  22.         /// <param name="max">方法会返回的最大值</param>
  23.         /// <param name="min">方法会返回的最小值</param>
  24.         /// <param name="sum">方法会返回的总和</param>
  25.         /// <param name="avg">方法会返回的平均值</param>
  26.         public static void Test(int[] a,out int max,out int min,out int sum,out int avg)
  27.         {
  28.             //out 参数要求,必须在方法中为外部变量赋值
  29.             max = a[0];   //假定传进来的数组中第一个元素就是最大值
  30.             min = a[0];   //假定传进来的数组中第一个元素就是最小值
  31.             sum = 0;    //假定和为0
  32.             avg = 0;    //假定平均值为0  
  33.             for (int i = 0; i < a.Length; i++)
  34.             {
  35.                 if (a[i] > max)
  36.                 {
  37.                     max = a[i];
  38.                 }
  39.                 else if (a[i] < min)
  40.                 {
  41.                     min = a[i];
  42.                 }
  43.                 sum += a[i];
  44.             }
  45.             avg = sum / a.Length;
  46.         }
  47.     }
  48. }
技术分享
 
out的实际练习01:
  1. namespace _04.out的练习01
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             //写一个方法来判断用户输入的是否正确
  8.             //返回给用户一个登陆结果,并且还要单独的返回给用户一个登陆信息
  9.             //如果用户名错误,除了返回登陆结果之外,还要返回一个"用户名错误"
  10.             //如果密码,错误,除了返回登陆结果之外,还要返回一个"密码错误"
  11.             string Message = null;  //用于接受返回信息
  12.             string Login = null;    //用于接收登陆结果
  13.             Console.WriteLine("请输入有户名:");
  14.             string name = Console.ReadLine();
  15.             Console.WriteLine("请输入密码:");
  16.             string pwd = Console.ReadLine();
  17.             Login=PanDuan(name, pwd, out Message);    //获取登陆的所有信息
  18.             Console.WriteLine("登陆的信息:{0},{1}",Login,Message);
  19.             Console.ReadKey();
  23.         }
  24.         /// <summary>
  25.         /// 对用户的用户名和密码进行相应的判断
  26.         /// </summary>
  27.         /// <param name="name">用户名</param>
  28.         /// <param name="pwd">用户密码</param>
  29.         /// <param name="Message">登陆的信息</param>
  30.         /// <returns>登的状态</returns>
  31.         public static string PanDuan(string name,string pwd,out string Message)
  32.         {
  33.             if (name != "admin")
  34.             {
  35.                 Message = "用户名错误";    //使用out参数,必须在方法体的内部为其赋值
  36.                 return "登陆失败";
  37.             }
  38.             else if (pwd != "88888")
  39.             {
  40.                 Message = "密码错误";    //使用out参数,必须在方法体的内部为其赋值
  41.                 return "登陆失败";
  42.             }
  43.             else
  44.             {
  45.                 Message = "";         //使用out参数,必须在方法体的内部为其赋值
  46.                 return "登陆成功";
  47.             }
  48.         }
  49.     }
  50. }


out的实际练习02:
  1. namespace _05.实现MyTryParse的功能
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             //TryParse();方法的功能是把string类型转换成想转换的基本类型,如果转换成功,
  8.             //将转换的值,赋给后面的参数,并且返回true,如果转换失败,这给后面的参数赋值为0
  9.             //并且返回false.
  10.             //例如:
  11.             //int number=0;
  12.             //int.TryParse("222", out number);   //如果转换成功,字符串"222"的值将转换成222并赋值给number
  13.             //现在实现上述功能
  15.             string str = null;   //用于接收用户输入的值
  16.             int numI = 0;  //用于保存转换后的整型值
  17.             double numD = 0;  //用于保存转换后的双进度型的值
  18.             bool b = true;  //用于记录是否转换成功
  19.             Console.WriteLine("请输入需要转换的数值:");
  20.             str=Console.ReadLine();
  21.             b = MyTryParse(str, out numD);
  22.             Console.WriteLine("是否转换成功:{0},转换后的结果:{1}.",b,numD);
  23.             Console.ReadKey();
  25.         }/// <summary>
  26.         /// 将用户输入的字符型 转换成基本数据类型 int
  27.         /// </summary>
  28.         /// <param name="str">需要转换的字符串</param>
  29.         /// <param name="number">需要转换的字符串</param>
  30.         /// <returns>转换是否成功</returns>
  31.         public static bool MyTryParse(string str, out int number)
  32.         {
  33.             try
  34.             {
  35.                 number = int.Parse(str);
  36.                 return true;
  37.             }
  38.             catch
  39.             {
  40.                 number = 0;
  41.                 return false;
  42.             }
  43.         }
  44.         /// <summary>
  45.         /// 将用户输入的字符型 转换成基本数据类型 double
  46.         /// </summary>
  47.         /// <param name="str">需要转换的字符串</param>
  48.         /// <param name="number">需要转换的字符串</param>
  49.         /// <returns>转换是否成功</returns>
  50.         public static bool MyTryParse(string str, out double number)
  51.         {
  52.             try
  53.             {
  54.                 number = double.Parse(str);
  55.                 return true;
  56.             }
  57.             catch
  58.             {
  59.                 number = 0;
  60.                 return false;
  61.             }
  62.         }
  63.     }
  64. }

ref的用法
能够将一个变量带入到一个方法中进行改变,改变完成之后,再将改变后的值带出方法.
这样一来,我们在将变量通过ref带入到方法之前,必须要为这个变量赋值.

ref的练习1:
  1. namespace _06.ref的使用
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             //使用方法来交换两个int类型的变量
  8.             int a = 10;
  9.             int b = 20;
  10.             JiaoHuan(ref a,ref b);
  11.             Console.WriteLine("a的值为:{0},b的值为:{1}.",a,b);
  12.             Console.ReadKey();
  14.         }
  16.         /// <summary>
  17.         /// 交换两个整型变量
  18.         /// </summary>
  19.         /// <param name="a">需要交换的数a</param>
  20.         /// <param name="b">需要交换的数b</param>
  21.         public static void JiaoHuan(ref int a, ref int b)   //ref的作用是将有值得变量带入到方法中,进行改变,再将改变后的值带出
  22.         {
  23.             int temp = 0;
  24.             temp = a;
  25.             a = b;
  26.             b = temp;
  27.         }
  28.     }
  29. }
技术分享
 

params的用法
一个方法可以有多个参数,但是一定要记住使用params修饰的可变参数数组一定放在最后一个位置.
params可变参数:
将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理.

Params可变参数的练习1:
  1. namespace _07.Parames可变参数
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             //需求:
  8.             //我们现在要计算期末成绩,可是成绩是一门一门的出来
  9.             //可是我现在就要计算现在出来的成绩,但是后面加入的成绩
  10.             //以后也要进入计算
  11.             //总结:
  12.             //这个是时候,我们就不能再使用数组来装成绩了,因为我们
  13.             //不确定有几门课成绩需要计算
  14.             //就方法而言这个时候,我们就可以使用可变参数来解决这一问题
  16.             int sum = 0;
  17.             sum=Sum(80, 70, 90, 100);
  18.             Console.WriteLine("总成绩为:{0}.",sum);
  19.             Console.ReadKey();
  20.         }
  22.         public static int Sum(params int[]a)
  23.         {
  24.             int sum = 0;  //用来将传进来的成绩求和保存
  25.             for (int i = 0; i < a.Length; i++)
  26.             {
  27.                  sum += a[i];
  28.             }
  29.             return sum;
  30.         }
  31.     }
  32. }





来自为知笔记(Wiz)


02.方法的高级参数


联系
我们