C#方法

方法的定义与调用

首先我们要知道什么是方法,为什么要去使用方法?

方法就是把一些相关的语句组织在一起,用来执行的语句块

每一个C#程序至少有一个带有Main方法

   static void Main(string[] args)
   {   
   //方法的定义,一般情况下,写在一个类中
   // 格式: 访问修饰符  返回值  方法的名字(){
   // 方法体
   // }

   //访问修饰符: public 公开的
   //返回值类型 :  void  没有返回值
   //方法的名字: 随便定义即可   以大驼峰命名

   Test();
}
 public static void Test()
 {
     Console.WriteLine("我是一个方法");
 }

方法的参数

   static void Main(string[] args)
   {
       //方法的参数
       //参数: 形参和实参
       //形参: 形式参数,方法在定义的过程时候,生命在括号里面的变量,这个参数由实参决定
       //实参: 实际参数,方法在调用的时候,写在括号里面的数据,这个数据就会赋值给对应的形参
       Test("实参");
       TestT(5);
       TestTT(3, "实参");
      // TestTT( "实参",3); 这个构造函数的位置顺序要一样
       //注意,参数位置必须一致
   }
   public static void Test(string name)
   {
       //实参传递什么,形参就是什么
       Console.WriteLine(name);
   }
   public static void TestT(int number)
   {
       for (int i = 0; i < number; i++)
       {
           Console.WriteLine("你好");
       }
   }
   public static void TestTT(int number,string name)
   {
       for(int i = 0;i < number;i++)
       {
           Console.WriteLine(name);
       }
   }

方法的返回值

  static void Main(string[] args)
  {
      //方法返回值  int string void 
      Num(10,20);

  }
  //方法通过返回值,将方法内部得到的结果返回给调用的地方
  //需要在定义方法的时候,指定方法的返回值类型,如果没有返回值   写void
  public static int Num(int x,int y)
  {
      return x + y;
      //注意:return关键字不仅用于返回数据,还可以用于终止方法的执行(return后面的方法就不会执行)
  }

方法参数的传递

1. 值传递:传递的是变量,方法内部改变不会受外界影响

2. 引用传递:传递的是内存地址,方法内部改变,外部也会受到影响

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 方法返回值
{
    internal class Program
    {
        static void Main(string[] args)
        {
         
            //值传递  --------传递值类型
            //方法在调用的时候,如果传入的是变量,或者表达式,都会先进行计算,然后进行传递
            //方法调用传递变量,传递过去的是这个表达式或者变量的值,而不是变量本身
            
            int a = 10;
            int b = ++a;
            Test(b);      //11
            Test(b + 10); //21

            Console.WriteLine("b的值是"+b);//11

            // 值传递-----传递引用类型
            //当给方法传递一个引用类型的时候,传递的也是变量里面里面保存的值
            //只不过引用类型的变量存储的是内存地址,所以传递进入的是内存地址,相当于两个地方操作的是一个内存地址,一个改变,另一个也会改变
            People people = new People() { Name = "马超" };
            
            TestT(people);
            Console.WriteLine(people.Name);

        }
        public static void Test(int x)
        {
            Console.WriteLine("传入的参数式"+x);
            x = 40;//内部改变,外部输出,不会受影响
        }
        public static void TestT(People p)
        {
            Console.WriteLine("传入的参数是"+p.Name);
            p.Name = "小丑";
        }
       
    }
    class People
    {
        public string Name;
    }
    //注意: 值传递(值参数):这个名字和传递的数据类型没有关系,是因为传递进函数内部的是变量里面保存的值,所以才叫做值传递
}

引用传递

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 引用传递
{
    internal class Program
    {
        static void Main(string[] args)
        {

            //引用传递(引用传参):当传递一个值类型的时候,方法内部修改形参,会影响到外部,当方法内部需要修改传递进来的变量的时候,就需要使用引用传递

            int a = 10;
            Test(ref a);//传递参数的时候必须加上ref关键字
            Console.WriteLine("a的值是"+a);

            //定义一个函数,用来交换a和b的值
            int b = 10;
            int c = 20;
            YU(ref b, ref c);
            Console.WriteLine("b值是"+b);

            People people = new People() { Name="曹操"};
            TestT(ref people);
            Console.WriteLine(people.Name);

        }
        //在定义方法的时候,给某个形参前面加上ref关键字,这个参数就进行引用传递(直接传递变量本身)
        public static void Test(ref int x)
        {
            Console.WriteLine("传入的参数是"+x);
            x = 666;
        }
        public static void YU(ref int x,ref int y)
        {
            (x,y)=(y,x);//这是一个语法糖
        }
        public static void TestT(ref People p)
        {
            //修改了p里面保存的内存地址
            //默认情况下 进行的是值传递 内部修改不会影响外部

            //加上ref之后  是进行的引用传递, 在方法内部把p保存的内存地址修改之后,会影响到外部p1保存的内存地址
            p = new People() { Name="张飞"};
            Console.WriteLine("传入的参数是"+p.Name);
        }
    }
    class People
    {
        public string Name;
    }
}

out输出参数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OUT
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int a = 6;
            int b = 7;
            Test(ref a, ref b);
            Console.WriteLine("a和b的值是"+a+b);

            int c = 10;
            int d = 20;
            TestT(out c, out d);
        }
        public static void Test(ref int x,ref int y)
        {
            Console.WriteLine($"x的值是{x},y的值是{y}");
            x = 60;
            y = 70;
        }
        public static void TestT(out int x, out int y)
        {
            x = 60;
            y = 70;
            Console.WriteLine($"x的值是{x},y的值是{y}");
           
        }
    }
}
//总结:
//ref和out的区别
//1.out传递参数,可以不用赋值
//2.out传递参数,必须在方法中进行赋值
//3.ref传递参数,可以在方法中获取值,out传递参数,只能在赋值之后取值(out不能传递进去数据)

//ref 的主要作用是为了传入数据,因此传入的时候必须赋值
//out 的主要作用是为了传出数据,因此在传入的时候可以不进行初始化,并且在方法中必须赋值