C#复杂数据类型

——枚举

语法：
[public] enum 枚举名
{
    值1,
    值2,
    值3,
    ........
}

public:访问修饰符。公开的公共的，哪都可以访问。
enum：关键字，声明枚举的关键字
枚举名：要符合Pascal命名规范

一般将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用这个枚举。

枚举就是一个变量类型 ，只是枚举声明、赋值、使用的方式跟那些普通的变量类型不一样。

我们可以将一个枚举类型的变量跟int类型和string类型互相转换。
枚举类型默认是跟int类型相互兼容的，所以可以通过强制类型转换的语法互相转换。
当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来。

枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用ToString().
如果将字符串转换成枚举类型则需要下面这样一行代码：
(要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),”要转换的字符串”);
如果转换的字符串是数字，则就算枚举中没有，也会不会抛异常。
如果转换的字符串是文本，如果枚举中没有，则会抛出异常。

//演示一下枚举类型和int类型之间的转换
//枚举类型的每个值都有一个对应的递增的索引，可以通过赋int值来改变索引，枚举值转换成int类型得出的也是索引
public enum QQState
    {
        OnLine=1,
        OffLine,
        Leave,
        Busy,
        QMe
    }
 //取出一个枚举类型的值，转换成int
 QQState state = QQState.OnLine//枚举取值只能去枚举中的值
 int n= (int) state;//结果为1
 Console.WriteLine((int)QQState.OffLine);//2
Console.WriteLine((int)QQState.Leave);//3
Console.WriteLine((int)QQState.Busy);//4
Console.WriteLine((int)QQState.QMe);//5

 //将int类型转换成枚举类型，还是使用上面定义的那个枚举
int n1 = 3;
QQState state = (QQState)n1;
Console.WriteLine(state); //输出该枚举类型的 Leave

//将枚举类型转换成string类型
QQState state = QQState.OnLine;
string s = state.ToString();
Console.WriteLine(s);//输出OnLine，但是这个OnLine的数据类型为string

//将string转换成枚举类型
//有个前提，string字符串需要时枚举类型中有的才可以转换，否则会抛异常
string s = "ABCDEFG";
QQState state = (QQState)Enum.Parse(typeof(QQState), s);
Console.WriteLine(state);
//上面这个之心那个就会抛异常，因为QQState枚举中没有ABCDEFG

来一个字符串成功转换成枚举的例子

string s="1";
QQState enums = (QQState)Enum.Parse(typeof(QQState),s);
Console.WriteLine(enums);//输出OnLine

最后注意一点，枚举类型的值只能通过 枚举名.值 来取

——结构
可以帮助我们一次性声明多个不同类型的变量。

语法：
[public] struct 结构名
{
    成员;//字段
}

结构一般定义在命名空间层下，调用时需要实例化
变量在程序运行期间只能存储一个值，而字段可以存储多个值。

//定义一个结构
public struct Person
    {
        public string _name;
        public int _age;
        public Gender _gender;//值类型为枚举
    }
public enum Gender
    { 
        男,
        女
    }

//对以上结构实例并初始化
Person zsPerson;
zsPerson._name = "张三";
zsPerson._age = 21;
zsPerson._gender = Gender.男;

Person lsPerson;
lsPerson._name = "李四";
lsPerson._age = 22;
lsPerson._gender = Gender.女;

其实会发现结构和类很相似，本来他们也很相似，后面再说他们的相似之处有多大

——数组
一次性存储多个相同类型的变量。
语法：
数组类型[] 数组名=new 数组类型[数组长度];

注意：数组的长度一旦固定了，就不能再被改变了

//数组的四种声明方式
int[] nums = new int[10];//声明一个长度为10 的数组
int[] nums = {1,2,3,4,5,6,7};//声明并赋值，长度自动计算
int[] nums = new int[]{1,2,3,4,5}//声明并赋值，这中形式常用于参数
int[] nums = new int[5]{1,2,3,4,5}//声明长度并赋值，长度必须和赋值数相等，一般别用这样的方式

//数组常用方法
Array.Reverse(nums);//对数组进行反转
Array.Sort(nums);//对数组元素进行升序排列，前提元素是数字

数组经典案例，冒泡排序，下面看看冒泡排序的理，每一次拿第一个数和后面的比较
int[] nums={9,8,7,6,5,4,3,2,1,0}; 0 1 2 3 4 5 6 7 8 9
第一趟比较：8 7 6 5 4 3 2 1 0 9 交换了9次 i=0 j=nums.Length-1-i
第二趟比较：7 6 5 4 3 2 1 0 8 9 交换了8次 i=1 j=nums.Length-1-i
第三趟比较：6 5 4 3 2 1 0 7 8 9 交换了7次 i=2 j=nums.Length-1-i
第四趟比较：5 4 3 2 1 0 6 7 8 9 交换了6次 i=3 j=nums.Length-1-i
第五趟比较：4 3 2 1 0 5 6 7 8 9 交换了5次
第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了4次
第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了3次
第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了2次
第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了1次

int[] nums = { 1, 4, 3, 9, 6, 8, 11 };
 for (int i = 0; i < nums.Length; i++)
            {
                for (int j = 0; j < nums.Length-1-i; j++)
                {
                    if (nums[j] > nums[j + 1]) {
                        nums[j] += nums[j + 1];
                        nums[j + 1] = nums[j] - nums[j + 1];
                        nums[j] -= nums[j + 1];
                    }
                }
            }
//这里看一下内层循环算法，其实就是交换两个数的位置
/*
  比如:a=10;b=9;
  a+=b;  则a==19;
  b=a-b; b=19-9==10;
  a-=b;  a=19-10==9;
  这样就交换了两个数的位置，实在不行就定义第三方变量
*/

——函数
函数就是将一堆代码进行重用的一种机制。

函数的语法：
[public] [static] 返回值类型 方法名([参数列表])
{
    方法体；
}

public:访问修饰符，公开的，公共的，哪都可以访问。
static：静态的

返回值类型：如果不需要写返回值，写void
方法名：Pascal 每个单词的首字母都大些。其余字母小写
参数列表：完成这个方法所必须要提供给这个方法的条件。如果没有参数，小括号也不能省略。

方法写好后，如果想要被执行，必须要在Main()函数中调用。

方法的调用语法：
类名/对象名.方法名([参数]);
在某些情况下，类名是可以省略的，如果你写的方法跟Main()函数同在一个类中，这个时候，类名可以省略。

return
//1、在方法中返回要返回的值。
//2、立即结束本次方法

//定义一个方法，找出传入int数据的最大值，参数可以任意多个
//由于参数可以任意多个，所以需要使用params
public static int GetMax(params int[] nums) {
            int max = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] > max)
                    max = nums[i];
            }
            return max;
        }