我们在Main()函数中，调用Test()函数，我们管Main()函数称之为调用者，管Test()函数为被调用者;

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

1.传递参数

2.使用静态字段来模拟全局变量;

C#里面并没有全局变量,但是我们一般能用一个静态的字段来实现跟全局变量一样的功能;也就是说这个字段全部的方法都可以使用;

静态字段应该与方法平级，写在类里面，方法外面，因此字段的使用范围是整个类，因为它的作用域;所以可以当做全局变量;

声明在方法外面，类里面的一般是字段；声明在方法里面的一般称之为变量;

因此字段可以加访问修饰符;变量不能加访问修饰符;

public  static int _number = 10;

有可能我们实现一个功能要有多个方法，写这多个方法的时候可能会用到同一个变量;

第一种方式把这些变量以参数的形式一个一个传进来;

第二种方式是当多个方法都需要相同的变量的时候，可以把这个变量声明为字段,这样不用传参数也能访问到;

把方法共同用到的变量写成静态字段;这样方便使用;

方法是和Main方法平级的;

如果调用者想得到被调用者的值;

1.返回值;

写完方法后必须写文档注释;

不管是形参还是实参都是在内存中开辟了空间的;

封装方法最简单的方法,选中要封装成方法的代码，右键，重构，提取方法。

写方法的原则：

1.方法的功能一定要单一;

2.方法中最忌讳的就是出现提示用户输入的字眼;

形参和实参只要类型和数量一样就可以了;名字不一定要一样

判断用户只能输数字，用Convert转换，配合try catch即可   判断用户只能输yes和no则只要||配合if else即可

在方法中有三个高级参数,out ref params

1,out

如果一个方法要返回多个值，但是这多个值是同一种类型，我们可以考虑返回一个数组;

如果一个方法要返回多个值，但是这多个值的类型不同，我们就要用到out参数;

out参数就侧重于在一个方法中可以返回多个不同类型的值;也可以返回多个相同类型的值;

public  static  void Test(int[] numbers , out int max , out int min , out int sum , out int avg,out bool b,out string s)//形参上out表示要多于返回的参数;
{

}

这个方法本质上没有返回值，但是我用out参数多于的返回了4个参数回去;

out参数要求必须在方法的内部为其赋值;因为我们要给它返回值;

int[] numbers={0,2,4,6,8};

int max ;

int min ;

int sum ;

int avg ;

bool b;

string s; //没必要给这些变量赋值，因为它们的值是从方法中来的;

Test(numbers,out max,out min,out sum,out avg,out b,out s);

Console.WriteLine（max);

Console.WriteLine（min);

Console.WriteLine（sum);

Console.WriteLine（avg);

Console.WriteLine（b);

Console.WriteLine（s);

//用out返回的值不需要用return;能够帮组我们在一个方法中返回多个不同类型的值;

public static bool IsLogin(string username,string pwd,out string msg)
{

}

//如果不写返回值的话可以这样;
public static void IsLogin(string username,string pwd,out string msg,out bool b)
{
 
}

string name = Console.ReadLine();

string pwd = Console.ReadLine();

string msg;

bool b = IsLogin(name,pwd,out msg)

再次声明，out参数在使用的时候，方法内部必须给out参数赋值;但是在方法外部不用给out变量赋值，它的值是在方法内部传出来的;

什么时间做什么事，这个原则你掌握了，你就是真正的长大了;

int num;

bool b = int.TryParse("123",num);

如果"123"能够成功转换为int类型，那么返回true;并将转换后的值赋值给num;如果"123"不能成功转换为int类型的值，那么返回false，num的值就是0;

int.TryParse()方法的实现

public static bool MyTryParse(string s , out int num)
{
     num = 0;
     try
     {
       num = Convert.ToInt32(s);
       return true;
      }
      catch
      { 
       return false;  
      }
}

2.ref

static void Main(string[] args)
{
  double salary = 5000；
  JiangJin(5000);
  Console.WriteLine(salary);    //输出的Salary依然是5000;
  Console.ReadKey();
}

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

static void Main(string[] args)
{
  double salary = 5000；
  double s = JiangJin(5000);
  Console.WriteLine(s);    //输出的Salary是5500;
  Console.ReadKey();
}

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

如果调用者想得到被调用者的值; 返回值;

要是有这样一个东西，能够在方法里面能够改变变量之后，外面也能跟着改变，ref参数能做到这么一件事

static void Main(string[] args)
{
  double salary = 5000；
  JiangJin(ref salary);
  Console.WriteLine(salary);    //输出的Salary是5500;
  Console.ReadKey();
}

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

public static void JiangJin(ref double s)传参的时候要用到ref，

JiangJin(ref salary);调用的时候也要用到ref 

ref参数,能够将一个变量带入一个方法进行改变,改变完成之后，再将改变后的值带出方法;用ref参数的好处就是我们不需要写返回值了;

交换两个变量的值

1.第三方变量;

2.两个变量的加加减减

用方法来封装

public static void Test(int n1,int n2)
{
   int temp = n1;
   n1 = n2;
   n2 = temp;
}

int n1 = 10;
int n2 = 20;
Test(10,20);
Console.WriteLine(n1);
Console.WriteLine(n2);

值依然没有改变,因为如果要改变额话必须要满足：如果调用者想得到被调用者的值; 返回值;它没有使用返回值返回，所以没有改变;

public static void Test( ref int n1,ref int n2)
{
   int temp = n1;
   n1 = n2;
   n2 = temp;
}

int n1 = 10;
int n2 = 20;
Test(ref 10, ref 20);
Console.WriteLine(n1);
Console.WriteLine(n2);  值改变了;

ref参数和out参数不一样，out参数必须在方法内部赋值，ref参数则必须在方法外部已经赋值;为什么要在方法外部赋值，因为ref的作用就是把变量带到方法里面进行改变，如果没有赋值,
就改变不了;ref参数要求在方法外必须为其赋值，方法内可以不赋值;

3.params

int[] s = {1,2,3,4};

Test("张三",s);

public static void Test(string name, int[] score)

Test("张三",1,2,3,4); //params把里面的几个数字处理为int[] score里面的元素;

public static void Test(string name,params int[] score)

params int[] score 可变参数数组;实际上数组长度不可变,只是用params模拟一下;

params可变参数;将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理;

看到params修饰的数组，有两个选择

1.填跟数组类型一致的元素进去;

2.填一个相应类型的数组进去;

public static void Test(string name,params int[] score,int id)//错的

public static void Test(string name,int id,params int[] score)//对的

params可变参数必须是形参列表中的最后一个元素;

一个参数列表中只能出现一个可变参数;

params修饰的是数组，而不是单个元素;

int[] sum = {1,2,3,4,5};

int sum = GetSum(sum);

int sum = GetSum(1,2,3,4,5,6,7);

public static int GetSum(params int[] n)
{
  int sum = 0;
  for( int i = 0;i < n.length; i++)
  {
      sum += n[i];
   }
  return sum;
}

程序员上班之后一定要锻炼;

方法的重载

方法的重载指的就是方法的名称相同，但是参数不同;

参数不同，分为两种情况

1.如果参数的个数相同，那么参数的类型就不能相同;

2.如果参数的类型相同，那么参数的个数就不能相同;

方法的返回值跟重载没有关系;

方法的递归

方法自己调用自己;

静态字段可以充当全局变量，在整个类中都可以访问到，静态字段和非静态字段的区别是静态字段可以直接访问，非静态字段要创建对象的实例才能访问;

public static int i = 0;

public static void TellStory()
{
   Console.WriteLine("从前有座山");
   Console.WriteLine("山里有座庙");
   Console.WriteLine("庙里有个老和尚");
   i++;
   if(i >= 10)
   {
    return
    }
   TellStory()
}

递归一次画一个圈，递归一次再里面画一个圈，递归10次到了里面第10个圈。出来的时候不可能一次性出来，而是一个一个慢慢出来;

当调试过程中将要进入一个方法的时候，按F10可以跳过方法，进入下一条语句，这个叫做逐过程调试; 

15-01-06 C# 面向过程 07