C#函数调用&&引用参数&&输出参数

staic 表示 Play 方法为 Program 抽象类的静态方法
意味着：Play 只能通过Program.Play方式调用,并且只能在类的内部使用
注意：如果Play在 Progrem中内部使用，可以省略抽象类。

通俗的来说就是  如果在一个class类里面   如下两种调用都没问题

1.   Program.Play();
2.   Play();

如果不在一个class类  只能用Program.Play();调用

 class Program
 { 
  static void Main(string[] args)
   {
       // 函数调用问题

       Program.Start();
       Program.Play();
       Play();
   } 
  static void Play()
  {
      Console.WriteLine("爪牙爪牙找朋友");
      Console.WriteLine("爪牙爪牙找朋友");
      Console.WriteLine("爪牙爪牙找朋友");
  }
  static void Start()
  {
      Console.WriteLine("开始播放音乐");
      Console.WriteLine("音乐中........");
  }
}

下面讲到不在一个class类如何调用函数

如果 在一个类中可以省略  public 

但是  如果一个类 调用另一个类中的函数

必须写public  代表公共的

例如  Program类调用Person类中的 Say函数，须先new一个函数所在类的（Person）实例对象

 class Program
 {
     static void Main(string[] args)
     {
         // 函数调用问题

         Person zs = new Person();
         zs.Say("aaa");
         Console.ReadKey();
     } 
 class Person
 {
     // Say 使用 Person实力对象上的api
     // 实例对象是：new Person；
     public void Say(string name)
     {
         Console.WriteLine("我是同故宫实力对象方式"+name );
     }
     // public 公共
     // static 静态的
     // Say 只能通过Person.Say调用：可以在Person内部和其他类中使用。
     // 没有public 只能在Person 抽象类内部调用
     public static void Say()
     {
         Console.WriteLine("我只能通过Persion.Say才能触发");

     }

 接下来是参数   

形参就是函数定义的参数

实参就是main函数中调用时 给予的参数

class Program
{
    static void Main(string[] args)
    {
        int[] arr = { 1, 2 };
        Foo(1,"a",arr);  // 实参
        Console.ReadKey();
    }
    // 普通 参数
    static void Foo(int a,string b,int[] c) // 形参
    {
        // 形参与实参的位置是相同。
        // 实参作用是给形参赋值
        // 注意：形参变量，只能在函数内部使用
        Console.WriteLine(a);
        Console.WriteLine(b);
        Console.WriteLine(c);
    }
}

同时  函数中的参数只能在函数中使用

在函数中对于main函数中实参并不能起到改变的作用

但是  这里就可以用到 ref 来进行引用参数

 class Program
 {
     static void Main(string[] args)
     {
         int a = 123;
         int b = 234;

          Foo(a, b);
          Console.WriteLine("测试：查看没有用ref参数时  a:  {0}  b{1}", a, b);
          Bar(ref a,ref b);
          Console.WriteLine("测试：查看引用ref参数时  a:  {0}  b{1}", a, b);

          Console.ReadKey();
}
     // 普通参数；换值 影响的Foo中a,b 无法修该 Main 中a,b
     static void Foo(int a,int b )
     {
         int tmp = a;
         a = b;
         b = tmp;
         Console.WriteLine("Foo内部私有的：a:  {0}  b{1}", a, b);
     }
     // ref 引用参数
     // 方法体中修该的实际是，函数执行时引用的变量。
     static void Bar(ref int a,ref int b)
     {
         int tmp = a;
         a = b;
         b = tmp;
         //Console.WriteLine("a:  {0}  b{1}", a, b);
     }

 输出参数out

言简意赅就是  原本函数中形参没有具体值

用out输出参数   通过函数中变量赋值  输出给形参  再传给main函数中变量

  static void Main(string[] args)
  {
      int c, d;
      Foo(out c,out d);
      Console.WriteLine("c:{0}  d:{1}", c, d);
      Console.ReadKey();
  }
  // out 参数，可以输出多个结果。
  // 将函数中数据，先赋值给 out 形参，再赋值 函数执行时候 out实参变量
  static void Foo(out int a,out int b)
  {
      a = 123;
      b = 234;
          
  }