4.1布尔逻辑

C#入门优良 Chapter四 流程序调整制,

4.一布尔逻辑

  布尔相比较运算符

  ==  !=   <   >    <=    >=

  管理布尔值的布尔值运算符

  ! & | ^(异或)

  条件布尔运算符

  &&   ||  比&和|品质越来越好  
 例如&&只需判定前方的布尔值为false,全体值就为false,不用总括前边的布尔值

  一.布尔赋值运算符

    &=  |=  ^=

  二.按位运算符

    &  |  ^  ~

    位移运算符 >>  <<

    位移赋值运算符>>=   <<=

  三.运算符优先级(更新)

    ++,–(用作前缀);(),+,-(一元),!,~

Java基础语法总结二,入门精彩。    *,/,%

    +,-

    <<,>>

    <,>,<=,>=

    ==,!=

    &

    ^

    |

    &&

    ||

    =,*=,/=,%=,+=,-=,>>=,<<=,&=,^=,|=赋值运算符

    ++,–(用作后缀)

4.2 goto语句

  goto  <labelName>

4.3 分支

  壹.长富运算符

    ? : 

  2.if语句

    if(){}else{}

  3.switch语句

    switch()

    {

       case val1:……;break;

       case val2:……;break;

       ……

       default:就算未有相配的val值,有default,实行default中的代码

     }

    注脚常量:内定变量类型和主要字const,同时必须给它们赋值。

4.四.循环:重复实践语句

  1.do循环

    do

    {先推行1回决断while()内的值,为true则再一次施行,false退出循环

    }while();

  2.while循环

      while(){}先剖断while()内的值,true才早先实行

  3.for循环

    for(int i=0;i<4,i++){}

  肆.循环中断

    break:马上停下循环

    continue:立即停下当前巡回,进入下3遍巡回

    goto:跳出循环到钦点标志地点上

    return:跳出循环及分包该循环的函数

  伍.最为循环

    while(true){}    利用break等退出


Mandelbrot会集示例(书中提交的言传身教代码用C#)

 class Program
    {
        //Mandelbrot图像中的每个位置都对应于公式N=x+y*i中的一个复数。其实数部分是x,虚数部分是y,i是-1的平方根。图像中各个位置的x和y坐标对应于虚数的x和y部分
        //图像中的每个位置用参数N来表示,它是x*x+y*y的平方根。如果这个值大于或等于2,则这个数字对应的位置值是0。如果参数N的值小于2,就把N的值改为N*N-N(N=(x* x-y* y-x)+(2*x* y-y)*i)),并再次测试这个新N值。如果这个值大于或等于2,则这个数字对应的位置值是1。这个过程一直继续下去,直到我们给图像中的位置赋一个值,或迭代执行的次数多于指定的次数为止。”
        static void Main(string[] args)
        {
            //N的实数和虚数部分
            double realCoord, imagCoord;
            //存储计算过程中的临时信息
            double realTemp, imagTemp, realTemp2, arg;
            //记录在参数N(arg)等于或大于2之前的迭代次数
            int iterations;
            //选择合适的边界值来显示Mandelbrot图像的主要部分,如果想放大这个图像,可以放大这些边界值。
            for (imagCoord = 1.2; imagCoord >= -1.2; imagCoord -= 0.05)
            {
                //两个for循环处理图像中的一个点,给N指定一个值。
                for (realCoord = -0.6; realCoord <= 1.77; realCoord += 0.03)
                {
                    //初始化变量
                    iterations = 0;
                    realTemp = realCoord;
                    imagTemp = imagCoord;
                    arg = (realCoord * realCoord) + (imagCoord * imagCoord);

                    //2是4的平方根,所以仅计算x^2+y^2的值,while循环执行迭代,
                    while ((arg < 4) && (iterations < 40))
                    {
                        //N*N-N的实数部分
                        realTemp2 = (realTemp * realTemp) - (imagTemp * imagTemp)
                              - realCoord;
                        //N*N-N的虚数部分
                        imagTemp = (2 * realTemp * imagTemp) - imagCoord;
                        realTemp = realTemp2;
                        arg = (realTemp * realTemp) + (imagTemp * imagTemp);
                        //当前点的值存储在iterations中
                        iterations += 1;
                    }

                    //选择要输出的字符
                    switch (iterations % 4)
                    {
                        case 0:
                            Console.Write(".");
                            break;
                        case 1:
                            Console.Write("o");
                            break;
                        case 2:
                            Console.Write("O");
                            break;
                        case 3:
                            Console.Write("@");
                            break;
                    }
                }
                //内层循环结束后需要结束一行,所以输出换行符。
                Console.Write("\n");
            }
            Console.ReadKey();
        }
    }

演示结果为:

金沙注册送58 1

章节习题供给用户输入图像的界限,并展示选中的图像部分。当前代码输出的字符应正好能放在调控台应用程序的1行上,思念什么使各样选中的图像正好占有

高低一样的半空中,以最大化可视区域。

  class Program
    {
        //Mandelbrot图像中的每个位置都对应于公式N=x+y*i中的一个复数。其实数部分是x,虚数部分是y,i是-1的平方根。图像中各个位置的x和y坐标对应于虚数的x和y部分
        //图像中的每个位置用参数N来表示,它是x*x+y*y的平方根。如果这个值大于或等于2,则这个数字对应的位置值是0。如果参数N的值小于2,就把N的值改为N*N-N(N=(x* x-y* y-x)+(2*x* y-y)*i)),并再次测试这个新N值。如果这个值大于或等于2,则这个数字对应的位置值是1。这个过程一直继续下去,直到我们给图像中的位置赋一个值,或迭代执行的次数多于指定的次数为止。”
        static void Main(string[] args)
        {
            //N的实数和虚数部分
            double realCoord, imagCoord;
            double realMax = 1.77;
            double realMin = -0.6;
            double imagMax = -1.2;
            double imagMin = 1.2;
            double realStep;
            double imagStep;
            //存储计算过程中的临时信息
            double realTemp, imagTemp, realTemp2, arg;
            //记录在参数N(arg)等于或大于2之前的迭代次数
            int iterations;
            //选择合适的边界值来显示Mandelbrot图像的主要部分,如果想放大这个图像,可以放大(其实是减小)这些边界值。
            while (true)
            {
                //设定跨度以保证每个选中的图像正好占据大小相同的空间,以最大化可视区域。
                realStep = (realMax - realMin) / 79;
                imagStep = (imagMax - imagMin) / 48;
                for (imagCoord = imagMin; imagCoord >= imagMax; imagCoord += imagStep)
                {
                    //两个for循环处理图像中的一个点,给N指定一个值。
                    for (realCoord = realMin; realCoord <= realMax; realCoord += realStep)
                    {
                        //初始化变量
                        iterations = 0;
                        realTemp = realCoord;
                        imagTemp = imagCoord;
                        arg = (realCoord * realCoord) + (imagCoord * imagCoord);

                        //2是4的平方根,所以仅计算x^2+y^2的值,while循环执行迭代,
                        while ((arg < 4) && (iterations < 40))
                        {
                            //N*N-N的实数部分
                            realTemp2 = (realTemp * realTemp) - (imagTemp * imagTemp)
                                  - realCoord;
                            //N*N-N的虚数部分
                            imagTemp = (2 * realTemp * imagTemp) - imagCoord;
                            realTemp = realTemp2;
                            arg = (realTemp * realTemp) + (imagTemp * imagTemp);
                            //当前点的值存储在iterations中
                            iterations += 1;
                        }

                        //选择要输出的字符
                        switch (iterations % 4)
                        {
                            case 0:
                                Console.Write(".");
                                break;
                            case 1:
                                Console.Write("o");
                                break;
                            case 2:
                                Console.Write("O");
                                break;
                            case 3:
                                Console.Write("@");
                                break;
                        }
                    }
                    //内层循环结束后需要结束一行,所以输出换行符。
                    Console.Write("\n");
                }
                //当前边界值
                Console.WriteLine("Current limits:");
                Console.WriteLine("realCoord:from {0} to {1} ", realMin, realMax);
                Console.WriteLine("imagCoord:from {0} to {1} \n", imagMin, imagMax);

                //输入新的边界值
                Console.WriteLine("Enter new limits:");
                //实数
                Console.WriteLine("realCoord:from:");
                realMin = Convert.ToDouble(Console.ReadLine());
                Console.WriteLine("realCoord:to:");
                realMax = Convert.ToDouble(Console.ReadLine());
                //虚数
                Console.WriteLine("imagCoord:from:");
                imagMin = Convert.ToDouble(Console.ReadLine());
                Console.WriteLine("imagCoord:to:");
                imagMax = Convert.ToDouble(Console.ReadLine());

            }
        }
    }

原边界(-0.6,1.2)  (1.77,-1.2)

现边界(-0.6,1.2) (0,0)

一定于放大了原本的图像的一局地:大致是这一片段?近期不得不懂获得那么些程度了

金沙注册送58 2

 

 

 金沙注册送58 3

 

Chapter4 流程序调整制, 四.一布尔逻辑
布尔相比运算符 == != = = 管理布尔值的布尔值运算符 ! | ^(异或)
条件布尔运算符 || 比和|品质…

三、运算符

  布尔比较运算符

Java基 本 的 运 算 符 按效益分有 下 面 几 类 :

  ==  !=   <   >    <=    >=

1.算 术 运 算 符 (+,-,*,/,%,++,–) Java对 加 运 算 符 进 行 了 扩 展
,使 它 能 够 进 行 字 符 串 的连 接,如 “abc”+”de”,获得 串 “abcde”。与
C、 C++不 同 ,对 取 模 运 算 符 %来 说 ,其 操 作 数 可 以为浮点 数 ,
如37.二%十=七.贰。i++与 ++i的 区 别:i++在 使 用 i之 后 ,使 i的 值 加 壹,因而 执 行 完 i++后 ,整 个 表明式的 值 为 i,而 i的 值变 为 i+壹;++i在 使 用
i之 前 ,使 i的 值 加 一,因 此 执 行 完 ++i后 ,整 个 表达式和 i的 值 均 为
i+一。

金沙注册送58 ,  管理布尔值的布尔值运算符

2.关 系 运 算 符
(>,<,>=,<=,==,!=)该运算符的表征是:运算完的结果,要么是true,要么是false。Java中
,任 何 数 据 类 型 的 数 据 (包 括 基 本 类 型 和 组 合 类 型)都可 以 通
过 ==或!=来 比 较 是 否 相 等 (这 与 C、 C++不 同 )。关 系 运 算 符 用
来 比 较 两 个 值 ,返 回 布 尔 类 型 的值true或 false,而不是C、C++中 的
1或 0。

  ! & | ^(异或)

3.布 尔 逻 辑 运 算 符 (& | ^ ! && ||)

  条件布尔运算符

逻辑运算符除了 ! 外都以用来连接三个boolean类型表明式。

  &&   ||  比&和|质量更加好  
 比方&&只需判定前方的布尔值为false,全部值就为false,不用总结前边的布尔值

&: 唯有两边都为true结果是true。不然正是false。

  1.布尔赋值运算符

|:只要两边都为false结果是false,否则正是true

    &=  |=  ^=

^:异或:和或稍微分歧等。

  贰.按位运算符

两边结果一致,就为false。

    &  |  ^  ~

两边结果不一致,就为true.

    位移运算符 >>  <<

& 和 &&分裂: & :无论左侧结果是何许,左侧都踏足运算。

    位移赋值运算符>>=   <<=

&&:短路与,若是左侧为false,那么左侧不参数与运算。

  3.运算符优先级(更新)

| 和|| 差异:|:两边都运算。

    ++,–(用作前缀);(),+,-(1元),!,~

||:短路或,倘若左侧为true,那么右侧不参加运算。

    *,/,%

4.位 运 算 符 (>>,<<,>>>,&,|,^,~ )
用于操作二进制位的运算符,如二*8 = 二<<叁;。>>>(无符号右移)

    +,-

5.赋 值 运 算 符 (= += -= *= /= %=)

    <<,>>

6.条 件 运 算 符 ( ?:)

    <,>,<=,>=

7.其 它 (包 括 分 量 运 算 符 · ,下 标 运 算 符 [],实 例 运 算 符
instanc eof,内 存 分 配运 算 符 new,强 制 类 型 转 换 运 算 符 (类 型 ),
方 法调 用 运 算 符 () 等 )

    ==,!=

事例:对七个变量的数量开始展览沟通。无需第贰方变量。

    &

int a = 3,b = 5;–>b = 3,a = 5;

    ^

a = a + b; a = 8;

    |

b = a – b; b = 3;

    &&

a = a – b; a = 5;

    ||

a = a ^ b;//

    =,*=,/=,%=,+=,-=,>>=,<<=,&=,^=,|=赋值运算符

b = a ^ b;//b = a ^ b ^ b = a

    ++,–(用作后缀)

a = a ^ b;//a = a ^ b ^ a = b;

4.2 goto语句

Java 中国共产党有 54 种运算符,按优先级能够分为 1④ 级:

  goto  <labelName>

优先级 操作符 含义 关联性 用法

4.3 分支


  一.伊利运算符

1 [ ] 数组下标 左 array_name[expr]

    ? : 

. 成员选取 左 object.member

  2.if语句

( ) 方法参数 左 method_name(expr_list)

    if(){}else{}

( ) 实例构造 左 class_name(expr_list)

  3.switch语句

++ 后缀自增 左 lvalue++

    switch()

— 后缀自减 左 lvalue–

    {

二 ++ 前缀自增 右 ++rvalue

       case val1:……;break;

— 前缀自减 右 –lvalue

       case val2:……;break;

~ 按位取反 右 ~expr

       ……

! 逻辑非 右 !expr

       default:要是未有相配的val值,有default,实施default中的代码

+ 一元加 右 +expr

     }

– 一元减 右 -expr

    证明常量:钦点变量类型和首要性字const,同时必须给它们赋值。

三 ( ) 强制调换 右 (type)expr

4.四.循环:重复推行语句

new 对象实例化 右 new type()

  1.do循环

new type(expr_list)

    do

new type[expr]

    {先实行1遍剖断while()内的值,为true则再度施行,false退出循环

4 * 乘 左 expr * expr

    }while();

/ 除 左 expr / expr

  2.while循环

% 求余 左 expr % expr

      while(){}先判定while()内的值,true才开头实行

5 + 加 左 expr + expr

  3.for循环

– 减 左 expr – expr

    for(int i=0;i<4,i++){}

+ 字符串连接 左 strExpr + strExpr

  4.循环中断

六 >> 有号子右移 左 expr >> distance

    break:立刻截止循环

>>> 无符号右移 左 expr >>> distance

    continue:霎时停下当前巡回,进入下1次巡回

7 < 小于 左 expr < expr

    goto:跳出循环到钦点标志地点上

<= 小于等于 左 expr <= expr

    return:跳出循环及富含该循环的函数

> 大于 左 expr > expr

  5.最佳循环

>= 大于等于 左 expr >= expr

    while(true){}    利用break等退出

instanceof 类型比较 左 ref instanceof refType


== 等于 左 expr == expr

Mandelbrot集结示例(书中提交的示范代码用C#)

!= 不等于 左 expr != expr

 class Program
    {
        //Mandelbrot图像中的每个位置都对应于公式N=x+y*i中的一个复数。其实数部分是x,虚数部分是y,i是-1的平方根。图像中各个位置的x和y坐标对应于虚数的x和y部分
        //图像中的每个位置用参数N来表示,它是x*x+y*y的平方根。如果这个值大于或等于2,则这个数字对应的位置值是0。如果参数N的值小于2,就把N的值改为N*N-N(N=(x* x-y* y-x)+(2*x* y-y)*i)),并再次测试这个新N值。如果这个值大于或等于2,则这个数字对应的位置值是1。这个过程一直继续下去,直到我们给图像中的位置赋一个值,或迭代执行的次数多于指定的次数为止。”
        static void Main(string[] args)
        {
            //N的实数和虚数部分
            double realCoord, imagCoord;
            //存储计算过程中的临时信息
            double realTemp, imagTemp, realTemp2, arg;
            //记录在参数N(arg)等于或大于2之前的迭代次数
            int iterations;
            //选择合适的边界值来显示Mandelbrot图像的主要部分,如果想放大这个图像,可以放大这些边界值。
            for (imagCoord = 1.2; imagCoord >= -1.2; imagCoord -= 0.05)
            {
                //两个for循环处理图像中的一个点,给N指定一个值。
                for (realCoord = -0.6; realCoord <= 1.77; realCoord += 0.03)
                {
                    //初始化变量
                    iterations = 0;
                    realTemp = realCoord;
                    imagTemp = imagCoord;
                    arg = (realCoord * realCoord) + (imagCoord * imagCoord);

                    //2是4的平方根,所以仅计算x^2+y^2的值,while循环执行迭代,
                    while ((arg < 4) && (iterations < 40))
                    {
                        //N*N-N的实数部分
                        realTemp2 = (realTemp * realTemp) - (imagTemp * imagTemp)
                              - realCoord;
                        //N*N-N的虚数部分
                        imagTemp = (2 * realTemp * imagTemp) - imagCoord;
                        realTemp = realTemp2;
                        arg = (realTemp * realTemp) + (imagTemp * imagTemp);
                        //当前点的值存储在iterations中
                        iterations += 1;
                    }

                    //选择要输出的字符
                    switch (iterations % 4)
                    {
                        case 0:
                            Console.Write(".");
                            break;
                        case 1:
                            Console.Write("o");
                            break;
                        case 2:
                            Console.Write("O");
                            break;
                        case 3:
                            Console.Write("@");
                            break;
                    }
                }
                //内层循环结束后需要结束一行,所以输出换行符。
                Console.Write("\n");
            }
            Console.ReadKey();
        }
    }

八 & 整数按位与 左 integralExpr & integralExpr

演示结果为:

& 布尔与 左 booleanExpr & booleanExpr

金沙注册送58 4

9 ^ 整数按位异或 左 integralExpr ^ integralExpr

章节习题供给用户输入图像的边界,并出示选中的图像部分。当前代码输出的字符应正好能放在调整台应用程序的1行上,思虑怎么着使各类选中的图像正好占据

^ 布尔异或 左 booleanExpr ^ booleanExpr

高低同样的空间,以最大化可视区域。

10 | 整数按位或 左 integralExpr | integralExpr

  class Program
    {
        //Mandelbrot图像中的每个位置都对应于公式N=x+y*i中的一个复数。其实数部分是x,虚数部分是y,i是-1的平方根。图像中各个位置的x和y坐标对应于虚数的x和y部分
        //图像中的每个位置用参数N来表示,它是x*x+y*y的平方根。如果这个值大于或等于2,则这个数字对应的位置值是0。如果参数N的值小于2,就把N的值改为N*N-N(N=(x* x-y* y-x)+(2*x* y-y)*i)),并再次测试这个新N值。如果这个值大于或等于2,则这个数字对应的位置值是1。这个过程一直继续下去,直到我们给图像中的位置赋一个值,或迭代执行的次数多于指定的次数为止。”
        static void Main(string[] args)
        {
            //N的实数和虚数部分
            double realCoord, imagCoord;
            double realMax = 1.77;
            double realMin = -0.6;
            double imagMax = -1.2;
            double imagMin = 1.2;
            double realStep;
            double imagStep;
            //存储计算过程中的临时信息
            double realTemp, imagTemp, realTemp2, arg;
            //记录在参数N(arg)等于或大于2之前的迭代次数
            int iterations;
            //选择合适的边界值来显示Mandelbrot图像的主要部分,如果想放大这个图像,可以放大(其实是减小)这些边界值。
            while (true)
            {
                //设定跨度以保证每个选中的图像正好占据大小相同的空间,以最大化可视区域。
                realStep = (realMax - realMin) / 79;
                imagStep = (imagMax - imagMin) / 48;
                for (imagCoord = imagMin; imagCoord >= imagMax; imagCoord += imagStep)
                {
                    //两个for循环处理图像中的一个点,给N指定一个值。
                    for (realCoord = realMin; realCoord <= realMax; realCoord += realStep)
                    {
                        //初始化变量
                        iterations = 0;
                        realTemp = realCoord;
                        imagTemp = imagCoord;
                        arg = (realCoord * realCoord) + (imagCoord * imagCoord);

                        //2是4的平方根,所以仅计算x^2+y^2的值,while循环执行迭代,
                        while ((arg < 4) && (iterations < 40))
                        {
                            //N*N-N的实数部分
                            realTemp2 = (realTemp * realTemp) - (imagTemp * imagTemp)
                                  - realCoord;
                            //N*N-N的虚数部分
                            imagTemp = (2 * realTemp * imagTemp) - imagCoord;
                            realTemp = realTemp2;
                            arg = (realTemp * realTemp) + (imagTemp * imagTemp);
                            //当前点的值存储在iterations中
                            iterations += 1;
                        }

                        //选择要输出的字符
                        switch (iterations % 4)
                        {
                            case 0:
                                Console.Write(".");
                                break;
                            case 1:
                                Console.Write("o");
                                break;
                            case 2:
                                Console.Write("O");
                                break;
                            case 3:
                                Console.Write("@");
                                break;
                        }
                    }
                    //内层循环结束后需要结束一行,所以输出换行符。
                    Console.Write("\n");
                }
                //当前边界值
                Console.WriteLine("Current limits:");
                Console.WriteLine("realCoord:from {0} to {1} ", realMin, realMax);
                Console.WriteLine("imagCoord:from {0} to {1} \n", imagMin, imagMax);

                //输入新的边界值
                Console.WriteLine("Enter new limits:");
                //实数
                Console.WriteLine("realCoord:from:");
                realMin = Convert.ToDouble(Console.ReadLine());
                Console.WriteLine("realCoord:to:");
                realMax = Convert.ToDouble(Console.ReadLine());
                //虚数
                Console.WriteLine("imagCoord:from:");
                imagMin = Convert.ToDouble(Console.ReadLine());
                Console.WriteLine("imagCoord:to:");
                imagMax = Convert.ToDouble(Console.ReadLine());

            }
        }
    }

| 布尔或 左 booleanExpr | booleanExpr

原边界(-0.6,1.2)  (1.77,-1.2)

11 && 逻辑与 左 booleanExpr && booleanExpr

现边界(-0.6,1.2) (0,0)

12 || 逻辑或 左 booleanExpr || booleanExpr

也就是放大了原先的图像的1有的:大约是那一局地?如今只得掌握到那么些程度了

一叁 ? : 条件运算 右 booleanExpr ? expr : expr

金沙注册送58 5

14 = 赋值 右 lvalue = expr

 

*= 乘赋值 右 lvalue *= expr

 

/= 除赋值 右 lvalue /= expr

 金沙注册送58 6

%= 模赋值 右 lvalue %= expr

 

+= 加赋值 右 lvalue += expr

+= 字符串连接赋值 右 lvalue += expr

-= 减赋值 右 lvalue -= expr

<<= 左移赋值 右 lvalue <<= expr

>>= 有暗号右移赋值 右 lvalue >>= expr

>>>= 无符号右移赋值 右 lvalue >>>= expr

&= 整数按位与赋值 右 lvalue &= expr

&= 布尔与赋值 右 lvalue &= expr

|= 整数按位或赋值 右 lvalue |= expr

|= 布尔或赋值 右 lvalue |= expr

^= 整数按位异或赋值 右 lvalue ^= expr

^= 布尔异或赋值 右 lvalue ^= expr

运算符不但有优先级,还有关联性。上表中关联性为”左”表示该表达式从右侧初阶实行演算;关联性为”右”表示该表明式从左边伊始开始展览演算。

四、流程序调节制语句(If 、 switch、 do while、 while、 for、break、continue)

一.
当推断数据范围,获取判别运算结果boolean类型时,要求动用if;当推断固定个数的值的时候,能够选拔if,也足以选择switch。可是提出使用switch,作用相对较高。

switch(变量){

case 值:要实行的讲话;break;

default:要实行的语句;

}

做事原理:用小括号中的变量的值依次和case前面的值举办对照,和哪些case前面包车型客车值同样了就试行哪个case前面包车型大巴语句,假使未有同样的则进行default后边的口舌;

细节:一):break是足以简轻巧单的,假若轻松了就向来实施到遭受break 截至;

2):switch
前面包车型客车小括号中的变量应该是byte,char,short,int6系列型中的1种;

三):default能够写在switch结构中的放肆地方;如若将default语句放在了第一行,则不管expression与case中的value是还是不是协作,程序会从default开始实践直到首个break出现。

二.当或多或少语句须要实行很频仍时,就用循环结构。

while和for可以开始展览沟通。区别在于:假使必要定义变量支配循环次数。提出选择for。因为for循环完结,变量在内部存款和储蓄器中自由。

叁.break:功用于switch
,和循环语句,用于跳出,也许叫做为止。break语句单独存在时,上面不要定义其余语句,因为实践不到,编译会失败。当循环嵌套时,break只跳出当前所在循环。要跳出嵌套中的外部循环,只要给循环起名字就可以,那个名字叫做标号。

4.continue:只效率于循环结构,继续循环用的。功效:结束本次巡回,继续后一次循环。该语句单独存在时,上面无法定义语句,试行不到

(转:

相关文章

网站地图xml地图