C#基础摘录2

构造函数 => 没有返回值，名字必须和父名相同（结构体，类 。。。）

（必须完全赋值，但不一定全部需要传入参数）（结构体不能定义无参数构造函数）（结构体的构造函数必须+public）

（结构体有默认构造函数，不能被重载）

当对象new的时候，会立刻调用构造函数

this的含义：指的是当前被定义的对象

基本数据类型 数据的结构中仅有一个成员（一种状态，一种属性）

复杂数据类型 数据的结构可包含多个成员，一般由基本数据类型组合或变化而来（更好的管理数据，让使用者更好的理解数据）（例：枚举（复杂数据类型）（一种由一组称为枚举数列的命名常量组成的特殊类型））

enum 枚举名（自定义的类型名称）
{
  枚举项1，枚举项2，枚举项3
}

枚举可用初始值来重写默认值，可以赋值  枚举项1转换成整形自动为0，可以如下来重写枚举项

（第一个枚举项不赋值，默认为0，若某一个枚举项手动赋值，后面的枚举项的值默认向后进1 即若赋值第一项（a1）为 5 ,那么(a2)=6,(a3)=7）

enum A 
{
   a1 = 5,
   a2,
   a3
}

枚举名（自定义枚举名） 变量名 = 自定义枚举名.某一枚举项 如果定义的枚举是上面这个，那么枚举变量定义如下

A myEnumName = A.a1;
//那么myEnumName 就将作为枚举变量名，并代表A.a1
//可以重写该变量的指引：
myEnumName = A.a2 或 myEnumName = A.a3 
//也可以这样
myEnumName++;如果当前代表是A.a1,直接就代表下一个，即a2

强制转换可以转换枚举型 自定义枚举名.枚举项  =（自定义枚举名）7（整型）（例：A myEnumName = (A)6   int i = (int)myEnumName来把枚举转成整型的值）

枚举与字符串之间的转换

A a = Enum.Parse("hehe");
A a =(A)Enum.Parse(typeof(A),"hehe");
//如果给定的字符串再对应的枚举项中没有，会出现转换错误

基本数组===>数据元素必须是同一类型

格式： 数据类型[] 数组名（也可以叫变量名） = 指定长度并赋予初始值   ===> int[] array = new int[n]{1,2};

或  数据类型[] 数组名（也可以叫变量名）= 仅指定长度   ===>int[] array = new int[n];

或  数据类型[] 数组名（也可以叫变量名）= 初始值   ===>int[] array ={1,2,3,4,5};

二维数组 ===>int[ , ] array = new int[  , ] = {{},{}};  二维数组获取长度==>GetLength(0)左边维度长度，GetLength(1)右边维度长度

本质上在内存中一维和二维是一样的，多维数组用于解决重复数据的复杂逻辑

交错数组 ===> 数据类型[][] 变量名 = new 数据类型[][]{new int[n], new int[j],new int[m]}(在[][]中，第一个[]是最外层)(访问方式：先用foreach获取A[][]内包含的数组，再for()遍历)

（多维数组和交错数组的区别）==>多维数组每个维度的元素都相等，如果当成横竖分布的话，二维数组是个矩形，多维数组也是矩形块组成的，而交错数组可以表示锯齿块

迭代器 foreach(var itme in array){}(特点：1.会造成内存碎片，2.var 会自己推断出变量的类型，也可以直接赋予类型，3.in后面的是数据结构)

引用类型在内存中存储的是地址

string 字符串由一个引用指向堆中的char数组使用，因为我们可以用下标的形式访问字符串中的每一个字符

isNullOrEmpty()判断一个字符是不是空字符，返回一个布尔

Trim 切除首尾指定字符

Slipt 切割字符串

SubString 取子串

函数（方法）==>是对逻辑的一种封装，方便复用，是将一堆代码封装进行重用的一种机制（不能在函数体内定义另外的函数，类，结构，接口 ...）

只能声明在类，结构体，接口中

特点：有效节约代码量，提升代码可读性

方法中如果能拷贝实际内存地址我们就可以正常改变实参的值

ref （将函数参数传参由取值变成取地址）函数（ref int 形参，ref int 形参）==>调用时，实际参数必须有被赋值==>函数（ref 实参，ref 实参） ref => 引用类型 

用out来返回一个检测结果，out 要求在函数体内一定要经参数赋值（原有的值不可用）例：

string info;
if(Login(user,password,out info)) 
console.writeline(info);

由于==>out参数==>一定要有赋值==>更严谨==>检测用out关键字

params(必须是最后一个参数) 参数修饰符  //可变参数修饰 将一个数组参数变成允许调用者用数组参数传参

在定义是必须Params，调用时直接填数组元素

//不用定义数组变量，直接调用函数时传参

如果定义中有static 就是用类名调用的方法，没有static就是用变量名调用

结构体 struct （初学者可以认为跟类差不多）

struct 结构名  可以一次性声明多个不同类型变量，也可多个相同
{
  成员1；   成员可以为所有基本数据类型，所有复杂类型，但是在使用自身必须时静态的
  成员2;
}           当结构体成员为Public时，可以通过结构体对象，成员名来访问

（属性不多，频繁计算复杂事物）使用struct，计算少的不要定义为struct

特点：运算快（放在栈里计算）也可以不放在栈里

静态的函数在代码运行前就已经存在了，而非静态的函数，是在代码运行之后，定义类之后才有的

函数允许我们重名，重名函数在重载的情况下时允许的

参数列表不一样时构成重载

重载函数有助于我们统一理解逻辑 例：

static int Sum(int a,float b){return (int)(a+b);}
static float Sum(float a,int b){return (float)(a+b);}

在类中声明的变量叫全局变量

静态变量（公共全局的变量，大家都可以用的唯一变量（会占用静态存储区）（static用 类名.静态变量来用））

函数递归 指 函数自身调用自身的一种算法，递归可能造成堆栈异常，在递归过程中，必须要有边界（即得有一种已知情况，用来充当边界）找出边界参数==>(必须要由父问题交给子问题（必须要由函数传递）这个参数在传递过程中要无限趋近边界变化)

 

static int A(int num)
{
  if(num<=1)return 1;
  else return num*A(num -1);
}

   面向对象：一种思想 （程序逻辑，程序的结构）程序设计思路，时一种程序结构的表述

特点：封装，多态，继承

具有相同属性的抽象（类）====>对象、属性、行为
属性=====>字段（类中所有数据类型），属性（保护字段）
行为=====>方法（函数）
对象=====>是类的实例，具有类的属性和方法（非静态）

访问修饰符 class 类名
{
  字段;
  属性;
  方法;
  构造函数(构造函数没有返回类型)（构造函数名和类名一致）格式==>public 类名(...){...}
}



pulic class A  自定义一个类，里面自定义一些属性和方法
{
  public A(string n,int a)    这个作为一个有参构造函数，当类被new出对象时自动调用，当然new的时
                              候也要填参数 ===> A myClass = new A("ltf", 18); 
  {
     this.name =n;
     this.age =a;
  }

  (pubic A(){} 也可以声明一个无参构造函数，也可以以重载的形式声明多种构造函数)
   
  string name;
  int age;
  public void func()
  {
     console.writeline("hehe");
  }
}

A a = new A();    new关键字（结合构造函数）可以实例化一个具体的对象
A.name ="ltf";    通过new 来创建类的实例（对象），然后调用这个实例的属性和方法来用出来
a.age =18;
a.func();

我们尽可能将类定义在另一个类外面

但是类也允许在类里面定义

实例化==>在内存中开辟一块空间，然后初始化; 
整个类的使用流程 （构造==>被使用==>析构）（析构简单来说就是被垃圾回收，结束使用这样子）

  //重载中如果逻辑重复的情况下可以这样：

构造函数 1. public A(string name):this(name,18)

                2.public A(string name,int age)

用1 调用 2（参数少的调用参数长的）用（:this()）引用类型可以用Null

引用类型包括字符串（特殊引用类型）、数组、类、接口、委托等

直接存储的是地址，地址指向（引用）堆中的实际数据

值类型直接存储的数据，由系统自动释放资源的数据类型，包括除字符串外的基本类型、枚举、结构等

堆===>存放引用类型的对象数据      

栈===>C#中所有的值类型的值和引用类型的引用都分配在栈上，栈根据后进先出原则，依次对分配和释放内存对象，由编译器自动分配释放   

装箱：将值类型转换为引用类型   

拆箱：将引用类型转换成值类型

类的静态方法在主函数中用类名调用，静态构造函数==>只有在第一次new时被执行，之后不执行

静态构造函数和构造函数 互不影响，第一次==>两个构造函数都调用

try{} catch(){} 尝试捕获异常

finally(){}==>在return前强行调用