一，方法的参数

　　1，值传递

　　　　①，形参分配了一个新的存储空间。所有值参数可以带进，不可以带出。

　　　　②，声明时没有任何修饰符。

　　　　void swap(int x,int y){};

　　2,引用传递ref

　　　　①,采用ref修饰。值可以带进，也可以带出。

　　　　②,实参在传值之前必须赋初值，否则会报错。

　　　　③，实参和形参指向相同的地址空间。

　　　　

代码 
public static void swap(ref int x, ref int y)
        {
            int c = x;
            x = y;
            y = c;
        }
        static void Main(string[] args)
        {
            int i = 10;
            int j = 20;
            swap(ref i, ref j);
            Console.Write("i={0},J={1}", i, j);
｝

 

 

　　3，输出参数out

　　　　①，采用out修饰，值可以带进，也可以带出。

　　　　②，可以不赋初值，即便是赋初值，在方法中还是没有用的，只有在方法中赋值才可以。

　　　　③，和ref一样，不会创建新的存储空间，和实参指向相同的地址空间。

　　　　

public static void swap(out int x, out int y)
        {
            //int c = x; //error no orignal value
            //x = y;
            //y = c;
            x = 10; y = 20;
            int c = x; 
            x = y;
            y = c;
        }
        static void Main(string[] args)
        {
            int i = 10;//invalidation
            int j = 20;//invalidation
            swap(out i, out j);
            Console.Write("i={0},J={1}", i, j);
｝
四，参数数组params
　　1，不可以与out，ref连用。
　　2，参数只可以是一维数组，不可以是二维数组。如string []. 不可以是string [,]；
　　3，参数数组可以指0个或者多个参数。
代码
static void Print(params int [] args)
        {
            int length = args.Length;
            for (int i = 0; i < length; i++)
            {
                Console.Write("第{0}个参数值为：{1}\n",i,args[i]);
            }
        }
        static void Main(string[] args)
        {
            int [] array = { 1, 2, 3, 4 };
            Console.Write("第一组数据：\n");
            Print((int [])array);
            Console.Write("第二组数据：\n");
            Print(10, 20, 30, 40);
｝






 

五，数组参数
　　1，数组作为值传入，如果改变数组元素的值，则可以传出；如果改变数组对象的值，数组元素的值不会被传出。
　　2，数组作为引用参数传入，使用ref。则在传入之前必须创建数组对象。值可以传出。
　　3，数组作为输出参数传入，使用out。在传入之前可以创建数组，也可以不创建数组。创建数组也没有用，需要在函数内创建。值可以传出。
代码 
//数组元素改变，可以传出。
        static void swap(int[] a, int[] b)
        {
            int c = a[0];
            a[0] = b[0];
            b[0] = c;
        }
        //数组对象改变，不可以传出。
        static void swap(int[] a, int[] b)
        {
            int[] c = a;
            a = b;
            b = c;
        }
        //引用参数，可以传出
        static void swap(ref int[] a,ref int[] b)
        {
            int[] c = a;
            a = b;
            b = c;
        }
        
        static void Main(string[] args)
        {
            int[] a = { 0 };
            int[] b = { 12 };
            Console.Write("before:a[0]={0},b[0]={1}\n", a[0], b[0]);
            swap( out a,out b);
            Console.Write("after:a[0]={0},b[0]={1}\n", a[0], b[0]);
            Console.Read();
        }

六，方法的重载

　　1，方法的重载有叫方法的签名。可以是参数的顺序，类型，个数的不同，但是返回值是不包括在内。如下定义是错的：（只有返回值类型不一样）

　　

代码 
static void swap(int[] a, int[] b)
        {
            int c = a[0];
            a[0] = b[0];
            b[0] = c;
        }
        //数组对象改变，不可以传出。
        static int swap(int [] a, int[] b)
        {
            int[] c = a;
            a = b;
            b = c;
            return 0;
        }

　　2，除方法外，还可以对构造函数，索引器，运算符进行重载。