C#基础入门第六天（复杂数据类型）

时间 2021-01-20

标签 c# 数组 ide 函数 spa code 排序索引游戏栏目 C# 繁體版

原文原文链接

总复习
1、变量类型
int double string char bool decimal float
变量的使用规则：先声明再赋值最后使用
int number;
number=10;
number=20;
Console.WriteLine(number);
命名规范：Camel Pascalc#

2、运算符
赋值运算符：=
复合赋值运算符：+= -= = /= %= sum+=age; sum=sum+age;
算数运算符： + - / % ++ --
关系运算符： > < >= <= == !=
逻辑运算符： && || !数组

3、c#中的语法结构
分支结构：
if if-else
选择结构：
while do-while foride

第六天新内容
1、常量(不可被重复赋值)
声明的常量的语法：
const 变量类型变量名=值;
何时会用到常量？
如：收银项目，折扣是不但愿被别人改变的，因此这样的须要用经常使用函数

2、枚举
语法：
[public] enum 枚举名
{
值1,
值2,
值3,
........
}
public:访问修饰符。公开的公共的，哪均可以访问。
enum：关键字，声明枚举的关键字
枚举名：要符合Pascal命名规范spa

将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，全部的类均可以使用这个枚举。code

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

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

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

重点：全部的类型都可以转换成string类型，调用ToString()。ci

namespace _03枚举类型和string以及int类型之间的转换
 {
public enum QQState
{
    OnLine,
    OFFline,
    Leave=9,
    Busy,
    QMe
}
class Program
{
    static void Main(string[] args)
    {
        #region 将枚举类型强转成int类型
        QQState state = QQState.OnLine;
        //枚举类型默承认以跟int类型相互转换，枚举类型跟Int类型是兼容的
        int n = (int)state;
        Console.WriteLine(0);
        Console.WriteLine((int)QQState.Leave);
        Console.ReadKey();
        #endregion

        #region 将int类型强转成枚举类型
        int n1 = 1;
        QQState state = (QQState)n1;
        Console.WriteLine(state);
        Console.ReadKey();
        #endregion

        #region 枚举转换string类型
        QQState state = QQState.OnLine;
        string s = state.ToString();
        Console.WriteLine(s);
        Console.ReadKey();
        #endregion

        #region 将字符串转换为枚举类型
        string s = "OnLine";
        //将s转换成枚举类型
        //convert   parse   Tryparse
        //调用parse方法的目的：就是让他帮助咱们将一个字符串转换成对应的枚举类型
        //拿到这个枚举的类型  参数
        QQState state = (QQState)Enum.Parse(typeof(QQState), s);
        Console.WriteLine(state);
        Console.ReadKey();
        #endregion
    }
}

}

枚举的转换的联系：//提示用户选择一个在线状态，咱们接受并将用户的输入转换成枚举类型，再次打印到控制台
先声明一个枚举出来：
public enum QQZhuangTai
{
在线=1,
离线,
忙碌,
隐身
}

Console.WriteLine("请选择你的QQ在线状态 1--在线 2--离线 3--忙碌 4--隐身");
        string input = Console.ReadLine();
        switch (input)
        {
            case "1":QQZhuangTai s1 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在线状态是{0}", s1);
                break;
            case "2":QQZhuangTai s2 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在线状态是{0}", s2);
                break;
            case "3":QQZhuangTai s3 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在线状态是{0}", s3);
                break;
            case "4":QQZhuangTai s4 = (QQZhuangTai)Enum.Parse(typeof(QQZhuangTai), input);
                Console.WriteLine("你的在线状态是{0}", s4);
                break;
        }
        Console.ReadKey();

3、结构
能够帮助咱们一次性声明多个不一样类型的变量。
语法：
[public] struct 结构名
{
成员;//字段
}
变量在程序运行期间只能存储一个值，而字段能够存储多个值。

namespace _04结构
     {
public struct Person
    {
    //字段命名前面都加一个下划线，这是规范
    public string _name;
    public int _age;
    public gender _gender;
}
public enum gender
{
    男,
    女
}
class Program
{
    static void Main(string[] args)
    {
        Person zsPerson;
        zsPerson._name = "张三";
        zsPerson._age = 21;
        zsPerson._gender = gender.女;

        Person lsPerson;
        lsPerson._name = "李四";
        lsPerson._age = 22;
        lsPerson._gender = gender.男;

        Console.WriteLine("学生信息：姓名{0},年龄{1},性别{2}", zsPerson._name, zsPerson._age, zsPerson._gender);
        Console.WriteLine("学生信息：姓名{0},年龄{1},性别{2}", lsPerson._name, lsPerson._age, lsPerson._gender);
        Console.ReadKey();
    }
}

}

namespace _05结构练习
 {
public struct MyColor
{
    public int _red;
    public int _green;
    public int _blue;
}
class Program
{
    static void Main(string[] args)
    {
        //一、定义一个结构叫MyColor,有三个成员，分别定义为int类型的red,green,blue
        //声明一个MyColor类型的变量，并对其成员赋值，使MyColor能够表示称为红色
        MyColor color;
        color._red = 255;
        color._green = 0;
        color._blue = 0;
    }
}
   }

4、数组
一次性存储多个相同类型的变量。
语法：
数组类型[] 数组名=new 数组类型[数组长度];
访问数组的某一个元素，须要经过这个元素的下标或者索引去访问，数组索引默认从0开始
***数组的长度一旦固定了，就不能再被改变了

//声明数组
        int[] nums = new int[10];
        //数组元素赋值
        nums[6] = 10;
        //经过一个循环给数组赋值，一样也经过一个循环对数组进行取值
        for (int i = 0; i < nums.Length; i++)
        {
            nums[i] = i + 1;
        }
        for (int i = 0; i < nums.Length; i++)
        {
            Console.WriteLine(nums[i]);
        }
        Console.ReadKey();

                    //数组声明并赋值的写法
        int[] nums2 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 90 };

数组的五个练习

static void Main(string[] args)
    {
        //练习1.从一个整数数组中取出最大的整数，最小的整数，总和，平均值
        //声明一个int类型的数组，而且随意赋值
        int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        //声明两个边路用来存储最大值和最小值
        int max = nums[0];
        int min = nums[0];
        int sum = 0;
        //循环的让数组中的每一个元素跟个人最大值，最小值进行比较
        for (int i = 0; i < nums.Length; i++)
        {
            //关于在循环中nums[i]的理解方式
            //1.表明数组中当前循环的元素
            //2.表明数组中的每一个元素
            //若是素组中当前循环到这个元素，比个人max大，就把当前元素赋值给最大值
            if (nums[i] > max)
            {
                max = nums[i];
            }
            if (nums[i] < min)
            {
                min = nums[i];
            }
            sum += nums[i];
        }
        Console.Write("这个数组的最大值是{0},最小值是{1},总和是{2},平均值是{3}", max, min, sum, sum / nums.Length);
        Console.ReadKey();

        //2.计算一个整数忰的全部元素的和
        int[] numsOne = { 10, 20, 30, 40, 50, 60 };
        int sum = 0;
        for (int i = 0; i < numsOne.Length; i++)
        {
            sum += numsOne[i];
        }
        Console.WriteLine(sum);
        Console.ReadKey();

        //3.数组里面都是人的名字，分割成例如：老杨|老苏|老周.....
        string[] names = { "张三", "李四", "王五", "赵六", "二麻子", "狗子" };
        string name = null;
        for (int i = 0; i < names.Length - 1; i++)
        {
            name += names[i] + "|";
        }
        Console.Write(name + names[names.Length - 1]);
        Console.ReadKey();

        //4.将一个整数数组的每个元素进行以下的处理：若是元素是正数则将这个位置的元素的值加1.
        //若是元素是负数则将这个位置的元素的值减1，若是元素是0，则不变
        int[] numsTow = { -2, -4, -6, 0, 1, 3, 5 };
        for (int i = 0; i < numsTow.Length; i++)
        {
            if (numsTow[i] < 0)
            {
                numsTow[i] -= 1;
            }
            else if (numsTow[i] > 0)
            {
                numsTow[i] += 1;
            }
        }
        for (int i = 0; i < numsTow.Length; i++)
        {
            Console.WriteLine(numsTow[i]);
        }
        Console.ReadKey();

        //5.将一个字符串数组的元素的顺序进行反转。{"我"，"是"，"好人"}
        //{ "好人"，"是"，"我"}，第i个和第length-i-1个进行交换
        string[] strs = { "我", "是", "好人" };
        string temp = null;
        for (int i = 0; i < strs.Length/2; i++)
        {
            temp = strs[i];
            strs[i] = strs[strs.Length - 1 - i];
            strs[strs.Length - 1 - i] = temp;
        }
        for (int i = 0; i < strs.Length; i++)
        {
            Console.Write(strs[i]);
        }
        Console.ReadKey();
    }

5、冒泡排序
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, 7, 5, 8, 0 };
            //对数组进行升序排列
        Array.Sort(nums);

        //对数组进行反转
        Array.Reverse(nums);

        //for (int i = 0; i < nums.Length-1; i++)
        //{
        //    for (int j = 0; j < nums.Length-1-i; j++)
        //    {
        //        if (nums[j] > nums[j + 1])
        //        {
        //            int temp = nums[j];
        //            nums[j] = nums[j + 1];
        //            nums[j + 1] = temp;
        //        }
        //    }
        //}
        for (int i = 0; i < nums.Length; i++)
        {
            Console.Write(nums[i]);
        }
        Console.ReadKey();

6、方法（函数）
函数就是将一堆代码进行重用的一种机制。
函数的语法：
[public] static 返回值类型方法名([参数列表])
{
方法体；
}
public:访问修饰符，公开的，公共的，哪均可以访问。
static：静态的
返回值类型：若是不须要写返回值，写void
方法名：Pascal 每一个单词的首字母都大些。其他字母小写
参数列表：完成这个方法所必需要提供给这个方法的条件。若是没有参数，小括号也不能省略。

方法写好后，若是想要被执行，必需要在Main()函数中调用。
方法的调用语法：
类名.方法名([参数]);
***在某些状况下，类名是能够省略的，若是你写的方法跟Main()函数同在一个类中，这个时候，
类名能够省略。

class Program
{
    static void Main(string[] args)
    {
        //int max = Program.GetMax(1, 2);
        //Console.WriteLine(max);
        //Console.ReadKey();

        Program.PlayGame();
        Program.PlayGame();
        Program.PlayWuDi();
        Program.PlayGame();
        Console.ReadKey();
    }

    #region 比较两个整数之间最大值并返回最大值的方法
    /// <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;
    }
    #endregion

    #region 模拟玩游戏过程的方法
    /// <summary>
    /// 正常完游戏的过程
    /// </summary>
    public static void PlayGame()
    {
        Console.WriteLine("采蘑菇，走啊走，跳啊跳！");
        Console.WriteLine("采蘑菇，走啊走，跳啊跳！");
        Console.WriteLine("采蘑菇，走啊走，跳啊跳！");
        Console.WriteLine("顶到无敌了！");
    }
    /// <summary>
    /// 顶到无敌后游戏的变化
    /// </summary>
    public static void PlayWuDi()
    {
        Console.WriteLine("被怪打不掉血！");
        Console.WriteLine("秒怪！");
    }
    #endregion
}

}

关键字：return一、在方法中返回要返回的值。二、当即结束本次方法。