C#学习-Day7

程序调试

1. 写完一段程序后，想看一下这段程序的执行过程
2. 当你写完这段程序后，发现程序并没有按照你想象的样子去执行

调试方法

1. F11逐语句调试
2. F10逐过程调试
3. 断点调试

for循环

语法：

for(表达式1；表达式2；表达式3)

{

循环体；

}

表达式1一般为声明循环变量，记录循环的次数(int i=0;)

表达式2一般为循环条件(i<10)

表达式3一般为改变循环条件的代码，使循环条件终有一天不再成立(i++)

执行过程：程序先执行表达式1，声明了一个循环变量用来记录循环的次数，然后执行表达式2，判断循环条件是否成立，如果表达式2返回的结果为true，则执行循环体，当执行完循环体后，执行表达式3，然后执行表达式2继续判断循环条件是否成立，如果成立则继续执行循环体，如果不成立，则跳出for循环。

            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine(i);
            }
            for (int i = 10 ; i >=1; i--)
            {
                Console.WriteLine(i);
            }
            Console.ReadKey();

            for (int i = 100; i <= 999; i++)
            {
                int bai = i / 100;
                int shi = i % 100 / 10;
                int ge = i % 10;
                if (bai * bai * bai + shi * shi * shi + ge * ge * ge == i)
                {
                    Console.WriteLine("水仙花数有{0}", i);
                }
            }
            Console.ReadKey();

            int count = 1;
            for (int i = 0; i < 10; i++)
            {               
                for (int j = 0; j < 10; j++)
                {
                    Console.WriteLine("Hello Word {0}",count);
                    count++;
                }
            }
            Console.ReadKey();

            for (int i = 1 ; i <=9; i++)
            {
                for (int j = 1; j <= 9; j++)
                {
                    Console.Write("{0}*{1}={2}\t", i, j, i*j);
                }
                Console.WriteLine();
            }
            Console.ReadKey();

            for (int i = 1; i <= 9; i++)
            {
                for (int j = 1; j <= i; j++)
                {
                    Console.Write("{0}*{1}={2}\t", i, j, i * j);
                }
                Console.WriteLine();
            }
            Console.ReadKey();

            Console.WriteLine("请输入一个数");
            try
            {
                int input = Convert.ToInt32(Console.ReadLine());
                for (int i = 0; i <= input; i++)
                {
                    Console.WriteLine("{0}+{1}={2}", i, input - i, input);
                }
            }
            catch
            {
                Console.WriteLine("输入格式错误，程序终止");
            }
            Console.ReadKey();

int.TryParse

            int number = 10;
            bool b = int.TryParse("123abc", out number);
            Console.WriteLine(b);  
            Console.WriteLine(number);
            Console.ReadKey();

continue

立即结束本次循环，判断循环条件，如果成立，则进入下一次循环，否则退出循环

            int sum = 0;
            int i = 1;
            while (i <= 100)
            {
                if (i % 7 == 0)
                {
                    i++;
                    continue;
                }
                sum += i;
                i++;
            }
            Console.WriteLine(sum);
            Console.ReadKey();

            for (int i =2; i <= 100; i++)
            {
                bool b = true;
                for (int j = 2; j < i; j++)
                {                
                    if (i % j ==0)
                    {
                        b = false;
                        continue;
                    }
                }
                if (b)
                {
                    Console.WriteLine("{0}是质数", i);
                }
            }
            Console.ReadKey();

三元表达式

语法:

表达式1?表达式2:表达式3;

表达式1一般为一个关系表达式。

如果表达式1的值为true，那么表达式2的值就是整个三元表达式的值。

如果表达式1的值为false，那么表达式2的值就是整个三元表达式的值。

注意:表达式2的结果类型必须跟表达式3的结果类型一致，并且也要跟整个三元表达式的结果类型一致。

            Console.WriteLine("请输入一个数字");
            int first = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("请输入第二个数字");
            int second = Convert.ToInt32 (Console.ReadLine());
            int max=first > second ? first : second;
            Console.WriteLine(max);
            Console.ReadKey();

            Console.WriteLine("请输入你的名字");
            string name = Console.ReadLine();
            string str=name == "老刘" ? "人才" : "流氓";
            Console.WriteLine(str);
            Console.ReadKey();

随机数

Random r =new Random();

int rNumber=r.Next(1,10);

常量

声明常量的语法：

const 变量类型 变量名=值;

枚举

语法：

[public] enum 枚举名

{

值1,

值2,

值3,

…

}

public:访问修饰词，公开的，哪都可以访问

enum:关键字，声明枚举的关键字

枚举名:要符合Pascal命名规范

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

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

枚举类型默认可以跟int类型互相转换，枚举类型更int类型兼容

所有的 类型都能转换成string类型； int n=10; string str=n.ToString();

枚举同样也可以跟string类型相互转换，如果将枚举类型转换成string类型，则直接调用ToString();

如果将字符串转换成枚举类型则需要下面这样一行代码：

(要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),“要转换的字符串” );

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

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

结构

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

方法：

[public] struct 结构名

{

​ 成员;//字段

}

namespace 结构练习
{
    public struct MyColor
    {
        public int _red;
        public int _green;
        public int _blue;
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyColor mc;
            mc._red = 255;
            mc._green = 0;
            mc._blue = 0;
        }
    }
}

namespace 结构练习
{
    public enum Gender
    {
    男,
        女
    }
    public struct Person
    {
        public int _age;
        public string _name;
        public Gender _gender;
    }
    class Program
    {
        static void Main(string[] args)
        {
            Person zhangsan;
            zhangsan._age = 22;
            zhangsan._gender = Gender.男;
            zhangsan._name = "张三";
            Person xiaolan;
            xiaolan._name = "小兰";
            xiaolan._gender = Gender.女;
            xiaolan._age = 22;
            Console.WriteLine("我叫{0}，我今年{1}岁了，我是{2}生", zhangsan._name, zhangsan._age, zhangsan._gender);
            Console.WriteLine("我叫{0}，我今年{1}岁了，我是{2}生", xiaolan._name, xiaolan._age, xiaolan._gender);
            Console.ReadKey();
        }
    }
}

数组

一次性存储多个相同类型的变量

语法：

数组类型[] 数组名=new 数组类型{数组长度}

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

        int[] nums = new int[10];
        for (int i = 0; i <nums.Length;i++)
        {
            nums[i] = i;
        }
        for (int i = 0; i < nums.Length ; i++)
        {
            Console.WriteLine(nums[i]);
        }
        Console.ReadKey();

        int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        int max = nums[0];
        int min = nums[0];
        int sum = 0;
        for (int i = 0; i < nums.Length; i++)
        {
            if (nums[i] > max)
            {
                max = nums[i];
            }
            else if (nums[i] < min)
            {
                min = nums[i];
            }
            sum += nums[i];
        }
        Console.WriteLine("数组中最大值是{0}，最小值是{1}，总和是{2}，平均值是{3}", max, min, sum, sum / nums.Length);
        Console.ReadKey();

冒泡排序

将一个数组中的元素按照从大到小或者从小到大的顺序进行排列

        int[] nums = { 8, 7, 4, 0, 9, 2, 3, 6, 1, 5 };
        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 n1=nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = n1;
                }
            }
        }
        for (int i = 0; i < nums.Length ; i++)
		{
            Console.WriteLine(nums[i]);
		}
        Console.ReadKey();

方法(函数)

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

函数的语法：

[public] static 返回值类型 方法名([参数列表])

(

方法体；

)

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

static:静态的

返回值类型:如果不需要返回值，写void

方法名:Pascal命名法，每个单词的首字母都大写，其余字母小写

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

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

方法的调用语法:

类名.方法名([参数])

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

class Program
{
    static void Main(string[] args)
    {
        int n3 =GetMax(1, 3);
        Console.WriteLine(n3);
        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;
    }

return

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