C#---复杂数据类型

一、常量

声明的常量的语法:
const 变量类型  变量名=值;

  const int number = 20; //常量不能够被重新赋值

二、枚举

语法:
[public]  enum 枚举名{
值1,
值2,

值3,
.....}

public: 访问修饰符。公开的公共的,哪都可以访问。

enum: 关键字,声明枚举的关键字
枚举名: 要符合Pascal命名规范

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

枚举就是一个变量类型, int--double string  decimal.
只是枚举声明、赋值、使用的方式跟那些普通的变量类型不一样。

class Program
    {
        public enum Gender
        {
            男,
            女
        }
        static void Main(string[] args)
        {
            // 变量类型 变量名==值
            Gender gender = Gender.女;

            //为什么会有枚举这个东东 ?
            //xx大学管理系统
            //姓名 性别 年龄 系别 年级 
            // 性别
            //char gender = '男';
            //string s1 = "famale";
            //string s2 = "酷酷的";
            Console.ReadKey();
        }
    }

三、枚举和int以及string类型之间的转换

我们可以将一个枚举类型的变量跟int类型和string类型互相转换。
枚举类型默认是跟int类型相互兼容的，所以可以通过强制类型转换的语法互相转换。当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来。
  枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用rostring () .如果将字符串转换成枚举类型则需要下面这样一行代码:
  (要转换的枚举类型) Enum.Parse(typeof(要转换的枚举类型),"要转换的字符串");

 如果转换的字符串是数字，则就算枚举中没有，也会不会抛异常。如果转换的字符串是文本，如果枚举中没有，则会抛出异常。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp3
{
    class Program
    {
        public enum QQState
        {
            Online=1,
            OffLine,
            Leave,
            Busy,
            QMe
        }
        public enum gender
        {
            男,
            女
         }
        static void Main(string[] args)
        {
            #region 将枚举类型强转成int类型
            变量类型 变量名==值
            //QQState state = QQState.Busy;
            枚举类型默认可以跟int类型互相转换，枚举类型跟int类型是兼容的
            //int i = (int)state;
            //Console.WriteLine(i);
            //Console.WriteLine((int)QQState.OffLine);
            //Console.WriteLine((int)QQState.Leave);
            //Console.WriteLine((int)QQState.QMe);
            #endregion

            #region 将int类型强转为枚举类型
            //int n1 = 3;
            //QQState s = (QQState)n1;
            //Console.WriteLine(s);
            #endregion
            #region 将枚举类型转换成字符串类型
            //所有的类型都能够转换成string类型
            //int hh = 11;
            //double hh = 25.36;
            //Decimal hh = 5630m;
            //String h2= hh.ToString();
            //Console.WriteLine(h2);
            //QQState w = QQState.Busy;
            //String sss = w.ToString();
            //Console.WriteLine(sss);
            #endregion

            #region 将字符串类型转换为枚举类型
            String s = "0";
            //将s转换成枚举类型
            //Convert.ToInt30()  int.parse() int TryParse()
            //调用Parse()方法的目的就是为了让它帮助我们将一个字符串转换成对应的枚举类型
            //QQState oo= (QQState)Enum.Parse(typeof(QQState),s);
            //Console.WriteLine(oo);
            #endregion

            //枚举练习
            //提示用户选择一个在线状态，我们接受，并将用户的输入转换成枚举类型。再次打印到控制台中
            Console.WriteLine("请选择你的qq在线状态 1-- Online,2--OffLine,3---Leave,4--Busy,5---QMe");
            String input=Console.ReadLine();
            switch (input)
            {
                case "1":
                    QQState q1 = (QQState)Enum.Parse(typeof(QQState), input);
                    Console.WriteLine("你选择的状态为{0}", q1);
                    break;
                case "2":
                    QQState q2 = (QQState)Enum.Parse(typeof(QQState), input);
                    Console.WriteLine("你选择的状态为{0}", q2);
                    break;
                case "3":
                    QQState q3 = (QQState)Enum.Parse(typeof(QQState), input);
                    Console.WriteLine("你选择的状态为{0}", q3);
                    break;
                case "4":
                    QQState q4 = (QQState)Enum.Parse(typeof(QQState), input);
                    Console.WriteLine("你选择的状态为{0}", q4);
                    break;
                case "5":
                    QQState q5 = (QQState)Enum.Parse(typeof(QQState), input);
                    Console.WriteLine("你选择的状态为{0}", q5);
                    break;
            }
            Console.ReadKey();
        }
    }
}
四、结构

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

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

}

变量在程序运行期间只能存储一个值，而字段可以存储多个值。

namespace ConsoleApp3
{
    class Program
    {
        public struct Person
        {
           public String _name;//字段
           public int _age;
           public Gender _gender;
        }
        public enum Gender
        {
            男,
            女
         }
        static void Main(string[] args)
        {
            Person zsPerson;
            zsPerson._age = 12;
            zsPerson._name = "张三";
            zsPerson._gender = Gender.女;

            Person lsPerson;
            lsPerson._age = 18;
            lsPerson._name = "李四 ";
            lsPerson._gender = Gender.男;
            Console.WriteLine(lsPerson._name);
            Console.WriteLine(zsPerson._name);
            Console.ReadKey();
        }
    }
}
五、数组
一次性存储多个相同类型的变量。

语法:
数组类型 []  数组名 = new 致组类型[数组长度];

//数组类型 []  数组名 = new 致组类型[数组长度];
            int[] nums = new int[10];
            //数组的声明方式
            int[] numsss = { 1, 2, 3, 4, 5 };
            int[] nusmsm = new int[3]{ 1,2,3 };
            int[] numsfor = new int[] { 1,2 ,4 ,6};

            string[] dds = new string[8];
            bool[] hhs = new bool[9];
            Console.ReadKey();

练习题

//练习1:从一个整数数组中取出最大的整数,最小整数,总和,平均值
            //声明一个int类型的数组并且随意的赋初值
            int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 25 };
            int max = nums[1];
            int min = nums[0];
            int sum = 0;
            for (int i = 0; i <nums.Length; i++)
            {
                if (nums[i] > max)
                {
                    max = nums[i];
                }
                if (nums[i] < min)
                {
                    min = nums[i];
                }
                sum += nums[i];
            }
            Console.WriteLine("这个数组的最大值{0}，最小值{1}，和为{2},平均值为{3}",max,min,sum,sum/nums.Length);
            Console.ReadKey();

 //练习2:数组里面都是人的名字,分割成:例如:小杨|小苏|小邹..”
            string[] names = { "小杨", "小苏", "小邹", "小话", "小至"};
            // 解体思路:通过一个循环，获得字符串数组中的每一个元素。
            // 然后，将这个每一个元素都累加到一个字符串中，以 | 分割
            string str = null;
            for (int i = 0; i < names.Length-1; i++)
            {
                str += names[i] + "|";
            }
            Console.WriteLine(str+names[names.Length-1]);
            Console.ReadKey();

 //练习4:将一个整数数组的每一个元素进行如下的处理:
            //如果元素是正数则将这个位置的元素的值加1，
            // 如果元素是负数则将这个位置的元素的值减1,如果元素是0,则不变。
            int[] numbers = { 1, -5, -4, -9, 78, 7, 0 };
            //解题思路:通过一个循环，获得数组中的每一个元素。
            //对每一个元素进行判断
            for (int i = 0; i < numbers.Length; i++)
            {
                if (numbers[i] > 0)
                {
                    numbers[i] += 1;
                }else if (numbers[i] < 0)
                {
                    numbers[i] -= 1;
                }
                else
                {
                }
            }
            //打印
            for (int j = 0; j < numbers.Length; j++)
            {
                Console.WriteLine(numbers[j]);
            }

 //练习5∶将一个字符串数组的元素的顺序进行反转。{“我”,"是”,”好人”"} {“好人”,”是”,”我“}
            string[] names = { "我的", "狗狗", "小" };
            for (int i = 0; i < names.Length/2; i++)
            {
                string temp = names[i];
                names[i]=names[names.Length - 1-i];
                names[names.Length - 1-i] = temp; 
            }
            for (int j = 0; j < names.Length; j++)
            {
                Console.WriteLine(names[j]);
            }
            Console.ReadKey();

冒泡排序:就是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。

//练习6∶冒泡排序
            int[] numbers = { 1, 45, 36, 17, 55, 66, 77, 12 };

            //Array.Sort(numbers);
            // Array.Reverse(numbers);
            for (int i = 0; i < numbers.Length-1; i++)
            {
                for (int j = 0; j < numbers.Length-1-i; j++)
                {
                    if (numbers[j] > numbers[j + 1])
                    {
                        int temp = numbers[j];
                        numbers[j] = numbers[j + 1];
                        numbers[j + 1] = temp;

                    }
                }
            }
            //打印---排序后的数组
            for (int i = 0; i < numbers.Length; i++)
            {
                Console.WriteLine(numbers[i]);
            }
            Console.ReadKey();

11、方法
函数就是将一堆代码进行重用的一种机制。

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

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

static:  静态的
返回值类型:  如果不需要写返回值,写void
方法名: Pascal每个单词的首字母都大些。其余字母小写

参数列表:  完成这个方法所必须要提供给这个方法的条件。如果没有参数，小括号也不能省略

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

方法的调用语法:
类名.方法名([参数]);

***在某些情况下，类名是可以省略的，如果你写的方法跟Main ()函数同在一个类中，这个时候，类名可以省略。

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

   //计算两个整数之间的最大值
            int number = Program.GetMax(12, 36);
            Console.WriteLine(number);
            Console.ReadKey();
        }
        /// <summary>
        /// 计算两个整数之间的最大值
        /// </summary>
        /// <param name="n1">第一个整数</param>
        /// <param name="n2">第二个整数</param>
        /// <returns>将最大值返回</returns>
        public static int GetMax(int n1,int n2)
        {
            return n1 > n2 ? n1 : n2;
        }