数组、流程控制语句

数组

1. 一维数组和二维数组的定义的三种方式
2. 迭代器的遍历 foreach

 //数组
            //将相同的数据类型的数据形成一个有序的集合称为数组
            //1、数组是一段连续的内存空间
            //2、数组的长度在声明时就必须给定，且长度不可变


            //第一种定义
            int[] arr1 = { 1, 2, 3, 4, 5, 6 };


            //第二种定义,没有给定数组中元素值，会默认值填充
            int[] arr2 = new int[5];


            //第三种: 给定的数组长度必须和集合中的元素完全一致
            int[] arr3 = new int[5] { 1, 2, 3, 4, 5 };


            //二维数组
            //第一种定义方式
            int[,] arr4 = { 
                { 1, 2, 3, 4 }, 
                { 7, 8, 9, 10 }
            };

            //第二种定义方式
            int[,] arr5 = new int[2, 3];


            //第三种定义方式
            int[,] arr6 = new int[3, 3] { { 1,2,3 },{ 1,2,3 },{ 1,2,3 } };


            //获取二维数组的长度
            Console.WriteLine(arr1.GetLength(1));


            //迭代器：foreach
            //1、无论要便利容器是否是线性容器，都可以将容器中的元素全部遍历一遍
            //2、迭代器在遍历的过程中不能跳过某些元素不遍历
            //3、迭代器可以不从头开始遍历
            //4、迭代器可以使用关键字跳出迭代过程

            //如果要使用foreach，则必须要继承IEnumerable<T>或IEnumerable
            foreach (var item in arr4)
            {
                if(item == 1)
                {
                    continue;
                }
                Console.WriteLine(item);
            };


//交错数组
//一个一维数组的数组
int[][] numbers = new int[2][] {new int[] {1,2,3,4}, new int[] {5,6}};

流程控制语句

1. & 和 &&的 区别
2. switch的特殊地方

 //在c#中，位运算符的&和|既可以做位运算符又可以做逻辑运算符
            //但是逻辑运算只能做逻辑判断，不能当做算术运算符使用


            //在使用任何一个变量时，必须确保它在任意一个分之中都有给定具体的值、


            //switch
            //在c#中，当case中存在任何一句执行语句时，不可省略掉break（不能击穿）
            //但是，当case中不存在执行语句时，可以不写break;
            int day = 1;
            switch (day)
            {
                case 1:
                    Console.WriteLine("吃饭");
                    break;
                case 2:
                    Console.WriteLine("吃饭");
                    break;
            }

数值的传递

1. 值传递和引用传递的区别
2. 堆和栈的区别
3. ref 和 out 关键字

            //值传递：将数值单独传递进去
            //引用传递：传递的是地址
            //值类型：字节大小确定，且一般都不大
            //引用类型：可能比较大

            //栈: 空间小运算速度快 值类型
            //堆：空间大运算速度慢 引用类型
//14、堆和栈的区别？

//栈是编译期间就分配好的内存空间，因此你的代码中必须就栈的大小有明确的定义；局部值类型变量、值类型参数等都在栈内存中。

//堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小。

            int a = 1;
            int b = 3;
            Change(ref a, ref b);


            string str = "96";
            int res;
            Console.WriteLine(int.TryParse(str,out res)); 
            Console.WriteLine(res);


 //ref:reference 引用，将值传递变为引用传递
 //1、如果要使用ref关键字，除了定义函数时需要写出ref关键字外，在参数传递时也要显式的写出ref关键字
 //2、ref关键字修饰的参数，在实参传入前必须要赋值

 //out关键字：让函数有多个返回值的做法
 //1、如果要使用out关键字，除了定义函数时需要写出out关键字外，在参数传递时也要显式的写出out关键字
 //2、out关键字修饰的参数，在实参传入之前可以不赋值，但函数返回前必须对该参数赋值

函数

1. 函数的格式
2. 函数的重载
3. 默认参数
4. params

//返回值类型，函数名（参数列表）｛方法体｝
        //void,只在函数的返回值中使用的一种数据类型，用于表示无返回值的情况
        //如果想要让它写的函数能被主函数调用，必须加上static
        //1.函数在定义时必须明确写出所需的返回值类型和参数列表
        //2.函数在调用时，如果有参数，则必须传入给定数量及类型的参数


        /// <summary>
        /// 求两个参数的和并返回
        /// </summary>
        /// <param name="a">第一个操作数</param>
        /// <param name="b">第二个操作数</param>
        /// <returns>两个操作数的和</returns>
        static int Sum(int a, int b)
        {
            return a+b;
        }


        //函数的重载：函数的返回值和函数名一样，但是参数列表不同
        //函数的签名：函数的返回值和参数列表统称为函数签名
        //参数类型不同，参数个数不同
        static float Sum(float a, int b)
        {
            return a + b;
        }

        static float Sum(int a, float b)
        {
            return a + b;
        }



        //默认参数在具体使用的时候可以不给实参，会使用这个参数的默认值
        //如果给定的了具体的实参，将会使用给出的实参值
        //默认参数在声明函数时一定要放在所有非默认参数的后面
        //static void Test(int num1 = 1, int num2)
        //{
        //    Console.WriteLine(num2);
        //}

       
        //params: 实现一个不定长度的参数列表
        //params必须放在形参列表的最后
        static void Print(params int[] nums)
        {

        }

随机数

//随机数
//系统随机数是根据系统时间通过固定的公式计算出一串数字，然后从头开始选取随机种子
//抽奖系统
Random random = new Random();
random.Next(0, 5);

设置光标的位置

 Console.SetCursorPosition(int left, int top);
 //光标在写一个数据后，会自动向前移动一格