代码流程控制

if语句结构

if语句结构的最简形式如下。

C#
if (<条件>) 
{
    <语句块>
}

其中,当<条件>的结果为true值时,执行<语句块>。下面的代码演示了此结构的应用。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int year = 2020;
            if ((year % 400 == 0) || (year % 100 != 0 && year % 4 == 0))
            {
                Console.WriteLine("{0}年是闰年", year);
            }
        }
    }
}

代码执行结果如下图。

那么,不是闰年时是不也要显示信息呢?可以添加else语句部分,如下面的代码。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int year = 2019;
            if ((year % 400 == 0) || (year % 100 != 0 && year % 4 == 0))
            {
                Console.WriteLine("{0}年是闰年", year);
            }
            else
            {
                Console.WriteLine("{0}年不是闰年", year);
            }
        }
    }
}

代码执行结果如下图。

此外,在if和else之间,还可以添加一个或多个else if部分,以判断更多的条件,如下面的代码。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int dir = 1;
            if (dir == 1)
            {
                Console.WriteLine("北");
            }
            else if (dir == 2)
            {
                Console.WriteLine("东");
            }
            else if (dir == 3)
            {
                Console.WriteLine("南");
            }
            else if (dir == 4)
            {
                Console.WriteLine("西");
            }
            else
            {
                Console.WriteLine("未知方向");
            }
        }
    }
}

执行代码会显示“北”,大家可修改dir变量的值来观察执行结果。

?:运算符

?:运算符可以看作if...else...语句结构的简写形式,其应用格式如下:

C#
x ? y : z

当x的值为true时,表达式返回y的值,当x的值为false时表达式返回z的值。下面的代码演示了?:运算符的应用。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int year = 2019;
            bool isLeapYear =
                    (year % 400 == 0) || (year % 100 != 0 && year % 4 == 0);
            Console.WriteLine("{0}{1}闰年", year, isLeapYear ? "是" : "不是");
        }
    }
}

代码执行结果如下图。

switch语句结构

switch语句结构用于处理同一变量或表达式的不同值,其中,每一个值都应使用一个case语句来处理,同时,可以使用default语句值列表之外的情况。

一般情况下,每一个case语句块及default语句块都应使用break语句作为结束,如下面的代码,我们使用switch语句重写方向的判断。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int dir = 1;
            switch (dir)
            {
                case 1:
                    Console.WriteLine("北");
                    break;
                case 2:
                    Console.WriteLine("东");
                    break;
                case 3:
                    Console.WriteLine("南");
                    break;
                case 4:
                    Console.WriteLine("西");
                    break;
                default:
                    Console.WriteLine("未知方向");
                    break;
            }
        }
    }
}

如果多个值需要使用相同的处理代码,可以利用case语句的贯穿功能,即在case语句中不添加执行代码和break语句,此时,就会向下执行case语句,直到有结束语句(如break、return、goto等)。

下面的代码,我们使用case语句的贯穿特性来判断某年某月有多少天。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int year = 2020;
            int month = 2;
            int daysInMonth = 0;
            bool isLeapYear =
                    (year % 400 == 0) || (year % 100 != 0 && year % 4 == 0);
            switch (month)
            {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    daysInMonth = 31;
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    daysInMonth = 30;
                    break;
                case 2:
                    daysInMonth = isLeapYear ? 29 : 28;
                    break;
                default:
                    daysInMonth = 0;
                    break;
            }
            Console.WriteLine("{0}年{1}月有{2}天", year, month, daysInMonth);
        }
    }
}

代码执行结果如下图。

for语句结构

for语句结构一般用于可确定执行次数的循环控制,其基本应用格式如下。

C#
for (<循环控制变量初始化> ; <条件>; <循环控制变量改变>) 
{
    <语句块>
}

如下面的代码用于计算1到100的和。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            for (int i = 0; i <= 100; i++)
            {
                sum = sum + i;
            }
            Console.WriteLine(sum);
        }
    }
}

执行代码显示5050。

灵活应用循环控制变量的改变规则,还可以简化一些工作,如下面的代码就是计算2到100的偶数之和。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            for (int i = 2; i <= 100; i = i + 2)
            {
                sum = sum + i;
            }
            Console.WriteLine(sum);
        }
    }
}

执行代码会显示2550。

foreach语句

foreach语句可以方便的访问数组或集合中的所有成员,下面先看一个简单的例子,后续课程中还会有数组和集合应用的详细讨论。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = new int[] { 1, 2, 3, 4, 5 };
            foreach (int i in arr)
            {
                Console.WriteLine(i);
            }
        }
    }
}

代码执行结果如下图。

本例中,首先定义了数组arr,其成员类型为int;在foreach语句中,变量i表示数组成员,使用in运算符指定其遍历数组arr的所有成员,并在循环语句块中显示了数组成员的值。

标签与goto语句

代码中如果需要快速跳转,可以配合使用goto语句和标签。如下面的代码。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 100; i++)
            {
                for (int j = 0; j < 100; j++)
                {
                    for (int k = 0; k < 100; k++)
                    {
                        int sum = i + j + k;
                        if (sum > 150)
                        {
                            Console.WriteLine("{0}+{1}+{2}={3}", i, j, k, sum);
                            goto tag_greater_150;
                        }
                    }
                }
            }
        tag_greater_150:;
        }
    }
}

代码执行结果如下图。

continue语句

continue语句在循环语句结构中的功能就是中断本次循环,并开始下一次循环(如果条件满足),如下面的代码,我们利用continue语句来计算1到100中的偶数之和。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            for (int i = 0; i <= 100; i++)
            {
                if (i % 2 != 0) continue;
                else sum += i;
            }
            Console.WriteLine(sum);
        }
    }
}

代码执行显示2550。

while语句结构

while语句结构的应用格式如下。

C#
while(<条件>) 
{
    <语句块>
}

结构中,当<条件>成立时(true),执行<语句块>,当<条件>不成立时(false),终止循环;下面的代码,我们使用while语句结构执行1到100的累加操作。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            int i = 1;
            while (i <= 100)
            {
                sum = sum + i;
                i++;
            }
            Console.WriteLine(sum);
        }
    }
}

执行代码显示5050。

do...while语句结构

do...while语句结构与while相似,只是判断<条件>的位置不同;do...while语句结构的应用格式如下。

C#
do 
{
    <语句块>
}while(<条件>);

如下面的代码,我们通过do...while语句结构计算2到100的偶数之和。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            int i = 2;
            do
            {
                sum = sum + i;
                i = i + 2;
            } while (i <= 100);
            Console.WriteLine(sum);
        }
    }
}

执行代码会显示2550。

实际应用中,do...while语句会在每次执行循环语句后判断条件,有时,这样会有一些完全隐患,如果没有特殊要求,我们更建议使用while语句结构,即在每次执行循环语句之前进行条件判断。

异常处理

即使我们能保证代码的健壮,也不能保证外部资源绝对的正确;能够处理应用执行过程中的未知错误,即能保证应用执行的正确性,也可以给用户以良好的映像。

C#代码中,可以使用try...catch...finally语句结构来处理可能的异常情况。首先,在try语句块中定义可能会出现异常的代码,然后,可以在一系列的catch语句块中处理已知或未知的异常类型;最后,无论代码是否出现异常,都可以在finally语句块中进行最终的处理工作。

下面的代码,我们来看看整数除0异常的信息。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int x = 10;
                int result = x / 0;
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

代码执行结果如下图。

实际应用中,可以使用多个catch语句块来处理具体的异常类型。如果无法处理异常,可以使用throw语句向代码的上一层抛出异常,如下面的代码。

C#
public class Hello {
	public static void main(String[] args) {
		try {
			int x = 10;
			int result = x / 0;
			System.out.println(result);
		} catch(Exception e) {
			throw e;
		}
	}
}

本例,在Main()方法中抛出的异常,其上层就是操作系统了,所以,执行代码会直接显示异常,如下图。

无论代码是否出现异常,finally语句块都可以执行,如下面的代码。

C#
using System;
namespace HelloProject
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int x = 10;
                int result = x / 0;
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                Console.WriteLine("程序结束");
            }
        }
    }
}

代码执行结果如下图。

本站内容均为原创作品,转载请注明出处,本页面网址为:http://caohuayu.com/chy/article/Article.aspx?code=cc002008