（6）C#传智:枚举、结构、数组(第六天)

一、常量
    定义：永远不能变化的量。不能再次赋值。而变量可以多次赋值。
    声明： const 变量类型 变量名=值;
    何时用常量：不希望随意改变的值，方便程序维护和一次性改变。

     常量与静态变量的区别：

       两者都在编译时就被赋值。const必须手工赋初值（否则报错），存在于整个程序运行期，且整个程序生命周期不能被改变。

       静态变量不必手工赋初值（但程序会赋默认值，且不会报错），存在于整个程序运行期，但它的值可以被修改。

     问：常量可以为对象吗？

     答：一般不能。

            常量（const）可以是任何类型的值，包括对象。但是，有一个重要的限制：常量对象必须是在编译时就能确定的，这意味着你不能将常量设置为任何需要在运行时构造的对象。换句话说，常量对象必须是字面量，或者是已经存在的、不可变的对象。

          因此，将常量设置为一个需要在运行时创建的对象，比如一个类的实例，编译器会报错。

          但可以将常量设置为字符串字面量，例如"Hello World"，这是一个对象，但不需要运行时生成，所以是可以的。

    
二、枚举
    定义：列出某些有穷序列的成员的数据结构
        例：大学生管理系统，有姓名、性别、年龄、系别等中表示性别时
        有gender='男';s1="female";ss1="ss1";即数据结构不一致的定义
        造成使用的不便，故用枚举来规范数据结构，大家统一使用方便。
    语法：

  [public] enum 枚举名
          {
            值1；
            值2;
            ...
          }
    public/private 访问修饰符，公开公共的/私有的
    enum 声明枚举的关键字。一般用在namespace与class之间，方便所有类能使用。
        即在命名空间之下。
    enum 是一个变量类型，声明赋值使用有区别。
        声明时成员用逗号隔开，最后一个成员可以不用逗号，一般不用表示成员结束。 
        声明时与int相同，赋值时带成员。   

        public enum Sesons { 春,夏,秋,冬}
        Sesons s = Sesons.秋;
        Console.WriteLine(s);//秋
        Console.WriteLine(Sesons.春);//春
        Console.WriteLine((int)Sesons.春);//0
        Console.WriteLine((int)s);//2
        Console.WriteLine((int)(s + 1));//3
        Console.WriteLine(s + 1);//冬

 enum与string及int的转换
    enum->int
        枚举类型默认可以和int类型互相转换，两者兼容。默认成员从0开始.
        也可人为设置起始点，甚至在中间再设起始点。例：

         public enum QQstate
        {
            OnLine = 2, //2
            OffLine,    //3
            Leave = 5, //5
            busy,    //6
            Qme      //7
        }

 int->enum
        按序号对应输出enum的成员，若无法转换则原样输出。

        public enum Sesons { 春,夏,秋,冬}
        
        int n1 = 2, n2 = 5;
        Sesons a = (Sesons)n1;
        Sesons b = (Sesons)n2;
        Console.WriteLine(a);//秋
        Console.WriteLine(b);//5 不报错  

  enum->string
    所有的类型都可以转换成string,调用ToString()方法。

            int a = 3;
            double b = 4.6;
            decimal c = 22m;
            Sesons s = Sesons.春;
            Console.WriteLine("{0},{1},{2}", a.ToString(), b.ToString(), c.ToString());
            Console.WriteLine("{0},{1}", s, s.ToString());//春,春

 注意：ToString()最后面的()不能省略。
        
    将字符串转为整形的三种方式：
    1.Convert.ToInt32(); 2.int.parse() ;    3.int.Tryparse()
    Convert.ToInt32与int.Parse较为类似，实际上Convert.ToInt32内部调用了int.Parse：
            Convert.ToInt32 参数为null时，返回 0；
            int.Parse       参数为null时，抛出异常。
            
            Convert.ToInt32 参数为""时，抛出异常；
            int.Parse       参数为""时，抛出异常。
            
            Convert.ToInt32 可以转换的类型较多；
            int.Parse       只能转换数字类型的字符串。
            
    int.TryParse与int.Parse 又较为类似，但它不会产生异常，转换成功返回 true，转换失败返回 false。最后一个参数为输出值，如果转换失败，输出值为 0。
        int m; 
        if(int.TryParse("2"),out m)
        {
            ...
        }
        返回true ,运行{}内，并给m赋值为2；

         if(int.TryParse("ddd"),out m)
        {
            ...
        }
        返回false,不运行if{}内，并给m赋值为0；

            int m;
            string a = "3", b = "", c = null, d = "3kk";
            Console.WriteLine(Convert.ToInt32(c));//0
            Console.WriteLine(int.Parse(c));//异常
            Console.WriteLine(Convert.ToInt32(b));//异常
            Console.WriteLine(int.Parse(b));//异常
            Console.WriteLine(Convert.ToInt32(d));//异常
            Console.WriteLine(int.Parse(d));//异常
            if (int.TryParse(a, out m)) Console.WriteLine(m);//3
            if (int.TryParse(b, out m)) Console.WriteLine(m);//为假
            if (int.TryParse(c, out m)) Console.WriteLine(m);//为假
            if (int.TryParse(d, out m)) Console.WriteLine(m);//为假    

  (int) 属cast转换，只能将其它数字类型转换成int类型，它不能转换字符串，比如下例就会失败：
        string v = "1";
        int n = (int)v;    
        
    类似有double.parse(),bool.parse(),Enum.parse()
        
        
    enum->string
    没有Convert.toEnum，因为无法预知自定义的Enum类型。
    Enum.parse()首字母必须大写，这点与int,double等转换有区别。
    例：Enum.parse(typeof(Sesons),s)
        上面typeof(Sesons)表明是取某枚举的类型，利用反射原理。
        s为要转换的字符串。

        string s1 = "春", s2 = "0",s3="ABC";
        Sesons state1 = (Sesons)Enum.Parse(typeof(Sesons), s1);
        Sesons state2 = (Sesons)Enum.Parse(typeof(Sesons), s2);
        Sesons state3 = (Sesons)Enum.Parse(typeof(Sesons), s3);//异常
        Console.WriteLine(state1);//春
        Console.WriteLine(state2);//春  

总结:Enum可向int和string进行转换。
    1.Enum与int兼容，可相互强制转换.当转换到Enum中没有的值时，不会异常，直接显示数字。
     
     2.Enum可与string互相转换。Enum->string 直接调用ToString().
       string->Enum 时,需要：(枚举类型)Enum.parse(typeof(枚举类型),要转的字符串)
       若字符串是数字，即使枚举中无，也不会异常。
       若字符串是字母，如果枚举中无，则抛出异常。

三、结构    
    一次性声明多个不同类型的变量。用结构.
    F12查看定义，例：int后再按F12查看定义有struct 
    1.语法
        [public] struct 结构名
        {
            成员;//字段，不叫变量。不同的结构变量对应不同的值。
        }
    变量仅能存储一人值，字段取决于结构变量的多少。
    
    注意：一般字段开始以_下线线为开始。例如：

    public struct Person
    {
        public string _name;
        public int _age;
        public Gender _gender;
    }
    public enum Gender
    {
        男,
        女
    }

注意：结构体也可以有字段，有属性、有方法、有构造函数，它同类一样也有这些成员。

但是：结构体是值类型，意味着它在栈上分配，哪怕它有方法，一样在栈上根本。而类是引用类型，它在堆上，它更能处理大量的、复杂的关系，因为在大量处理的情况下，类用引用更能快速处理。

结构体适合用于小型的数据结构，而类更适合用于复杂的对象和业务逻辑。在选择使用结构体还是类时，需要根据具体的情况来决定。

另外，注意误区：new表示分配内存，结构体一样可以使用new，但用new并不一定在堆上分配，结构体上用new则表示在栈上分配。

    
四、数组
    一次性存储多个相同的变量，用数组.
    语法:   数组类型[] 数组名=new 数组类型[数组长度];
        int[] nums=new int[10];
        程序进入后，根据声明知道有nums值为null，然后由初始赋值开辟连续
        的int类型存储空间10个，初始值为0.
    null与“”的区别：
        null 还没有开辟空间,无值；
        “”变量已经开辟了空间，有值值为""。
    
    数组中的每一个称为元素，根据索引或下标去访问.索引不能超限，异常.
    元素由0到length-1。即上面10的长度为10,索引为0-9。
    数组一旦固定不能更改索引。
    
    数组中，int/double/decimal初值为0,bool为false,string为null,
    
    数组的4种声明方式：

        int[] n1 = new int[6];//推荐
        int[] n2 = { 0, 1, 2, 3, 4, 5 };//推荐
        int[] n3 = new int[6] { 0, 1, 2, 3, 4, 5 };
        int[] n4 = new int[] { 0, 1, 2, 3, 4, 5 };  

应用：

    int[] n = { 22, 33, 44, 23, 54, 112, 45, 2 };
    int max = n[0], min = n[0];//必须取数组中某一元素值
    //int max = int.MinValue, min = int.MaxValue;//或者取整数对应的上下限值
    int sum = 0;
    for (int i = 0; i < n.Length; i++)
    {
        if (n[i] > max)
        {
            max = n[i];
        }
        if (n[i] < min)
        {
            min = n[i];
        }
        sum += n[i];
    }  

 
    
    倒序数组：

    string[] names = { "我", "是", "好", "人" };
    string temp = "";
    for (int i = 0; i < names.Length / 2; i++)
    {
        temp = names[i];
        names[i] = names[names.Length - 1 - i];
        names[names.Length - 1 - i] = temp;
    }   

 
    
    冒泡排序：

    int[] n = { 9, 7, 6, 2, 8, 5, 4, 0, 1, 3 };
    int temp;
    for (int i = 0; i < n.Length - 1; i++)
    {
        for (int j = i + 1; j < n.Length; j++)
        {
            if (n[i] > n[j])
            {
                temp = n[i];//最小在前
                n[i] = n[j];
                n[j] = temp;
            }
        }
    }

    
    不用冒泡法，直接用Array:

    Array.Sort(n);//从小到大排列，升序
    Array.Reverse(n);//对当前数组反转，即将上面变成从大到小。

    
五、方法
    方法(函数),参数,返回值。代码重用的一种机制。
    语法：
    [public] static 返回值类型 方法名([参数列表])    
    {
        方法体;
    }
    public公共的，static静态的.
    static修饰类,属性,方法。使用static后不需要创建实例对象就可以直接通过类名点使用。
    三种用法：
    1.用在变量前。表示该变量在类、方法等中，变量一直为最后一次修改的值。
    2.用在方法时。表示为类所拥有，而不是所有实例所有（静态方法）。
        故不用实例即可使用，通过类名引用：类名.静态方法;
    3.用于类前.说明该类无法创建实例，类中全是静态方法，类中非静态方法是不能使用的。
        此类又称为静态类。