C#学习笔记

C#学习笔记（一）：数据类型 
C#数据类型分为两大类：数值类型和引用类型；
    一、数值类型包括：整型、字符型、布尔型、浮点类型、小数类型、结构、枚举
        1、整数类型：byte、sbyte、short、ushort、int、uint、long、ulong，常用的是int；
        2、浮点类型：float、double；
        3、小数类型：dicemal；
        4、字符类型：char；
        5、布尔类型：bool；
    二、引用类型包括：字符串、数组、对象类型、类、接口、代理
        1、对象类型：object；
        2、字符串类型：string；
    三、赋初值
    四、类型转换：隐式转换、显式转换；打包转换、拆包转换
        1、隐式转换：低级数据类型向高级数据类型转换，结果为高级数据类型；
        2、显式转换：造型（CAST）
        3、打包转换和拆包转换：堆（Heap）和栈（Stack）的区别；
    五、简单数值类
        1、两个域：MaxValue和MinValue；

C#学习笔记（二）：运算符和表达式 
1、算术运算符
    1）++、--在变量左右的区别
    2）负号运算符：例如-3+-3等同于-3-3
2、逻辑运算符
3、关系运算符
4、其他运算符
    1）is运算符：x is int
    2）?:运算符：
    3）as运算符：
            object x = 5.4F;
            object y;
            y = x as float;
    4）typeof运算符：
5、checked和unchecked 

C#学习笔记（三）：选择和循环结构 
1、if语句
    1）if(...) 
    2）if(...) else
    3）if(...)
          else if(...)
          else if(...)
          else
    注意嵌套的判断语句，从最内层开始，else总是和他最上面并且没有配对的if语句配对
2、switch语句
    switch(...)
    {
       case ... :
       case ...:
       ...
       default:
    }
3、while语句
    while(...)
     {
        ....
      }
4、do－while语句
      do
        {
         ...
         }
      while(...)
5、for语句
     for(...;...;...)
       {
        ...
        }
6、foreach－in语句
     foreach( ... in ....)
       {
        .....
        }

C#学习笔记（四）：数组 
1、一维数组
    1) int[] intArray = new int[10];
    2) int[] intArray;
        intArray = new int[10];
    3) int[] intArray = new int[10]{1,2,3,4,5,6,7,8,9,0};
    注意：不允许初始化部分元素，必须全部初始化
2、多维数组
    1) int[,] intArray = new int[3,2];
    2) int[,] intArray;
        intArray = new int[3,2];
    3) int[,] intArray = new int[3,2]{{0,1},{1,2},{2,3}}
3、嵌套数组
        int[][] intArray = new int[2][];
        intArray[0] = new int[2];
        intArray[1] = new int[3];
4、System.Array类
    1、属性
        Length
        Rank
    2、方法
        Sort         Reverse
        IndexOf   LastIndexOf

C#学习笔记（五）：面向对象和类 
面向对象
    1、数据封装
    2、代码重用
    3、多态性
    4、重载
命名空间
    using [alias=]namespace;
声明自己的类
    1、封装数据
        private int count;
        ... ...
    2、构造和析构
        构造：public 类名(...) {...}，可存在多个
        ~类名：析构，一般不需要
    3、方法
使用自己的类
域
    静态域：public static int field1;
    只读域：public readonly int field1;
属性
    修饰符 类型 标识符 {代码}
    private string name;
    public string Name
        {
            get{rerurn name;}
            set{name = value;}
        }
索引
    修饰符 类型 this[索引值]
    private int[] Array = new int[5];
    public int this[int index]
        {
            get   
                {
                    rerurn Array[index];
                }
            set
                {
                    Array[index] = value;
                }
        }
重载
    关键是参数不一样
    params：后面不能再有其他参数，因此一般是最后一个参数
    ref、out：实参前也必须加ref、out关键字，ref于out的区别在于out关键字不需要实参必须提前初始化
运算符重载
    语法：public static 返回类型 operator 运算符（参数）{代码}
    数据转换也可重载
    语法：public static implicit operator 转换后的类型（被转换的数值）
                public static explicit operator 转换后的类型（被转换的数值） 

C#学习笔记（六）：继承 
继承的初步
    1、派生：
            被继承的类叫基类、父类，继承而来的类叫派生类、子类
            class 子类名称 : 父类名称
                {
                .....
                }
            子类可以重载父类的方法，注意行参的不同
            在子类中构造新对象时，不仅要调用子类的构造器，还要调用父类的构造器，并且，这些被调用的构造器必须具有相应的参数列表
    2、base关键字
            子类可以利用父类的各种成员，但是子类只能利用父类中被声明为public和protected的成员
            base关键字是为了在子类中替代父类的名称
    3、禁止继承
            封闭类的概念：sealed
            sealed关键字不仅可以用来声明类，还可以用来声明“封闭”的方法和属性
    4、保护访问
            protected关键字：只在类的继承树链上可见
    5、内部访问
            internal关键字：在一个assembly内部可见
    6、成员访问级别
            private：私有成员只能在声明成员的类中使用
            protected internal：成员只能在同一个类及其子类中被使用，并且所有在类必须在一个assembly中
            internal：在一个assembly中访问
            protected：只能在类继承树链上被访问
            public：不受限制
多态性和虚成员
    1、在父类中利用virtual关键字来声明虚成员，虚成员可以是类的方法、属性和索引，不可以是域或者私有成员变量
    2、在子类中用override关键字来重新声明虚成员
抽象类
    1、abstract关键字
    2、抽象方法不可以为其实例化任何代码，在方法声明时，不可以在方法后使用{}；
    3、抽象属性需要指出属性的get或者set部分，但是不能实例化任何代码；
造型
        只允许用父类造型子类 

C#学习笔记（七）：接口和代理 
接口
    1、接口的声明
        1）语法：[修饰符] interface 接口名称[:父接口名称]{代码};
        2）要点：
                a、声明接口成员的时候，不可以为接口成员指明任何访问修饰符；
                b、不可以为成员实例化任何代码
    2、接口的使用
        1）使用一个接口只有通过类的继承来实现
        2）子类不仅可以从父类继承，还可以从接口继承
        3）当一个类从接口继承之后，必须在子类中实例化父接口中的所有成员
    3、接口与抽象类的比较
        1）在接口中，不能声明域或者私有变量
        2）声明接口成员时，不能使用任何访问修饰符
        3）接口一旦被继承，则在子类中必须实例化所有成员，而抽象类则可以根据需要重载部分成员
        4）接口允许多重继承
        5）接口相对抽象类具有更高的抽象层次
    4、System命名空间的常用接口
        1）ICloneable：Clone方法
        2）IComparable：CompareTo方法
        3）IConvertable：
        4）IFormatable：Format方法
代理
    1、代理的声明
        [修饰符]delegate 返回类型 代理名称（参数列表）；
    2、代理的使用
        使用new运算符创建一个代理对象，同时为代理对象指明引用的方法名称
    3、System.Delegate类
        Method和Target属性
    4、事件
        修饰符 event 类型 标识符
        修饰符 event 类型 标识符{get{};set{};}
        声明和使用一个事件需要如下步骤：
        1）创建一个代理或者使用系统代理：EventHandler
        2）在类的内部利用event关键字声明事件，并在类中定义调用事件的方法
        3）声明多个方法与事件关联 

C#学习笔记（八）：结构和枚举 
结构
    1、结构的声明
        [修饰符]struct 结构名称[：接口名称]{代码}；
        在结构中不允许存在没有参数的构造体
    2、结构的使用
        1）Point p1 = new Point(1,1);
        2）Point p1;
    3、结构和类的区别
        1）结构不允许继承
        2）结构中不允许声明一个没有参数的构造体
        3）在结构中不允许为一个实例化的域赋初值
        4）利用结构类型来声明对象的时候可以不使用new运算符
        5）结构是一种数值类型，而类是一种引用类型
枚举
    1、枚举的声明
        [修饰符]enum 名称[:各类整数类型]{列表}；
        例子：public enum test:ulong {Main=1,Max=2};
    2、枚举的使用
        从枚举类型的数值向整数类型数值转换需要使用显式类型转换
    3、System.Enum类
        1）Format方法
        2）FromString方法
        3）GetName方法和GetNames方法
        4）GetUnderlying方法
        5）GetValus方法
        6）IsDefined方法
        7）ToObject方法