C# 方法的定义

一、static关键字
　　1、静态方法与实例化方法的区别：
　　a)访问、调用方式：
　　静态方法：调用前初始化
　　实例化方法：实例化对象时初始化
　　b)静态字段：在程序编译时就预先分配空间，访问效率更快
　　实例化字段：执行到该代码段时才分配空间，需要关键字 new
　　2、静态调用关键字：static
　　静态方法能访问到其他静态成员，不能访问实例成员
　　例：
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　namespace 静态方法
　　{
　　public class Test
　　{
　　private static int member;
　　//实例方法访问静态字段
　　public void Way(int num)
　　{
　　member = num;
　　}
　　//静态方法访问静态字段
　　public static void Show()
　　{
　　Console.WriteLine("Value of member:"+member);
　　}
　　}
　　class Program
　　{
　　static void Main(string[] args)
　　{
　　Test test = new Test();
　　//对象调用实例方法
　　test.Way(40);
　　Test.Show();
　　}
　　}
　　}
　　3、静态类：若类上加上static 关键字，则该类中的成员必须为静态成员，且不能继承静态类

　　二、方法重载

　　1、含义：在同一个类中，方法名相同，参数数据类型、个数或顺序不同的方法
　　2、例：
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　namespace ConsoleApplication4
　　{
　　public class Student
　　{
　　public void Show1(int num1, int num2)
　　{
　　Console.WriteLine("两个整数相加为：{0}",num1+num2);
　　}
　　public void Show2(string sign1, string sign2)
　　{
　　Console.WriteLine("两个字符串相加等于：{0}",sign1+sign2);
　　}
　　}
　　class Program
　　{
　　static void Main(string[] args)
　　{
　　Student student = new Student(); //得到Student类的对象
　　student.Show1(12,21);
　　student.Show2("Hello", "girl");
　　}
　　}
　　}
　　三、构造函数：与类名相同，初始化成员变量
　　1、特征：
　　a)：无返回值
　　b)：可重载
　　c)：任何对象要创建成功必须先调用相应的构造函数再对属性进行赋值
　　2、语法：
　　访问修饰符 类名(参数列表)
　　{
　　//构造函数主体
　　}
　　3、默认构造函数
　　a)若类中没有显示定义构造函数，编译器会自动提供一个隐式的默认的不带参数的构造函数，当显示的定义了构造函数时，编译器则不会提供，若要使用默认的构造函数，则需显示定义
　　例：Student 类中声明两个构造函数
　　public class Student
　　{
　　private int no;
　　private string name;
　　//定义一个带int参数的构造函数
　　public Student(int num){ }
　　//定义一个带string参数的构造函数
　　public Student(string name) { }
　　} 调用构造方法实例化对象
　　Student student = new Student(); //错误 没有不带参数的构造函数 需要在Student类中手动定义一个无参数的构造函数
　　public Student(){}4、带参数的构造函数
　　例：
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　namespace 带参数的构造函数
　　{
　　public class Program
　　{
　　public int num;
　　public string name;
　　//无参数的构造函数中初始化两个字段
　　public Program()
　　{
　　num = 39;
　　name = "Shelly";
　　}
　　//带int参数的构造函数
　　public Program(int id)
　　{
　　num = id;
　　name = "Shelly"
　　}
　　//带string参数的构造函数
　　public Program(string sname)
　　{
　　num = 49;
　　name = sname;
　　}
　　public void Print()
　　{
　　Console.WriteLine("name={0}，num={1}",name,num);
　　}
　　static void Main(string[] args)
　　{
　　//实例化对象
　　Program p1 = new Program();
　　p1.Print();
　　//int
　　Program p2 = new Program(29);
　　p2.Print();
　　//string
　　Program p3 = new Program("Hi");
　　p3.Print();
　　}
　　}

　　}

　　5、静态构造函数：不需要访问修饰符
　　例：
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　namespace 静态构造函数
　　{
　　public class Test
　　{
　　//静态字段
　　private static int num;
　　//静态构造函数
　　static Test()
　　{
　　num = 10;
　　Console.WriteLine("num="+num);
　　}
　　static void Main(string[] args)
　　{
　　Test test = new Test();
　　}
　　}
　　}


　　6、析构函数
　　析构方法的重要内容：
　　1) 不带参数
　　2) 每个类中有且只有一个
　　3) 不带访问修饰符
　　4) 与类名相同，以~作前缀
　　5) 不能在代码中显示调用析构方法，在垃圾收集过程中调用，垃圾器分析代码，并确定在代码中没有任何途径引用该对象
　　注意：若不需要就避免执行，只应释放对象自己外部的资源，不应该访问其他对象

　　例：
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　namespace 析构函数
　　{
　　public class ShowClass1
　　{
　　public ShowClass1()
　　{
　　Console.WriteLine("调用构造函数:ShowClass1");
　　}
　　~ShowClass1()
　　{
　　Console.WriteLine("调用析构函数:ShowClass1");
　　}
　　}
　　public class ShowClass2
　　{
　　public ShowClass2()
　　{
　　Console.WriteLine("调用构造函数:ShowClass2");
　　}
　　~ShowClass2()
　　{
　　Console.WriteLine("调用析构函数:ShowClass2");
　　}
　　public void test()
　　{
　　ShowClass1 sc1 = new ShowClass1();
　　ShowClass2 sc2 = new ShowClass2();
　　}
　　}
　　class Program
　　{
　　static void Main(string[] args)
　　{
　　//析构函数调用
　　Program pro = new Program();
　　pro.test();
　　Console.WriteLine();
　　}
　　//析构函数的实例化
　　public void test()
　　{
　　ShowClass1 sc1 = new ShowClass1();
　　ShowClass2 sc2 = new ShowClass2();
　　}
　　}
　　}
　　构造函数与析构函数不同点：
　　1)实例化：构造函数：创建类的每个新实例时调用一次
　　析构函数：在每个实例被销毁前调用
　　2)静态：构造函数：只调用一次，在类的任意静态变量第一次被访问之前，或在实例被创建之前
　　析构函数：不存在，只有实例才有析构函数
　　7、readonly关键字
　　1)、与const不同点：
　　字段初始化：readonly：可以在声明字段时初始化，也可在构造函数中初始化
　　const：只能在声明时初始化
　　字段状态：readonly：可静态页可非静态
　　const：总是静态
　　2)、例：
　　public class Evaluation
　　{
　　public int x;
　　//声明readonly字段
　　public readonly int y = 25; //在声明时初始化值
　　public readonly int z;
　　public Evaluation(int x)
　　{

　　this.x = x;
　　//在构造函数中初始化值
　　z = 25;
　　Console.WriteLine("x={0},y={1},z={2}",x,y,z);
　　}
　　public Evaluation(int num1,int num2,int num3)
　　{
　　x = num1;
　　y = num2;
　　z = num3;
　　Console.WriteLine("x={0},y={1},z={2}", x, y, z);
　　}
　　}
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　class Program
　　{
　　static void Main(string[] args)
　　{
　　//readonly关键字在声明或构造函数中初始化
　　Evaluation show = new Evaluation(11,21,31);
　　Evaluation show2 = new Evaluation(22);
　　}
　　}

　　View Code


　　8、this关键字：在类中访问自身成员，常用在索引器中
　　使用范围：实例化构造函数、实例方法、属性和索引的实力访问器、用于区分类的成员和本地变量或参数、作为调用方法的实参
　　例：
　　public Round(double r)
　　{
　　this.r=r;//用于区分类成员和参数
　　}
　　9、索引器：对象的数组访问器
　　a)使用范围：在任何可以声明属性的地方都可声明
　　b)语法：
　　访问修饰符 数据类型 this [数据类型 标识符]
　　{
　　get{};
　　set{};
　　}
　　c)注意：仅有一个元素时，没有必要使用索引器进行访问，索引器专门针对于数组进行索引

解决问题的思路


往下：半小时一次


往上：固定上传，出错做异步抛掉数据


低于250：算次数
高于250：固定积分
规则


监控端：