程序博客网 > 淘宝可靠的日本代购

黑马程序员——Java基础---基础语法（二）

来源：互联网 发布：淘宝可靠的日本代购 编辑：程序博客网 时间：2024/05/18 21:44

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------


1. 运算符

1.1 比较运算符


 

    注意：
    1、比较运算符的结果都是boolean型，也就是要么是true，要么是false。
    2、比较运算符“==”不能误写成“=” 。

    示例1：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 10 > 5 );
  5.         System.out.println( 10 == 5 );
  6.     }
  7. }
复制代码
    运行结果：


1.2 逻辑运算符


 

    逻辑运算符用于连接两个boolean类型的表达式。
    "&"符号的运算特点：
    true & true = true;
    true & false = false;
    false & true = false;
    false & false = false;

    "&"符号运算规律：
    运算的两边只要有一个是false，结果肯定是false。只有两边都为true，结果才是true。

    示例1：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 6;
  5.         System.out.println( x > 2 & x < 5 );
  6.     }
  7. }
复制代码
    运行结果：


    "|"符号的运算特点：
    true | true = true;
    true | false = true;
    false | true = true;
    false | false = false;

    "|"符号运算规律：
    运算的两边只要有一个是true，结果肯定是true。
    只有两边都为false，结果是false。

    示例2：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         System.out.println( x > 2 | x < 5 );
  6.     }
  7. }
复制代码
  运行结果：


   "^"符号的运算特点：
    true ^ true = false;
    true ^ false = true;
    false ^ true = true;
    false ^ false = false;

    "^"符号运算规律：
    ^符号的两边结果如果相同，结果是false。两边的结果不同，结果是true。

    示例3：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         System.out.println( x > 2 ^ x < 5 );
  6.     }
  7. }
复制代码
    运行结果：

 

   "！"符号运算规律：
    true = false
    !false = true
    !!true = true

    示例4：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         System.out.println( ! ( x > 2 ) );
  6.     }
  7. }
复制代码
    运行结果：

 

    P.S.
    &&：和&运算的结果是一样的，但是运算过程有点小区别。
    &：无论左边的运算结果是什么，右边都参与运算。
    &&：当左边为false时，右边不参加运算，这样可以提升效率。

    ||：和|运算的结果是一样的，但是运算过程有点小区别。
    |：无论左边的运算结果是什么，右边都参与运算。
    ||：当左边为true时，右边不参加运算，这样可以提升效率。

    使用&&和||比使用&和|更高效一些。

    逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

1.3 位运算符


 

 

    P.S.
   位运算是直接对二进制位进行运算。

   与运算例子：
   6 & 3 = 2
        110
   &  011
   -------
        010

    示例：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 6 & 3 );
  5.     }
  6. }
复制代码
   运行结果：


    P.S.
    用“与运算”可以很方便提取某一二进制数的其中几位数。

    例如：取17476二进制数的后四位。
        0100010001000100
    & 0000000000001111
    ------------------------
        0000000000000100

    或运算例子：
    6  |  3 = 7 
         110
     |   011
    --------
         111

    示例：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 6 | 3 );
  5.     }
  6. }
复制代码
   运行结果：


    异或运算例子：
    6 ^ 3 = 5
          110
    ^   011
    -------
          101

    示例：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 6 ^ 3 );
  5.     }
  6. }
复制代码
   运行结果：


    P.S.
    一个数异或同一个数两次，结果还是这个数。

    例子：
    6 ^ 3 ^ 3 = 6
    6 ^ 3 = 5
          110
    ^   011
    -------
          101
    ^   011
    -------
         110

    技巧：
    利用异或运算可以实现对数据简单地进行加密，例如对一幅图片的所有数据异或3进行加密，那么这幅图片就无法查看了。解密只需要再对图片的数据执行异或3操作即可。

    取反运算：
    取反操作就是对二进制数值的每一位0变1，1变0。

    示例：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( ~6 );
  5.     }
  6. }
复制代码
   运算结果：

 

    左移运算例子：
    3 << 2 = 12 相当于 3 * 2（2） = 12
    00000000000000000000000000000011
    00000000000000000000000000001100

    3 << 3 = 24 相当于 3 * 2（3） = 24
    00000000000000000000000000000011
    00000000000000000000000000011000

    示例：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 3 << 2 );
  5.         System.out.println( 3 << 3 );
  6.     }
  7. }
复制代码
   运行结果：


    总结：
    左移几位其实就是该数据乘以2的几次方。
    <<：可以完成2的次幂运算。

    右移运算例子：
    6 >> 1 = 3 相当于 6/2（1）=3
    00000000000000000000000000000110
    00000000000000000000000000000011

    6 >> 2 = 1 相当于 6/2（2） = 1
    00000000000000000000000000000110
    00000000000000000000000000000001

    示例：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 6 >> 1 );
  5.         System.out.println( 6 >> 2 );
  6.     }
  7. }
复制代码
   运行结果：


    总结：
    右移几位其实就是该数据除以2的几次幂。

    附：
    以上例子中括号表示次幂的意思。

    P.S.
    >>：对于高位出现的空位，原来高位是什么，就用什么补这个空位。
    >>>：无符号右移，数据进行右移时，高位出现的空位，无论原高位是什么，空位都用0补。

    练习：
    1. 最有效率的方式算出2乘以8等于几？

    答案：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         System.out.println( 2 << 3 );
  5.     }
  6. }
复制代码
    运行结果：

 

    2. 对两个整数变量的值进行互换(可以使用第三方变量)。  

    答案：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int a = 3,b = 5;

  6.         //开发时，使用第三方变量的形式，因为阅读性强。
  7.         int c;

  9.         System.out.println( "a = " + a + ",b = " + b );

  11.         c = a; 
  12.         a = b;
  13.         b = c;

  15.         System.out.println( "a = " + a + ",b = " + b );
  16.     }
  17. }
复制代码
    运行结果：


    3. 对两个整数变量的值进行互换(不可以使用第三方变量)。

    答案1：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int a = 3,b = 5;
  5.         int c;

  7.         System.out.println( "a = " + a + ",b = " + b );

  9.         //这种方式不要用，如果两个整数的数值过大，会超出int范围，会强制转换，数据会变化。
  10.         a = a + b;
  11.         b = a - b;
  12.         a = a - b;

  14.         System.out.println( "a = " + a + ",b = " + b );
  15.     }
  16. }
复制代码
   运行结果：


    答案2：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int a = 3,b = 5;
  5.         int c;

  7.         System.out.println( "a = " + a + ",b = " + b );

  9.         a = a ^ b;
  10.         b = a ^ b;
  11.         a = a ^ b;

  13.        System.out.println( "a = " + a + ",b = " + b );
  14.     }
  15. }
复制代码
   运行结果：

 

1.4 三元运算符


    格式：
    (条件表达式) ? 表达式1 : 表达式2；
    如果条件为true，运算后的结果是表达式1；
    如果条件为false，运算后的结果是表达式2。

    示例1：
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3,y;
  5.         y = ( x > 1 ) ? 100 : 200;
  6.         System.out.println( "y = " + y );
  7.     }
  8. }
复制代码
   运行结果：


    示例2：获取两个整数中的较大的整数。
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int a = 3,b = 5;
  5.         int max = a > b ? a : b;
  6.         System.out.println( max );
  7.     }
  8. }
复制代码
   运行结果：


    示例3：获取三个整数中的较大的整数。
  1. class OperatorDemo
  2. {
  3.     public static void main(String[] args){
  4.         int o = 4,p = 5,q = 10;
  5.         int temp = o > p ? o : p;
  6.         int max = temp > q ? temp : q;
  7.         System.out.println( max );
  8.     }
  9. }
复制代码
    运行结果：


    注意
    表达式：就是具有一定语法规则的语句。

2. 程序流程控制

2.1 判断结构


    if语句

    格式一：
    if ( 条件表达式 )
    {
          执行语句；
    }

    示例：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         if( x > 1 ){
  6.             System.out.println("yes");
  7.         }
  8.         System.out.println("over");
  9.     }
  10. }
复制代码
   运行结果：


    P.S.
    1、如果if语句中只有一条语句，那么可以不写大括号。不过初学者一定要写括号，以免出错。
    2、如果if语句没写大括号，if就只能控制离它最近的单条语句。

    示例：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         if( x > 1 )
  6.             System.out.println("yes");
  7.             System.out.println("over");
  8.     }
  9. }
复制代码
   运行结果：


    格式二：
    if ( 条件表达式 )
    {
         执行语句；
    }
    else
    {
         执行语句；
    }

    示例1：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         if( x > 1 ){
  6.             System.out.println("yes");
  7.         }else{
  8.              System.out.println("over");
  9.         }
  10.         System.out.println("over");
  11.     }
  12. }
复制代码
   运行结果：


    示例2：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.         int a = 3,b;
  5.         if( a > 1 )
  6.             b = 100;
  7.         else
  8.             b = 200;
  9.         System.out.println("b = " + b);
  10.     }
  11. }
复制代码
   运行结果：


    P.S.
    三元运算符就是if else语句的简写格式。
    例如：b = a > 1 ? 100 : 200;就可以实现和上面同样的功能。

    简写格式什么时候用？
    当if else运算后，有一个具体的结果时，可以简化写成三元运算符。

    格式三：
    if(条件表达式)
    {
         执行语句；
    }
    else if (条件表达式)
    {
         执行语句；
    }
    ……
    else
    {
        执行语句；
    }

    示例：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.         int x = 3;
  5.         if( x > 4 )
  6.             System.out.println("a");
  7.         else if( x > 3 )
  8.             System.out.println("b");
  9.         else if ( x > 2 )
  10.             System.out.println("c");
  11.         else if(  x > 1 )
  12.             System.out.println("d");
  13.    
  14.         System.out.println("over");
  15.     }
  16. }
复制代码
   运行结果：

 

    P.S.
    if( 表达式 )后面切忌加上分号，否则表示无论表达式为true或者false，都不执行任何语句。
   
    示例：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.         if( false );
  5.         {
  6.             System.out.println("Hello World!");
  7.         }
  8.     }
  9. }
复制代码
   运行结果：


    说明：由于if( false );语句后面加了分号，因此不执行任何操作。{ System.out.println("Hello World"); }为局部代码块。

    局部代码块：局部代码块可以定义局部变量的生命周期。

    示例：
  1. class IfDemo
  2. {
  3.     public static void main(String[] args){
  4.     {
  5.         int m = 89;
  6.         System.out.println("Hello World..." + m);
  7.     }
  8.     System.out.println("over..." + m);
  9.     }
  10. }
复制代码
    运行结果：

 

    说明：变量m是局部变量，生命周期仅在局部代码块括号中，当代码执行到局部代码块右括号外，变量m便消失了。局部代码块外的代码当然也就访问不到变量m了。

    if语句特点：
    1、每一种格式都是单条语句。
    2、第二种格式与三元运算符的区别：三元运算符运算完一定要有值出现。好处是：可以写在其他表达式中。
    3、条件表达式无论写成什么样子，只看最终的结构是否是true或者false。

    练习1：根据用户定义的数值不同，打印对应的星期。
  1. class IfDemo
  2. {
  3.         public static void main(String[] args) 
  4.         {
  5.                 /*
  6.                 需求：根据用户指定的具体数据，判断该数据对应的星期。

  8.                 思路：
  9.                 虽然用户输入无法获取，但是那只是具体数据的一种获取手段而已。
  10.                 而我们要做的功能仅仅是对用户指定的数据进行对应星期的打印而已。
  11.                 所以具体的数据不确定，可以使用变量来表示。
  12.                 我们只对变量进行操作即可。至于变量的值，可以由用户决定。
  13.                 因为数据的不确定性，所以要对数据进行判断。
  14.                 使用if语句。
  15.                 */

  17.                 int week = 4;

  19.                 if(week==1)
  20.                         System.out.println(week+"对应中文是星期一");
  21.                 else if(week==2)
  22.                         System.out.println(week+"对应中文是星期二");
  23.                 else if(week==3)
  24.                         System.out.println(week+"对应中文是星期三");
  25.                 else if(week==4)
  26.                         System.out.println(week+"对应中文是星期四");
  27.                 else if(week==5)
  28.                         System.out.println(week+"对应中文是星期五");
  29.                 else if(week==6)
  30.                         System.out.println(week+"对应中文是星期六");
  31.                 else if(week==7)
  32.                         System.out.println(week+"对应中文是星期日");
  33.                 else
  34.                         System.out.println(week+"没有对应的星期");
  35.         }
  36. }
复制代码
    运行结果：


    练习2：根据用于指定月份，打印该月份所属的季节。
  1. class IfDemo
  2. {
  3.         public static void main(String[] args) 
  4.         {
  5.                 /*
  6.                 一年有四季。
  7.                 春季：3 4 5
  8.                 夏季：6 7 8
  9.                 秋季：9 10 11
  10.                 冬季：12 1 2 
  11.                 根据用户输入的月份，给出对应的季节。
  12.                 */
  13.                 
  14.                 int month = 9;
  15.                 
  16.                 if(month<1 || month>12)
  17.                         System.out.println(month+"月没有对应的季节");
  18.                 else if(month>=3 && month<=5)
  19.                         System.out.println(month+"月是春季");
  20.                 else if(month>=6 && month<=8)
  21.                         System.out.println(month+"月是夏季");
  22.                 else if(month>=9 && month<=11)
  23.                         System.out.println(month+"月是秋季");
  24.                 else 
  25.                         System.out.println(month+"月是冬季");        
  26.         }
  27. }
复制代码
    运行结果：

2.2 选择结构


    switch语句

    格式：
    switch(表达式)
    {
          case 取值1:
               执行语句；
               break；
          case 取值2:
               执行语句；
               break；
          …...
          default:
               执行语句；
               break；
    }

    switch语句特点：
    1、switch语句选择的类型只有四种：byte，short，int，char。
    2、case与default没有顺序。先执行第一个case，没有匹配的case执行default。
    3、结束switch语句的两种情况：①遇到break，②执行到switch语句结束。
    4、如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
    5、进入switch语句后，执行顺序是先执行case，然后从上到下，最后再执行default。即使default放在case上面，执行顺序也不变。

    示例1：
  1. class SwitchDemo
  2. {
  3.        public static void main(String[] args){
  4.              int x= 3;
  5.              switch(x)
  6.             {
  7.                    default:
  8.                         System.out.println("d" );
  9.                         break;
  10.                    case 4:
  11.                         System.out.println("a" );
  12.                         break;
  13.                    case 2:
  14.                         System.out.println("b" );
  15.                         break;
  16.                    case 3:
  17.                         System.out.println("c" );
  18.                         break;
  19.             }
  20.       }
  21. }
复制代码
   运行结果：

 

    示例2：
  1. class SwitchDemo
  2. {
  3.        public static void main(String[] args){
  4.              int a = 4,b = 2;
  5.              char opr = '-' ;

  7.              switch(opr)
  8.              {
  9.                    case '+' :
  10.                         System.out.println(a+b);
  11.                         break;
  12.                    case '-' :
  13.                         System.out.println(a-b);
  14.                         break;
  15.                    case '*' :
  16.                         System.out.println(a*b);
  17.                         break;
  18.                    case '/' :
  19.                         System.out.println(a/b);
  20.                         break;
  21.                    default:
  22.                         System.out.println("无法运算，符号不支持" );
  23.                         break;
  24.             }
  25.       }
  26. }
复制代码
   运行结果：


    示例3：部分case和default中没有break语句的情况。
  1. class SwitchDemo
  2. {
  3.        public static void main(String[] args){
  4.              int x= 3;
  5.              switch (x)
  6.             {
  7.                    case 4:
  8.                          System.out.println("a" );
  9.                          break ;
  10.                    case 2:
  11.                         System.out.println("b" );
  12.                    case 3:
  13.                         System.out.println("c" );
  14.                    default :
  15.                         System.out.println("d" );
  16.             }
  17.       }
  18. }
复制代码
    运行结果：

    

    示例4：
  1. class SwitchDemo
  2. {
  3.        public static void main(String[] args){
  4.             /*
  5.             用户输入的数据对应的星期。
  6.             */
  7.             int week = 4;
  8.             switch(week)
  9.             {
  10.                   case 1:
  11.                         System.out.println(week + "对应的是星期一" );
  12.                         break;
  13.                   case 2:
  14.                         System.out.println(week + "对应的是星期二" );
  15.                         break;
  16.                   case 3:
  17.                         System.out.println(week + "对应的是星期三" );
  18.                         break;
  19.                   case 4:
  20.                         System.out.println(week + "对应的是星期四" );
  21.                         break;
  22.                   case 5:
  23.                         System.out.println(week + "对应的是星期五" );
  24.                         break;
  25.                   case 6:
  26.                         System.out.println(week + "对应的是星期六" );
  27.                         break;
  28.                   case 7:
  29.                         System.out.println(week + "对应的是星期日" );
  30.                         break;
  31.                   default:
  32.                         System.out.println(week + "没有对应的星期" );
  33.                         break;
  34.             }
  35.       }
  36. }
复制代码
   运行结果：


    示例5：多个case同一种处理方式的情况。
  1. class SwitchDemo
  2. {
  3.        public static void main(String[] args){
  4.             int month = 3;

  6.             switch(month){
  7.                  case 3:
  8.                  case 4:
  9.                  case 5:
  10.                       System.out.println(month + "月对应的是春季" );
  11.                       break;
  12.                  case 6:
  13.                  case 7:
  14.                  case 8:
  15.                       System.out.println(month + "月对应的是夏季" );
  16.                       break;
  17.                  case 9:
  18.                  case 10:
  19.                  case 11:
  20.                       System.out.println(month + "月对应的是秋季" );
  21.                       break;
  22.                  case 12:
  23.                  case 1:
  24.                  case 2:
  25.                       System.out.println(month + "月对应的是冬季" );
  26.                       break;
  27.                  default:
  28.                       System.out.println(month + "没有对应的季节" );
  29.                       break;
  30.            }
  31.       }
  32. }
复制代码
   运行结果：


    if和switch语句的应用：

    if：
    1. 对具体的值进行判断。
    2. 对区间判断。
    3. 对运算结果是boolean类型的表达式进行判断。

    switch：
    1. 对具体的值进行判断。
    2. 值的个数通常是固定的。

    对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存，效率相对高。

2.3 循环结构


    关键词：while,do while,for。

    while语句格式：

    while( 条件表达式 )
    {
          执行语句；
    }

    示例：
  1. class  WhileDemo
  2. {
  3.         public static void main(String[] args) 
  4.         {
  5.                 int x = 1;
  6.                 while(x<3)
  7.                 {
  8.                         System.out.println("x="+x);
  9.                         x++;
  10.                 }
  11.         }
  12. }
复制代码
   运行结果：


    P.S.
   一定要注意不要写while(x < 3);这样的语句，后面的分号就是循环体，代表不执行任何语句，这个循环就成了一个死循环。

    do while语句格式：

    do
    {
         执行语句；
    }while( 条件表达式 );

    示例：
  1. class DoWhileDemo
  2. {
  3.        public static void main(String[] args){
  4.          int x = 1;
  5.          do{
  6.             System.out.println("x = " + x);
  7.             x++;
  8.          }
  9.          while(x < 3);
  10.       }
  11. }
复制代码
   运行结果：


    while和do while的区别：
    do while语句的特点：无论条件是否满足，循环体至少执行一次。
    while如果条件不满足，循环体一次都不会执行。

    练习1：获取1到10,10个数字的和。
  1. class WhileDemo
  2. {
  3.     public static void main(String[] args){
  4.       int x = 1;//记录参与加法的数据。
  5.       int sum = 0;//记录住每一次的和

  7.       while(x <= 10){
  8.          sum += x;
  9.          x++;
  10.       }
  11.       System.out.println("sum = " + sum);
  12.    }
  13. }
复制代码
   运行结果：

 

   练习2：1~100之间，6的倍数出现的次数。
  1. class WhileDemo
  2. {
  3.        public static void main(String[] args){
  4.          int x = 1;
  5.          int count = 0;

  7.          while(x <= 100)
  8.          {
  9.              if(x % 6 == 0){
  10.                   count++;
  11.              }
  12.              x++;
  13.          }
  14.          System.out.println("count = " + count);
  15.       }
  16. }
复制代码
   运行结果：


    for语句格式：

    for(初始化表达式；循环条件表达式；循环后的操作表达式)
    {
         执行语句；(循环体)
    }

    for里面的三个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

    示例：
  1. class ForDemo
  2. {
  3.        public static void main(String[] args){
  4.          for(int x = 0; x < 3; x++){
  5.               System.out.println("x = " + x);
  6.          }
  7.   }
复制代码
   运行结果：


    P.S.
    for循环的初始化表达式、循环后的操作表达式可以是多个表达式，通过逗号分隔。

    例如：
    for(int a = 1,b =2; a < 2 & b < 3; a++,b++){

    }

    练习1：
  1. class ForDemo
  2. {
  3.      public static void main(String[]args)
  4.      {
  5.           int x=1;
  6.           for(System.out.println("a");x<3;System.out.println("c"))
  7.           {
  8.                System.out.println("d");
  9.                x++;
  10.           }
  11.      }
  12. }
复制代码
    运行结果：

    1、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
    
    下面通过两个例子对比：

    示例1：
  1. class whileDemo
  2. {
  3.     public static void main(String[] args){
  4.         //打印1~10十个数字
  5.         int x = 1;
  6.         while(x <= 10)
  7.         {
  8.            System.out.println("x = " + x++);
  9.         }
  10.     }
  11. }
复制代码
    运行结果：


    示例2：
  1. class ForDemo
  2. {
  3.     public static void main(String[] args){
  4.         for(int y = 1; y < 10; y++){
  5.             System.out.println("y = " + y);
  6.         }
  7.         System.out.println("y = " + y);
  8.     }
  9. }
复制代码
   运行结果：


    2、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
    3、在使用循环时候，一定要明确哪些语句需要参与循环，哪些不需要。循环通常情况下，需要定义条件，需要控制次数。

0 0
淘宝可靠的日本代购 淘宝可靠的日本代购
原创粉丝点击
热门IT博客
华为交换机进入端口华为交换机进入端口
pc正常手机收不到jsonpc正常手机收不到json
淘宝e店宝
数据之美 邱南森 pdf
qq三国js怎么搭配灵魄
python自动化测试原理
python经典入门书籍
随机数生成算法原理
怎样用vba编写软件
中国软件
新速特软件站爱奇艺
linux应用开发前景
linux服务器网络配置
树莓派tensorflow
python视频百度云
工商管理 知乎
java异步同步
巴斯斯巴大学知乎
淘宝优惠券网站起名
json static.lib
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 先天性散光 隐形眼镜散光 眼睛散光的症状 散光是什么意思 眼镜散光 散光轴位自测图 为什么会散光 远视散光 眼睛闪光是怎么造成的 手机测散光度数测试图 眼睛散光 散光度数多少算高 散光症状 散光的危害 散光是什么 散光图片 不规则散光 散光什么意思 散光的原因 眼镜闪光是什么意思 散光可以戴隐形眼镜吗 眼睛为什么会散光 近视散光 儿童散光会自愈吗 散光测试 眼睛散光是怎么造成的 散光隐形眼镜 散光的表现 斜轴散光 散光125度严重吗 散光180度严重吗 散光一百多度严重吗 散光怎么造成的 幼儿眼睛散光怎么办 小孩子眼睛散光是怎么回事 散光严重 散光175度严重吗 小孩散光怎么办 六个月宝宝眼睛散光 散光严重吗 散光眼症状

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里