学习c#的第六天

[C# 判断](# 判断)

[if 语句](#if 语句)

[嵌套 if 语句](#嵌套 if 语句)

[switch 语句](#switch 语句)

[嵌套 switch 语句](#嵌套 switch 语句)

[? : 运算符](#? : 运算符)

[C# 循环](# 循环)

循环类型

[while 循环](#while 循环)

[for/foreach 循环](#for/foreach 循环)

[do...while 循环](#do...while 循环)

嵌套循环

循环控制语句

[break 语句](#break 语句)

[continue 语句](#continue 语句)

无限循环

C# 判断

if 语句

在C#中，if语句用于根据条件执行代码块。它的基本语法结构如下：

cs 复制代码

if (condition)
{
    // 如果条件为真，执行这里的代码
}

在这个结构中，condition是一个布尔表达式，如果它的值为true，那么紧跟在它后面的花括号内的代码块将会被执行。

除了最基本的if语句，C#还提供了其他几种变体，比如if-else语句和if-else if-else语句，用于处理多个条件的情况。

if-else语句的结构如下：

cs 复制代码

if (condition)
{
    // 如果条件为真，执行这里的代码
}
else
{
    // 如果条件为假，执行这里的代码
}

if-else if-else语句的结构如下：

cs 复制代码

if (condition1)
{
    // 如果条件1为真，执行这里的代码
}
else if (condition2)
{
    // 如果条件2为真，执行这里的代码
}
else
{
    // 如果以上条件都不为真，执行这里的代码
}

在编写if语句时，务必注意花括号的使用，尤其是在多行代码块中。

代码示例

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int z = 7;
        if (z < 5)
        {
            Console.WriteLine("z小于5");
        }
        else if (z == 5)
        {
            Console.WriteLine("z等于5");
        }
        else
        {
            Console.WriteLine("z大于5");
        }

    }
}

嵌套 if 语句

嵌套if语句是指在if语句的代码块内部再包含一个或多个if语句。这种结构通常用于处理更复杂的条件逻辑。以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int num = 10;
        if (num > 0)
        {
            Console.WriteLine("num大于0");
            if (num % 2 == 0)
            {
                Console.WriteLine("num是偶数");
            }
            else
            {
                Console.WriteLine("num是奇数");
            }
        }
        else
        {
            Console.WriteLine("num不大于0");
        }
    }
}

在这个示例中，外部的if语句检查num是否大于0，如果是，则执行外部if语句的代码块。在外部if语句的代码块内部，又包含了一个if-else语句，用于判断num是偶数还是奇数。

switch 语句

在C#中，switch语句用于根据表达式的值选择不同的执行路径。它的基本语法结构如下：

cs 复制代码

switch (expression)
{
    case value1:
        // 当表达式的值等于value1时执行这里的代码
        break;
    case value2:
        // 当表达式的值等于value2时执行这里的代码
        break;
    // 更多case语句
    default:
        // 如果表达式的值不匹配任何case时执行这里的代码
        break;
}

在这个结构中，expression是一个表达式，它的值会被和每个case后面的value进行比较。如果找到了匹配的value，则执行相应的代码块。如果没有找到匹配的value，则执行default标签后的代码块（default标签是可选的）。

以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int day = 3;
        switch (day)
        {
            case 1:
                Console.WriteLine("星期一");
                break;
            case 2:
                Console.WriteLine("星期二");
                break;
            case 3:
                Console.WriteLine("星期三");
                break;
            default:
                Console.WriteLine("其他");
                break;
        }
    }
}

在这个示例中，根据day的值，选择不同的执行路径输出相应的星期几信息。

嵌套 switch 语句

在C#中，可以嵌套switch语句，这意味着在一个switch语句的case块内部使用另一个switch语句。这种结构可以用于处理更复杂的条件逻辑。

以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int category = 2;
        int item = 3;

        switch (category)
        {
            case 1:
                switch (item)
                {
                    case 1:
                        Console.WriteLine("选择了类别1的物品1");
                        break;
                    case 2:
                        Console.WriteLine("选择了类别1的物品2");
                        break;
                    default:
                        Console.WriteLine("类别1中没有这个物品");
                        break;
                }
                break;
            case 2:
                switch (item)
                {
                    case 1:
                        Console.WriteLine("选择了类别2的物品1");
                        break;
                    case 2:
                        Console.WriteLine("选择了类别2的物品2");
                        break;
                    default:
                        Console.WriteLine("类别2中没有这个物品");
                        break;
                }
                break;
            default:
                Console.WriteLine("其他类别");
                break;
        }

    }
}

在这个示例中，外部的switch语句根据category的值选择不同的执行路径，而在每个case块内部又包含了一个嵌套的switch语句，用于根据item的值进一步选择执行路径。

? : 运算符

我们已经在前面讲解了 条件运算符 ? : ，可以用来替代 if...else 语句。它的一般形式如下：

cs 复制代码

condition ? expr1 : expr2

其中，condition 是一个布尔表达式，如果它的值为 true，则整个表达式的值为 expr1；如果 condition 的值为 false，则整个表达式的值为 expr2。

以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int num = 10;
        string result = (num > 0) ? "正数" : "非正数";
        Console.WriteLine(result);  // 输出："正数"

    }
}

在这个示例中，如果num大于0，则result的值为"正数"；否则result的值为"非正数"。

条件运算符通常用于简单的条件判断，并且可以嵌套使用以构建复杂的条件逻辑。

C# 循环

循环类型

while 循环

在C#中，while 循环用于在指定条件为真时重复执行代码块。其基本语法结构如下：

cs 复制代码

while (condition)
{
    // 在条件为真时执行的代码
    // 通常会在循环体内修改条件，以便在某个时刻终止循环
}

在这个结构中，condition 是一个布尔表达式，当它的值为 true 时，循环体内的代码会被执行。在每次循环迭代之后，都会重新检查 condition 的值，如果它仍然为 true，则继续执行循环体内的代码；否则循环终止。

以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int count = 0;
        while (count < 5)
        {
            Console.WriteLine("当前计数值为：" + count);
            count++;
        }
    }
}

在这个示例中，当 count 小于 5 时，循环体内的代码会被执行，并且在每次循环迭代之后 count 的值会递增，直到 count 不再小于 5 时循环终止。

while 循环适用于当循环次数未知但循环条件已知或者循环次数受其他变量控制的情况。需要注意的是，如果循环条件永远不为假，将导致无限循环，因此必须在循环体内部有机制来改变循环条件，以确保循环最终会结束。

for/foreach 循环

在C#中，for 循环和 foreach 循环用于重复执行代码块，但它们的应用场景和语法略有不同。

1、for 循环

for 循环通常用于已知循环次数的情况，其基本语法结构如下：

cs 复制代码

for (initialization; condition; iterator)
{
    // 循环体内的代码
}

其中：

initialization 用于初始化循环控制变量，通常是一个赋值表达式，用于设置循环的起始条件。
condition 是一个布尔表达式，用于定义循环继续执行的条件。
iterator 用于更新循环控制变量的值，通常是对循环控制变量进行增量或减量操作。

以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("当前计数值为：" + i);
        }

    }
}

在这个示例中，for 循环会从 i=0 开始，当 i<5 时，执行循环体内的代码，并且在每次循环迭代之后 i 的值会递增，直到 i 不再小于 5 时循环终止。

2、foreach 循环

foreach 循环用于遍历集合类型（如数组、列表等）中的元素，其基本语法结构如下：

cs 复制代码

foreach (var item in collection)
{
    // 对集合中的每个元素执行的代码
}

其中 collection 是一个集合类型的对象，item 是在循环过程中用来存储当前元素的变量。

以下是一个示例，展示了如何使用 foreach 遍历数组：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        foreach (int number in numbers)
        {
            Console.WriteLine("当前数字为：" + number);
        }


    }
}

在这个示例中，foreach 循环会遍历数组 numbers 中的每个元素，并将当前元素的值存储在 number 变量中，然后执行循环体内的代码。

总结来说，for 循环适用于已知循环次数的情况，而 foreach 循环适用于遍历集合类型中的元素。

do...while 循环

在C#中，do...while 循环和 while 循环类似，都是用于重复执行代码块直到指定条件不再满足。不同之处在于，do...while 循环会先执行一次循环体内的代码，然后再检查循环条件是否满足。其基本语法结构如下：

cs 复制代码

do
{
    // 循环体内的代码
}
while (condition);

在这个结构中，循环体内的代码会先被执行，然后再检查 condition 的值。只有在 condition 为 true 时，循环才会继续执行；否则循环终止。

以下是一个简单的示例：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        int count = 0;
        do
        {
            Console.WriteLine("当前计数值为：" + count);
            count++;
        }
        while (count < 5);
    }
}

在这个示例中，无论 count 是否小于 5，循环体内的代码都会被执行至少一次。之后，才会根据 count < 5 的条件决定是否继续执行循环。

do...while 循环适用于需要保证循环体内的代码至少执行一次的情况，而且循环是否继续执行取决于条件是否满足。与 while 循环相比，do...while 循环在某些场景下更方便，因为它可以确保循环体内的代码至少被执行一次。

嵌套循环

嵌套循环是指在一个循环结构内部再包含另一个循环结构，以此来实现更复杂的重复执行逻辑。在 C# 中，可以通过嵌套 for、while、do...while 或者混合使用多种类型的循环来实现嵌套循环。

以下是一个简单的示例，展示了如何使用嵌套循环生成九九乘法表：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= i; j++)
            {
                Console.Write($"{j} * {i} = {j * i}\t");
            }
            Console.WriteLine();
        }
    }
}

在上面的示例中，外层循环控制乘法表的行数，内层循环控制每一行的输出内容。通过嵌套循环，可以依次输出1*1,1*2.........，以此类推，最终得到完整的九九乘法表。

嵌套循环通常用于处理多维数据、图形输出、遍历二维数组等场景，能够帮助我们处理更为复杂的循环逻辑。但需要注意的是，嵌套循环会增加代码的复杂度，可能导致性能损耗，

循环控制语句

在C#中，break 和 continue 语句是用于控制循环行为的关键工具。

break 语句

break 语句用于立即终止包含它的最内层循环（for、while、do...while），并且跳出该循环执行循环后面的代码。例如：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            if (i == 5)
            {
                break; // 当 i 等于 5 时终止循环
            }
            Console.WriteLine(i);
        }

    }
}

在这个示例中，当 i 的值等于 5 时，break 语句会立即退出循环，不再执行循环体内 Console.WriteLine(i); 后面的代码。

continue 语句

continue 语句用于立即跳过循环体内剩余的代码，直接进入下一次循环的迭代。例如：

cs 复制代码

using System;

public class Program
{
    public static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            if (i == 2)
            {
                continue; // 当 i 等于 2 时跳过当前迭代
            }
            Console.WriteLine(i);
        }
    }
}

在这个示例中，当 i 的值等于 2 时，continue 语句会跳过 Console.WriteLine(i);，直接进行下一次循环迭代。

break 和 continue 语句通常与条件语句结合使用，用于根据特定条件来控制循环的执行流程。

无限循环

无限循环是指在程序执行过程中，循环条件一直保持为真，导致循环体内的代码反复执行而无法停止的情况。在C#中，编写无限循环的常见方式是使用 while 或者 for 循环，并且省略了导致循环条件变为假的更新语句或者条件判断语句。例如：

cs 复制代码

// 无限循环示例（慎用，可能导致系统资源耗尽）
while (true)
{
    // 无限循环体
}

// 或者使用 for 循环
for (;;)
{
    // 无限循环体
}

在上面的示例中，while (true) 和 for (;;) 都是典型的无限循环结构，它们会使循环体内的代码永远执行下去。

然而，应该注意到无限循环可能导致严重的问题，例如系统资源耗尽、程序无响应等。因此，如果要使用无限循环，务必要有明确的终止循环的条件，并且确保在适当的时候跳出循环，以免造成程序异常或系统负担过重。

cs 复制代码

using System;

class Program
{
    static void Main()
    {
        int count = 0;

        // 无限循环
        while (true)
        {
            Console.WriteLine("正在执行无限循环，当前计数为: " + count);

            count++;

            // 当计数达到10时跳出循环
            if (count == 10)
            {
                Console.WriteLine("达到计数上限，跳出循环。");
                break; // 跳出循环
            }
        }
        Console.WriteLine("循环结束，程序继续执行其他代码。");
    }
}

在这个示例中，我们使用了 while (true) 来创建一个无限循环。在循环体内部，我们输出当前计数的信息，并模拟一些处理，然后递增计数器。当计数器达到10时，我们使用 break 语句跳出循环，程序继续执行后续的代码。

需要注意的是，无限循环应该慎重使用，确保在合适的时机能够跳出循环，避免造成资源浪费或程序陷入无响应状态。