c# 基础之方法

方法：方法其实就是函数（Function），优点就是方便重复使用，使代码简洁。

方法参数分：

1）值参数，不含修饰符

2）引用参数，以ref修饰符声明

3）输出参数，以out修饰符声明

4）数组型参数，以params声明

最长用的语法格式：

        //语法:[访问修饰符] 返回值 方法名(参数1,参数2)
        public static int NewMethod(int a,int b)
        {
            return a > b ? a : b;       //max
        }

1.  值传递:

  　　　值传递是方法默认的参数类型，采用的是值复制的方式。把实参值复制给形参，所以这种参数传递方式的特点是形参的值发生改变时，不会影响实参的值，从而保障了实参数据的安全

 

        public static void ChangeValue(int x,int y)
        {
            int temp = x; //交换x y值
            x = y;
            y = temp;
        }

        static void Main(string[] args)
        {
            int x = 1, y = 2;
            ChangeValue(x, y);
            Console.WriteLine("x = {0},y = {1}", x, y);
            Console.ReadKey();
            /*
             * 输出结果为: x=1, y=2
             * 方法内的x y放生了改变,但是没影响方法外的x y.
             */
        }

 

 2.引用传递分(ref和out)

首先：两者都是按地址传递的，使用后都将改变原来参数的数值。

 

其次：ref可以把参数的数值传递进函数，但是out是要把参数清空，就是说你无法把一个数值从out传递进去的，out进去后，参数的数值为空。这个就是两个的区别，或者说就像有的网友说的，ref是有进有出，out是只出不进。

所以：使用ref，实参必须是赋值后的变量。纯值 如：1、3、“2年级一班”的实参就会报错。

 

        public static int GetMaxMin(int[] arr, ref int min)
        {
            int max = arr[0];
            min = arr[0];       //ref 参数 在方法内可以不赋值    
            for (int i = 1; i < arr.Length; i++)
            {
                if (max < arr[i])
                {
                    max = arr[i];
                }
                if (min > arr[i])
                {
                    min = arr[i];
                }
            }
            return max;
        }

        static void Main(string[] args)
        {
            int min, max;
            min = 0; //ref 实参变量使用前必须赋值,并且直接修改此值.
            //定义随机数,遍历成数组
            Random ro = new Random();
            int[] myArray = new int[10];
            for (int i = 0; i < myArray.Length; i++)
            {
                myArray[i] = ro.Next(1, 100);
            }
            //遍历数组
            for (int i = 0; i < myArray.Length; i++)
            {
                Console.Write(myArray[i].ToString() + ",");
            }
            //调用方法返回最大值
            max = GetMaxMin(myArray, ref min);
            Console.WriteLine("方法返回值max = {0},ref参数修改后min = {1}", max, min);
            Console.ReadKey();

        }

 

 

 使用out，和ref差不多。区别out参数变量在方法外可以不赋值但是在方法内必须重新赋值。所以使用out是无法将实参的值带入到方法体内的。我估计作用：将方法体中的值带出方法外。

比如求数组中最大值和最小值的方法，事例如下：

 

        public static int GetMaxMin(int[] arr, out int min)
        {
            int max = arr[0];
            min = arr[0];       //out 在方法体内必须赋值.    
            for (int i = 1; i < arr.Length; i++)
            {
                if (max < arr[i])
                {
                    max = arr[i];
                }
                if (min > arr[i])
                {
                    min = arr[i];
                }
            }
            return max;
        }


        static void Main(string[] args)
        {
            int min, max;//out 返回min可以不赋值
            //定义随机数,遍历成数组
            Random ro = new Random();
            int[] myArray = new int[10];
            for (int i = 0; i < myArray.Length; i++)
            {
                myArray[i] = ro.Next(1, 100);
            }
            //遍历数组
            for (int i = 0; i < myArray.Length; i++)
            {
                Console.Write(myArray[i].ToString() + ",");
            }
            //调用方法返回最大值
            max = GetMaxMin(myArray, out min);
            Console.WriteLine("方法返回值max = {0},out参数返回值 min = {1}", max, min);
            Console.ReadKey();

        }

 

4.   数组型参数类型(params类型)

params关键字可以指定在参数数目可变处采用参数的方法参数。也就是说。使用params可以自动把你传入的值按照规则转换为一个新建的数组。
在方法声明中的 params关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params关键字。

 

        public static int GetSum(ref int avg, params int[] total)
        {
            int sum = 0;
            for (int i = 0; i < total.Length; i++)
            {
                sum += total[i];
            }
            avg = sum / total.Length;       //平均成绩
            return sum;
        }

        static void Main(string[] args)
        {
            //定义各科变量
            int chainese, english, math,total,avg;
            avg =0;     //ref实参变量必须赋值
            chainese = 88;
            english = 90;
            math = 62;
            total = GetSum(ref avg, chainese, english, math);//最后的3个参数传入到total数组中了
            Console.WriteLine("你的总成绩{0}分,平均成绩{1}",total,avg);
            Console.ReadKey();
            /*总成绩240,平均80
             *              
             */

        }

 

 方法重载：1.方法名相同。2.方法参数个数或参数类型不同其中ref和out与无ref和out也能构成方法重载。

事例，通过2个整数相加、3个整数相加、2个小数相加

 

        //x为两数中最大数
        public static int Add(ref int x ,int y) //参数int 2个 其中参数1添加ref
        {
            int temp;
            temp = x;
            x = x > y ? x : y;
            return temp + y;
        }
        public static int Add(int x,int y)  //参数int 2个
        {
            return x + y;
        }

        public static int Add(int x, int y,int z)   //参数int 3个
        {
            return x + y+z;
        }
        public static double Add(double x, double y) //参数double 3个
        {
            return x + y;
        }


        static void Main(string[] args)
        {
            int sum1, sum2, refSum, max;
            max = 10;
            double sum3;
            sum1 = Add(10, 20);
            sum2 = Add(10, 20, 30);
            sum3 = Add(10.5, 20.5);
            refSum = Add(ref max, 20);
            Console.WriteLine("sum1 ={0},sum2 ={1},sum3 ={2},refSum ={3},max = {4}", sum1, sum2, sum3, refSum, max);
            Console.ReadKey();
            /*max传入方法时值 10.方法结束后max = 20
             * 返回值sum1 =30,sum2 =60,sum3 =31,refSum =30,max = 20
             */
        }