c#函数(方法)

方法的组成:

1.方法的修饰符,pubilic, static

2.方法的返回值,void没有返回值,有返回值的需要配合return

3.方法名称,命名规则同变量,一般大驼峰

4.形参列表,形参就是形式参数,将来使用方法时,会用实参来传递给形参

5.方法体,方法核心业务逻辑

封装成方法,调用方法,使用方法,根本目的,复用

通过类本身来调用的函数称为静态函数,通过类的实例来调用的方法称为实例方法,c#中方法必须要在类中定义,方法默认是私有的,只能在类中使用..

没有用static来修饰的方法称作实例 方法,实例方法必须通过类的个体来访问.

值传递特点:方法中修改了形参,不会影响外部的实参.引用传递:方法中修改了实参,影响外部的实参.实参的类型是引用类型中的string类型,传递特点与值传递一致,这是由于string类型在c#中特殊,重新修改了string后会生成新的字符,重新分配内存.方法传递类的实例时,是引用传递.修改实例的属性并没有给实例分配新的内存.

using System;
namespace ConsoleApp2
{
	class Program
    {
		/*
		 * 类中的函数，以后称方法
		 * 方法的组成：
		 * 1. 方法修饰符，public static
		 * 2. 方法的返回值，void没有返回值，有返回值，则需要配合return
		 * 3. 方法名称，命名规则同变量，一般大驼峰
		 * 4. 形参列表，形参就是形式参数，将来使用方法时，会用实参来传递给形参
		 * 5. 方法体，方法核心业务逻辑。
		 */
		public static void Main(string[] args)
		{
            // 使用方法，调用方法，封装成方法，根本的目的：复用。
            // 20, 30实际参数，简称参数
            Console.WriteLine(Program.Add(20, 30)); // 50

			//实例化类
			MyClass	myClass = new MyClass();
			//myClass.SayHello("C#很好"); // 报错，原因：访问权限问题
			Console.WriteLine(myClass.SayHello2("C#很牛"));
            Console.WriteLine(MyClass.SayHello3("C#很牛"));


			int a = 20, b = 30;
            // 值传递特点：方法中修改了形参，不用影响外部的实参。
            myClass.Add(a, b);
			Console.WriteLine($"方法Add()修改了形参x,y，但并不影响实参a,b，{a},{b}");

			// 引用传递特点：方法中修改了形参，影响外部的实参。
			int c = 20, d = 30;
			myClass.Add2(ref c, ref d);
            Console.WriteLine($"方法Add2()修改了形参x,y，影响实参c,d，{c},{d}");

			// 即使实参的类型是string引用类型，只要不使用ref关键字处理，还是值传递。这是由于string在C#比较特殊，重新修改了string后，会生成新的字符串，重新分配内存。
            string e = "aaa", f = "bbb";
            myClass.Add3(e, f);
            Console.WriteLine($"方法Add3()修改了形参x,y，但并不影响实参e,f，{e},{f}");

			// 此事例说明向方法传递类的实例，是引用传递。
			// 原因：修改实例的属性时，并没有给实例重新分配内存。
			Point p = new Point(30, 40);
			myClass.Add4(p);
            Console.WriteLine($"方法Add4()修改了形参p1，影响实参p，{p.X},{p.Y}");

			// 可以通过给字符串添加ref，让字符串传参时，是引用传递。
            string h = "aaa", i = "bbb";
            myClass.Add5(ref h, ref i);
            Console.WriteLine($"方法Add5()修改了形参x,y，影响实参h,i，{h},{i}");

			int j = 0;
			myClass.Add6(10, 20, out j);
			Console.WriteLine(j); // j就是从Add6()的形参c中传递过来的。

        }

        // 定义方法
        public static int Add(int x,int y) { 
			int c = x + y;
			return c;
		}
	}

	class MyClass
	{
		// C#中方法必须在类中定义
		// 方法默认访问权限是私有的private，只能在类中使用。
		string SayHello(string s)
		{
			return "我说：" + s;
		}

		// 没有使用static修饰符装饰的方法，称为实例方法。
		// 实例方法必须通过类的个体来访问。
		// 实例方法：即类的每一个实例都复制了一份方法的副本。
		public string SayHello2(string s)
		{
            return "我说：" + s;
        }

		// 使用static修饰符装饰的方法，称为静态方法。
		// 静态方法只能通过类本身来访问。不能通过类的实例来访问。
		// 静态方法：主要为了共享，静态方法只存在于类本身。
        public static string SayHello3(string s) {
            return "我说：" + s;
        }

		// 向方法中传递参数时，有两种情况：实参要么是值类型，要么是引用类型

		public void Add(int x, int y)
		{
			x = 10;
			y = 20;
			Console.WriteLine($"修改了参数后：{x},{y}");
		}

        // ref===Reference引用
		// 数据类型前有ref表示传递的数据是引用类型，是x的地址。
        public void Add2(ref int x, ref int y)
        {
            x = 10;
            y = 20;
            Console.WriteLine($"修改了参数后：{x},{y}");
        }

		public void Add3(string x, string y)
		{
			x = "hello";
			y= "world";
            Console.WriteLine($"修改了参数后：{x},{y}");
        }

		public void Add4(Point p1)
		{
			p1.X = 10;
			p1.Y = 10;
            Console.WriteLine($"修改了参数后：{p1.X},{p1.Y}");
        }

        public void Add5(ref string x, ref string y)
        {
            x = "hello";
            y = "world";
            Console.WriteLine($"修改了参数后：{x},{y}");
        }

		// 形参前加out关键字，这样的形参是：输出形参
		// 在外部调用Add6()时，可以用来个变量来接收输出形参c的值
		// int j = 0; myClass.Add6(10,20,out j);
		// 输出参数：形参向实参传递计算结果。
		// 输出参数可以代替return 语句。
        public void Add6(int x, int y, out int c)
        {
			c = x + y;
        }
    }

	class Point
	{
		public int X { get; set; }
        public int Y { get; set; }


        public Point(int x,int y)
		{
			X = x;
			Y = y;
		}

        public override string ToString()
        {
            return $"x坐标：{X},y坐标：{Y}";
        }
    }
}