*方法(Method)/ 函数(Function)：
基本概念: 方法 也叫函数
本质是一块具有名称的代码块 , 是封装代码进行重复使用的一种机制
•方法的定义与调用：
internal class Program
{
static void Main(string[] args)
{
//一个方法分为两个部分：方法的定义(方法的声明) 方法的调用(执行)
//方法的调用 方法名() 即可就是在方法的名字后面加一个() 因为 () 称之为执行运算符
Test();
//Program.Test();
Console.WriteLine("1");
//封装一个方法 打印10次吴亦
MyWrite();
}
//方法声明在哪里:
//1.class语句块中
//2.struct语句块中
//方法的定义基本语法:
// 1 2 3 4
// static 返回类型 函数名(参数类型 参数名1, 参数类型 参数名2,..... )
//{
// 方法的代码逻辑;
// 方法的代码逻辑;
// ...........
// 5
// return 返回值;(如果有返回类型才返回)
//}
//1.关于static 不是必须的 在没有学习类和结构体之前 都是必须写的 static 修饰的就是静态方法 main是静态方法,Test不是一个静态方法,两个不互通,需要static修饰
//2-1.关于返回类型 引出一个新的关键字void(表示没有返回值)
//2-2.返回类型 可以写任意的变量类型 14种变量类型 + 复杂数据类型(数组,枚举,结构体,类class)
//3.关于函数名使用帕斯卡命名法
//4-1.参数不是必须的,可以有0~n个参数 参数的类型也是任意类型 多个参数的时候 需要用 逗号 隔开
//4-2.参数名 驼峰命名法
//5.当返回值类型不为void时 必须通过新的关键字 return返回对应类型的内容 (注意:即使是void也可以选择性使用return)
public static void Test()
{ Console.WriteLine("C#中学到的第一个方法"); }
public static void MyWrite()
{
for (int i = 0; i < 10; i++)
{ Console.WriteLine("吴亦"); }
}
}
•方法的参数：
internal class Program
{
static void Mahin(string[] args)
{
// 打印10次吴亦凡 这个功能非常单一 我要打印20次吴亦凡 又要写一个方法
// 这两个需求 功能相似 ，我们就可以通过参数的传递，来控制一个方法做出不同的功能
/* 参数：形参 实参
* 形参：形式参数，方法定义的时候，写在()里面的变量，这个形参的值由实参决定
* 实参：实际参数，方法调用的时候，写在()里面的数据，这个数据将会赋值给对应的形参 */
//1.0调用
MyWrite();
//2.0调用
MyWrite2(20);
Console.WriteLine("-----------");
MyWrite2(5);
//3.0调用
MyWrite3(10,"罗志祥");
//4.0调用
MyWrite4(10,"jkjkjkkj");
MyWrite4(1);
}
// 1.0版本 打印10次吴亦凡
public static void MyWrite()
{
for (int i = 0; i < 10; i++)
{ Console.WriteLine("吴亦凡"); }
}
// 2.0版本 可以打印任意次数的吴亦凡
public static void MyWrite2(int count)
{
for (int i = 0; i < count; i++)
{ Console.WriteLine("吴亦凡"); }
}
//3.0版本 可以打印任意内容 任意次数
public static void MyWrite3(int count, string name)
{
for (int i = 0; i < count; i++)
{ Console.WriteLine(name); }
}
//4.0版本 如果传递打印内容 就打印传递过来的内容 如果没有传递打印内容 就打印默认值
// 可选参数(就是在方法调用的时候可以在小括号里面加需要输出的内容也可以不添加) 必须写在必选参数后面(必须在方法调用的时候添加内容的)
public static void MyWrite4(int count, string name="吴亦凡是劣迹明星")
{
for (int i = 0; i < count ; i++)
{ Console.WriteLine(name); }
}
}
•方法的返回值：
internal class Program
{
static void Main(string[] args)
{
// void 表示没有返回值
// 返回值 就是用来返回方法得到的一个运算结果
// 有返回值的方法怎么定义
int sum = Tets(10, 20);
//Console.WriteLine(Tets(10, 20));//30
Console.WriteLine(sum);//30
string name = Test2();
Console.WriteLine(name);
Console.WriteLine(Test2(1, 2));
Console.WriteLine("请输入第一个数字：");
double num1 = double.Parse(Console.ReadLine());
Console.WriteLine("请输入第二个数字：");
double num2 = double.Parse(Console.ReadLine());
Console.WriteLine("请输入运算符：（+ - * /）");
string str = Console.ReadLine();
switch (str)
{
case "+":
Console.WriteLine(Add(num1, num2));
break;
case "-":
Console.WriteLine(num1 - num2);
break;
case "*":
Console.WriteLine(num1 * num2);
break;
case "/":
Console.WriteLine(num1 / num2);
break;
}
}
public static int Tets(int a, int b)
{
int c = a + b;
// return 关键字
//即使是函数没有返回值也可以选择性使用return
//return可以直接不执行之后的代码 直接返回到函数外部
// 返回值 会 返回到函数调用的地方
//return a + b;
return c;
}
public static string Test2(int a = 1, int b = 2)
{
Console.WriteLine(a + b);
return "吴亦凡";
}
public static double Add(double a, double b)
{
Console.WriteLine(Minus(a, b));
return a + b;
}
public static double Minus(double a, double b)
{ return a - b; }
public static int Ride(int a, int b)
{ return a * b; }
public static int GetRidOf(int a, int b)
{ return a / b; }
}
internal class Program
{
static void Main(string[] args)
{
方法的实际运用
//使用函数 直接 写函数名 (参数) 即可
SayHellow();
// 参数可以是 常量 变量 函数都可以
// 参数一定是传一个 能够得到对应类型的表达式
string str = "张紫诺";
//传入一个string变量
SayYourName(str);
//传入一个string变量
SayYourName("马帅");
//传入一个返回值是string的函数
SayYourName(WhatYouName());
//有返回值的函数 要不是直接拿返回值来用,要不就是拿变量 接收它的结果
string str2 = WhatYouName();
//也可以直接调用 但是 返回值 对我们来说就没有用了
WhatYouName();
Console.WriteLine(Sum(2, 5));//7
int[] arr = Calc(5, 7);
Console.WriteLine(arr[0] + " " + arr[1]);
}
//1.无参数无返回值函数
// 1 2 3 4
static void SayHellow()
{
Console.WriteLine("你好世界");//你好世界
// 5 在没有返回值时 也就是返回值类型是void 可以省略
//return;(可以省略)
}
//2.有参数无返回值函数
// 1 2 3 4
static void SayYourName(string name)
{
Console.WriteLine("你的名字是:{0}", name);
//return;(可以省略)
}
//3.无参数有返回值函数
// 1 2 3 4
static string WhatYouName()
{
// 5 对应返回值类型 内容 返回出去
return "ZN";
}
//4.有参数有返回值函数
// 1 2 3 4
static int Sum(int a, int b)
{
//int c = a + b;
//return c;
//5 retrun后面可以写一个表达式 只要这个表达式的结果和返回值类型一致就可以
return a + b;
}
//5.有参数多返回值函数
//传入两个数 然后计算两个数的和 以及他们的平均数 得出结果返回出来
//函数的返回值 一定是一个类型 只能是一个内容
static int[] Calc(int a, int b)
{
int sum = a + b;
int avg = sum / 2;
//如果用数组作为返回值出去 那么前提是 使用者 知道这个数组的规则
//int[] arr = { sum, avg };
//return arr;
return new int[] { sum, avg };
}
}
•方法的引用参数ref参数：
internal class Program
{
static void Main(string[] args)
{
//学习ref和out的原因:他们可以解决 在函数内部改变外部传入的内容 里面变了 外面也要变
//方法传递参数的两种方案：
//值传递（值参数）：方法默认传递方式，这种方式在调用的时候，会在方法执行的时候声明一个新的变量接收一个参数，实参的值就会赋值给这个变量
//当传递的是一个基本数据类型的时候，方法内部修改形参，不会影响到外部，当传递一个引用类型的时候会影响到外部
//引用传参(引用参数):当传递了一个基本数据类型的时候，方法内部修改形参，:会影响到外部
int x = 10, y = 20;
Test1(x, y);
Console.WriteLine(x);//10
Console.WriteLine(y);//20
Test2(ref x, ref y);//传递参数的时候必须加上关键字ref
Console.WriteLine(x);//11
Console.WriteLine(y);//21
}
public static void Test1(int a, int b)
{
a++;
b++;
Console.WriteLine(a);//11
Console.WriteLine(b);//21
}
public static void Test2(ref int a, ref int b)
{
a++;
b++;
Console.WriteLine(a);//11
Console.WriteLine(b);//21
}
}
static void Main(string[] args)
{ //练习
//1.使用引用传参，我要得到两个数字相加
int a = 20; int b = 10; int c = 0;
Test(ref a, ref b, ref c);
Console.WriteLine("两个数的和为：" + c);
//2.封装一个方法 交换两个变量的值
int e = 20; int d = 10;
Test2(ref e, ref d);
}
//1.
public static void Test(ref int a, ref int b, ref int c)
{ c = a + b; }
//2.
public static void Test2(ref int e, ref int d)
{
(e, d) = (d, e);
Console.WriteLine("交换后第一个数字：" + e);
Console.WriteLine("交换后第二个数字：" + d);
}
•方法的out输出参数：
internal class Program
{
static void Main(string[] args)
{
// ref 输入关键字
// out 输出关键字
// return关键字用于返回方法执行的结果，但是只能返回一个结果，如果想要返回多个数据到方法调用的地方，就可以使用输出参数
int x = 10, y = 20;
Test1(ref x, ref y);
Console.WriteLine(x);//21
Console.WriteLine(y);//32
int a = 1;
int b = 4;
Test2(out a, out b);
Console.WriteLine(a);//100
Console.WriteLine(b);//200
/*
* out和ref的区别？
* ref传入的变量必须初始化
* out传递参数可以不用赋值
* out传递的参数，在方法中必须赋值
* ref传递的参数可以在方法内部获取到值，out必须在方法内部重新赋值之后才可以获取到值
*
* ref的作用主要是为了传入数据，因此在传入之前必须进行赋值 但是在函数内部可改可不改
* out的作用主要是为了传出数据，因此在结束的时候必须赋值 就是在函数内部必须修改该值(必须赋值)
*/
}
public static void Test1(ref int x, ref int y)
{
Console.WriteLine($"Test1方法中x:{x}，y:{y}");//10 20
x = 21;
y = 31;
}
public static void Test2(out int x, out int y)
{
//Console.WriteLine($"Test2方法中x:{x}，y:{y}");
x = 100;
y = 200;
Console.WriteLine($"Test2方法中x:{x}，y:{y}");//100 200
}
}
•变长参数：关键字 params
//变长参数关键字 params
static int Sum(params int[] arr)
{
int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
sum += arr[i];
}
return sum;
}
在Main方法里填: Sum(1,549,256,8646,164,0);//这里为了省地方不写了
//params int[]意味着可以传入n个int参数 n可以等于0 传入的参数会存在arr数组中
// 注意:
//1.params关键字 后面 必为 数组 意味着只能是同一类型的可变参数
//2.数组的类型 可以是 任意的类型
//3.函数参数可以有 别的参数和 params关键字修饰的参数
//4.函数参数中只能出现一个params关键字 并且一定是在最后一组参数 前面可以有n个其它参数
static void Eat(string name, int a, int b, params string[] things) { }
//可选参数
//有参数默认值的参数 一般为可选参数
//1.支持参数默认值 每个参数都可以有默认值
//2.如果要混用 可选参数 必须写在 普通参数后面
•函数重载：
//重载概念
//在同一语句块(class或者struct)中
//函数 (方法) 名相同
//参数的数量不同 或者 参数的数量相同,但参数的类型或顺序不同
//作用
//1.命名一组功能相似的函数,减少函数名的数量,避免命名空间的污染
//2.提升程序可读性
//注意
//1.重载和返回值类型无关,只和参数类型,个数,顺序有关
//2.调用时 程序会根据传入的参数类型判断使用哪一个重载
static int CalcSum(int a,int b)
{ return a + b; }
//参数数量不同
static int CalcSum(int a, int b,int c)
{ return a + b + c; }
//数量相同 类型不同
static float CalcSum(float a, float b)
{ return a + b; }
//数量相同 类型不同
static float CalcSum(int a, float b)
{ return a + b; }
//数量相同 顺序不同
static float CalcSum( float b, int a)
{ return b + a; }
//ref 和 out
//ref和out 可以理解成 他们也是一种变量类型 所以可以用在重载中 但ref和out不能同时在相同位置修饰
static float CalcSum( float b,ref int a)
{ return b + a; }
static float CalcSum(out float b, int a)
{
b = 1.1f;
return b + a;
}
static int CalcSum(int a,int b,params string[] things)
{ return a + b;}
static void Main(string[] args)
{
CalcSum(1, 2);
CalcSum(1, 2, 3);
CalcSum(1.2f, 3.4f);
CalcSum(1, 3.4f);
CalcSum(3.4f, 1);
}
•递归函数：
//递归函数 就是 让函数自己调用自己
//一个正确的递归函数
//1.必须有结束调用的条件
//2.用于条件判断的 这个条件 必须改变 能够达到停止的目的
// 用递归函数打印出 0到10
static void Fun(int a)
{
//第四步:结束条件
if (a > 10)
{ return; }
//第二步:完成要求 打印
Console.WriteLine(a);
//第三步:完成一个递归的变化 作为我们条件的判断
++a;
//第一步:构造了一个递归
Fun(a);
}
static void Main(string[] args){ Fun(0); }
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
