class 类

1.类是一种常见的引用类型，万物皆可类。

class  YourClassName
{

}

       A：在Class之前有类的特性和类的修饰符：

      （非嵌套类的修饰符有，public---公开公共的，哪里都能访问,、internal、abstract、sealed、static、unasfe、partial）

       B：紧跟YourClassName：泛型参数，唯一基类与多个接口。

       C：在{ } 内，类成员（字段、属性、方法、索引器、事件、构造器、重载运算符、嵌套类型和终结器、）

1.1：字段（ Field 类成员）、静态字段常量

      1.字段的初始化逻辑在构造器之前运行。类不占内存，对象是占内存的。

      2.字段的初始化可以包含表达式或者调用其他方法。

       A：静态修饰符static

       B：访问权限修饰符：、 默认修饰符 private---私有的，只能在本类中访问，默认是私有的

       public   、protected、internal 

       C: 继承修饰符  new

       D：不安全代码修饰符：unsafe

       E：只读修饰符 readonly(只能在声明时候赋值，或者在所属的类型构造器中赋值。)

       F：线程访问修饰符号：volatile

       G：字段初始化的默认值：0、\0、null 、false.

       H: 可以同时声明多个字段

public string  _name, _address, _number ;

1.2：常量（ const ）：常量是一种值永远不会改变的静态字段，常量会在编译时静态赋值，

        A：常量会在编译时静态赋值；

        B：类型：bool，char、string等基本类型、 枚举等

public const string _message = "abcd123@xxx.com" ;

       C：常量和 static  readonly 修饰的字段非常相似，

          1.System.Math.PI 是PI的常量，在编译时确定值3.14xxxx

           2.static readonly 在运行时可以取不同的值。

static readonly DateTime StartUpTime = DateTime.Now;

     D : 常量也可以在方法内部声明

          访问权限修饰符 public  internal   private   protected  

          继承修饰符：new 

1.3：方法（Method  类成员）

      1. 方法是一组语句实现某个行为。

      2. 从调用者指定的参数中获得输入的数据，并通过指定的输出类型将输出数据返回给调用者。 

      3.方法也可以是void 无返回值类型，方法还可以通过ref / out参数向调用者返回输出的数据。

      4.方法的签名在这个类型的签名中必须是唯一的。（方法名和和一定顺序的参数类型）

          不包含：参数名和返回值类型。

       A：静态修饰符static

       B：访问权限修饰符：public 、private、protected、internal 

       C: 继承修饰符  new、virtual  、abstract 、override、 sealed

       D：分部方法修饰符：partical 

       E：非托管修饰符：unasfe、extern

       F：异步代码修饰符：async

      方法重载实例：

void  method(int i ){   }
void  method(double i ){   }
void  method(int i ,float j){   }
void  method(string s,int i ){   }

      如下方法不能同时出现在一个类型中，方法的返回值类型和和params不属于方法的签名的一部分。

void Method (int i ) { }
float  Method (int i ) { }          //error
----------------------------
void Method(int[] num){  }
void Method(params int[] num){  }      //error

     参数按照值传递还是按照引用传递，也是方法签名的一部分，out和ref不能同时出现。

void Method (int i) { }
void Method (ref int i ) { }    //ok
void Method (out int i ) { }    // error(out和ref 不能同时出现)

局部方法不能是static修饰，如果父方法是静态的，那么局部方法也是隐式静态的。

     局部方法的优势：1.仅在这个代码块中可见。2.可以访问父方法的局部变量和参数，3.可以出现在其他类型的函数中，属性访问器，构造器，4.可以将局部方法放在局部方法中，放在lambert中，

进阶提示：如果普通方法中添加了局部静态方法，将无法使用父级方法的变量和参数，避免耦合，又可以定义局部方法和父级方法的变量名的冲突。

摘录： 限制:

1、局部方法仅用于局部类中。
2、局部方法的返回值必须是void。
3、局部方法可以是静态的或者是实例化的。
4、局部方法可以有参数，可以包含参数修饰符如this、ref 或 params，但是不包括 out 修饰符。
5、局部方法隐式的访问级别为 private，因此不能为 虚 方 法。

 1.4：实例构造器方法 (构造函数  constructor  类成员 ）

        A：实例构造器的名字和类型必须相同，没有返回值，连void都没有。

       B：访问权限修饰符：public 、private、protected、internal 

       C：非托管修饰符：unasfe、extern

       D: 可以重载构造函数，（方法的签名：名称相同，参数类型 || 数量不同）

       E： 让一个构造函数去调用另一个构造函数用this关键字（被调用的构造函数先行执行）

       F：隐式无参构造器，一旦创建了一个构造函数，无参构造函数就没有了

       G：构造函数和字段初始化顺序：字段可以在声明是赋初始值。

       H ：字段的初始化在构造器之前进行。

-----------------------------------------------------

注：构造器私有化，可以防止外界对类进行实例化，然后创建一个静态方法，来控制类实例的创建。

class YourClassName
{
     YourClassName();   //private constructor
     public static YourClassName create()
     {
      // ------
     }
}

public class Wing
{
    public double Price;
	public int Year;
	public Wing(double p){Price = p;}
	public Wing(double p,int y):this(p)
	{ 
		Year = y;
	}
    public Wing(double p,DateTime year):this(p,y.Year)
	{
	}
}

1.5：对象初始化器

    为了简化对象的的初始化，可以在调用构造器之后直接通过对象初始化器设置对象的可访问字段或者属性。（也可使用可选参数...核心技术Q99）

	//
    Person p = new Person{_name ="joy",_age=20};
	Person p1 = new Person("bob"){_age=22};
    //

public class Person
{
    public string _name;
	public int _age;
	public Person(){}
	public Person(string n){_name=n;}
}

1.6：this引用

     1.代表当前类的对象，避免当前类的字段，属性和局部变量之间发生混淆。

     2.在类中显式调用本类的构造函数。仅在类、结构的非静态成员中有效。

     3.可以作为方法参数传递

1.7：属性（ Properties  类成员）类似字段，内部含有方法一样的逻辑

    1.属性的本质是，内含有get / set  访问器 。

    2.属性的赋值和存值，本质上是对字段的赋值，可以对字段的取值和赋值进行限定。

    3.属性修饰符

       A：静态修饰符 :  static

       B：访问权限修饰符：public 、默认修饰符private、protected、internal 

       C: 继承修饰符  new、virtual  、abstract 、override、 sealed

       D：非托管修饰符：unasfe、extern

get / set方法内置代码：给属性赋值，最终值保存在字段中，属性就是中间商过渡的问题。

public void set_Name(string value)
{
   this._name = value;
}

public string get_Name()
{
   return this._name;
}

如下实例： 在set或者get中限定范围。get是取值限定，set是赋值限定。

public class Myclass 
{
    public int _age;   //赋值是value的原始值可能是负数，或者超过120，调用get才限定。
	public int Age
	{
		get
		{
			if(_age>=120||_age<=0)
			{
			   return 18;
			}
            else
			{
			   return _age;
			}
		}
		set
		{
			this._age = value;
		}
	}
	//--------------------------	
	public int _number; //在赋值的时候就是在0~120之间。
	public int Number
	{
		get
		{
		   return _number;
		}
		set
		{
			if(value>=120||_number<0)
			{
			  this._number = 18;
			}
			else
			{
			  this._number =value;
			}
		}
	}
}

自动属性

最常见的是get和set访问器读写私有字段，编译器会生成一个后台私有字段，该字段名称有编译器生成，且无法引用。

如果希望属性对其他类型暴露为只读属性，可将set访问器设置为private或者portected。

属性初始化器

public decimal CurrentTime {get;set;} = 1103M; 

1.9：静态构造器、静态成员：

     1.每个类的静态构造器只会执行一次，并且不是每个实例执行一次。

     2.一个类只能定义一个静态构造器，名称必须和类型同名，且没有参数。

              // 提示：静态构造函数必须是无参数的。

     3.触发静态构造函数执行：

         1.实例化类型（new yourClassName（）;）

          2.访问类型的静态成员。（yourClassName.静态成员;)

     4.静态构造器只支持两个修饰符：unsafe、extern ( 不能使用public等修饰符)

     5.如果静态构造器抛出异常，整个程序生命周期不可用。

      6.静态构造函数和静态字段初始化顺序，静态字段会在静态构造函数前运行。如果没有静态构造函数，字段会在被使用之前或者在运行时中，更早的时间进行初始化。

     7.静态字段初始化按照声明的先后顺序。

public class Foo
{
     public static int x = y;//初始化X为0
	 public static int y = 3; //初始化y为3
	 //--------------------------------------
     public static int m = 3;//初始化m为3
	 public static int n = m; //初始化n为3
	 //-------------------------------------

    public static int p = 33;
	public static Foo Instance = new Foo();
	
    //字段初始化器在K=3之前创建了Foo的实例。
	
    public static int k = 3;
    Foo()
	{
		Console.WriteLine(k);//初始化k为0
		Console.WriteLine(p);//初始化k为33
	}
}

   

public class Foo
{
	 public static int x = y;//初始化X为0
	 public static int y = 3; //初始化y为3
	//--------------------------------------
     public static int m = 3;//初始化m为3
	 public static int n = m; //初始化n为3
	//-------------------------------------
	public static int p = 33;
	public static Foo Instance = new Foo();
	//***************************************
	public static int k = 3;
	static  Foo()
	{
		Console.WriteLine(k);//初始化k为3
		Console.WriteLine(p);//初始化k为33
	}
}

---------------------------------------------------------------------------------------------------

笔记：

1.静态成员属于类，普通实例成员属于类的实例

2.静态成员使用类名.静态成员。普通成员用对象去调用。

3.静态方法只能访问静态成员，不能访问实例成员

4.实例方法可以访问静态成员。（实例的范围比静态的范围大）

--------------------------------------------------------------------------------------------------

1.10：静态类（静态类不能有派生类）

        1.System.Console 和System.Math就是最好的静态类

        2.静态类中只能书写静态成员（字段，属性，方法），不允许有实例成员。

        3.静态类不能创建静态类的实例（不允许被实例化）。

        4.如果类当做一个工具类，去使用可以考虑的设定为静态类。

        5.项目中，在项目中资源共享的。（类不占内存，对象实例占内存，静态类例外，本身是占内存。）（内存-5块区域，）

       6.只要有程序运行，静态类就不会删除资源。只有程序停止了静态类才能释放资源。

     

    A.堆：

     B.栈：

     C.静态存储区：在项目中谁都可以访问静态存储区。

     垃圾回收器：GB   GarbageCollection释放资源。

1.11：终结器

1.12：分布类型和方法

1.13：nameof 运算符  返回任意符号的字符串的名称（类型，成员，变量）