函数定义和使用函数
小理解
怎么样能被定义为函数呢，其实也就是把一些重复的操作，专门放在一个地方/代码块里面，需要用到的时候在调用就可以了，特定类型的函数称为方法。
函数的好处呢，提高代码的可读性，函数可以创建多用途的代码
简单使用
static void Write(){
Console.WriteLine("这是write函数");
}
static void Main(string[] args)
{
Program.Write();
Console.ReadKey();
}
//定义函数的时候必须适用圆括号
//函数名：PascalCase返回值
void就是一个，当函数返回一个值时。不能使用void。使用return结束函数的执行，把返回值给调用的
表达式体方法使用
static returntype functionname ()=><myvall*myvalue2>参数
形参是函数定义的一部分，而实参则有调用代码传递给函数。
(paramtype paramname)这种形式
调用参数时，必须是提供的参数和函数定义的参数完全匹配
关于参数数组，只能指定一个，这个参数必须位于函数定义当中参数的最后一个，可以允许使用个数不定参数来调用。params type[] paramsname。
在使用参数的时候，是把一个值参数传递给一个函数所使用的变量，在函数中对此变量的任何修改都不影响函数调用中指定的参数。
ref参数，和out参数，在前面方法中提到了
把未赋值的变量用作ref参数时非法的，但可以使用未赋值的变量out参数，在函数中使用out参数，把它看作未赋值的
元组
从函数返回多个值用怎样的方法呢，out参数，结构，数组？如果需要用代码来创建，初始化，引用和读写，就应该考虑元组了。
var numbers={1,2,3,4,5}变量的作用域
考虑局部作用域和全局作用域的含义，在一个代码块内部，外部为什么不能调用。
局部作用域可以有相同的名称，不会相互干涉
Main()函数
main函数作为c#应用程序的入口点，执行这个函数就是执行应用程序，也就是main函数结束，整个应用程序也就结束。
结构函数
struct CustomerName{
public string firstName;
}委托
委托是一种储存函数引用的类型。委托的声明类似于函数，但不带函数体，要是用delegate关键字。委托的声明包含一个返回值和参数列表。
嵌套类和匿名类
//嵌套类
//在c#中可以将一个类的定义在另一个类的内部
//外面的类叫外部类，内部的类叫嵌套类
//外部类和内部类之间可以相互访问
//new 外部类.内部类()可以创建内部类的对象
//非静态类访问需要创建类对象
//静态成员可以之间访问或通过类名访问，
//外部类
class Ab{
//内部类
class Ba{
}
}
internal class Program
{
static void Main(string[] args)
{
OuterClass.InnerClass innerclass=new OuterClass.InnerClass();
innerclass.Show();
OuterClass outerClass=new OuterClass();
outerClass.Print();
Console.ReadKey();
}
}
//外部类
class OuterClass
{
public string name = "OuterClass";//如果静态成员,如果非静态成员
public void Print() {
Console.WriteLine($"{name}");
//Console.WriteLine($"{InnerClass.name}");
Console.WriteLine($"{new InnerClass().name}");
}
//内部类
public class InnerClass
{
public string name= "InnerClass";//如果静态成员,如果非静态成员
public void Show() {
Console.WriteLine($"{name}");
// Console.WriteLine($"{OuterClass.name}");
Console.WriteLine($"{new OuterClass().name}");
}
}
}
//匿名类
//如果某个类的实例对象只会使用一次，可以使用匿名类的方式创建这个对象。
//不需要定义类，我们就可以创建一个对象
//这样的类一般用于存储一组只读数据
var p=new {Name="zhangsan",Age=18};
this和static使用
#region
//this
//定义：this关键字主要指的是调用者本身，调用者当前对象
//区分成员字段和局部变量
//调用其他构造函数
class Student{
public int id;
public string name;
public Student(){
Console.WriteLine("无参构造函数")
}//无参构造函数
//this可以指向当前对象的另一个构造函数
public Student(int id,string name)：this(){
//this代表当前对象，也是赋值的对象student
this.id=id;
this.name=name;
Console.WriteLine("有参构造函数")
}
}
Student student = null;
student = new Student(100,"zhangsan");
#endregion
//static
//如果使用static修饰函数该函数就是静态函数，如果不修饰就是非静态函数
//静态函数可以直接使用类名调用，非静态函数必须使用对象调用
class MyMath
{
public static double GetAtea(double x)
{
return x * x*3.14;
}
}
//静态函数可以直接使用类名调用
Console.WriteLine(MyMath.GetAtea(10));
Console.ReadKey();
//静态函数：静态函数中使用的静态字段
//静态字段：静态字段的初始化最好放在静态构造函数中
//静态属性：静态字段的属性一定是静态属性
//静态构造函数：主要用于静态字段的初始化，类加载的时候自动调用，不需使用new关键字调用
//静态类：所有的成员都是静态的类称之为静态类运算符重载
//运算符重载指的是给特定的运算符指定新的运算规则
class Vector
{
private int x;
private int y;
private int z;
//运算符重载，当运算符重载的是条件运算符的时候不允许成对出现
public static bool operator==(Vector a, Vector b)
{
return a.x==b.x&&a.y==b.y&&a.z==b.z;
}
public static bool operator !=(Vector a, Vector b)
{
return a.x != b.x || a.y != b.y || a.z != b.z;
}
//运算符+
public static Vector operator +(Vector a, Vector b)
{
return new Vector(a.x + b.x , a.y + b.y , a.z + b.z);
}
public Vector()
{
}
public Vector(int x, int y, int z)
{
this.x = x;
this.y = y;
this.z = z;
}
public void GetArea()
{
Console.WriteLine($"x={x},y={y},z={z}");
}
}
static void Main(string[] args)
{
Vector v = new Vector(1,2,3);
Vector v1 = new Vector(3,2,1);
Vector v2 = new Vector(3,2,1);
v.GetArea();
v1.GetArea();
Console.WriteLine(v == v1);//false
Console.WriteLine(v != v1);//true
Console.WriteLine(v1==v2);//false//为什么呢，比较的是地址，所以用运算符重载，改成比较的是值
Vector v5=new Vector(7,7,7);
Vector v6= new Vector(8,8,8);
Vector v4=v5+v6;
v4.GetArea();
Console.ReadKey ();