黑马程序员技术交流社区

标题: 一种选择 一份坚守! [打印本页]

作者: 陈泰延    时间: 2012-12-23 23:03
标题: 一种选择 一份坚守!
  1. class WhileDemo
  2. {
  3.         public static void main(String[] args)
  4.         {

  5.                 /*
  6.                 定义初始化表达式;
  7.                 while(条件表达式)
  8.                 {
  9.                                 循环体(执行语句)‘               
  10.                 }
  11.        
  12.                 int x = 1;
  13.                 while(x<=10)
  14.                 {
  15.        
  16.                 System.out.println("x="+x);//x=1,x=1
  17.                 x++;
  18.                          }*/
  19.             /* int x = 1;
  20.                  do
  21.                  {
  22.                          System.out.println("do : x="+x);
  23.                          x++;
  24.                  }
  25.                  while (x<0);
  26.                  
  27.              int y = 1;
  28.                          while(y<0)
  29.                 {
  30.                      System.out.println("y="+y);
  31.                          y++;
  32.                  }
  33.                  */
  34.        
  35.         /*
  36.         while:先判断条件,只有条件满足才执行循环体。
  37.         do while: 先执行循环体,在判断条件,条件满足,在继续执行循环体。
  38.         简单一句话:do while; 无论条件是否满足,循环体至少执行一次。

  39.        
  40.        
  41.        
  42.        
  43.         */



  44.     /*
  45.         for(初始表达式; 循环条件表达式; 循环后的操作表达式)
  46.         {
  47.                         执行语句
  48.         }
  49.        
  50.         */
  51.         /*for(int x = 0; x<3 ; x++)
  52.                 {
  53.                         System.out.println("x="+x);
  54.         }
  55.                 //System.out.println("x====="+x);

  56.                 int y=0;
  57.                 while(y<3)
  58.                 {
  59.                         System.out.println("y="+y);
  60.                         y++;
  61.                 }
  62.                         System.out.println("y======"+y);
  63.                         */
  64.                         /*
  65.                         1,变量有自己的作用域,对于for来讲; 如果将用于控制循环的增量定义在for语句中。那么该变量只有在for语句内有效。
  66.                         for语句执行完毕。该变量的内存中被释放。
  67.                         2, for和while可以进行互换,如果需要定义循环增量,用for更为合适。

  68.                         总结:
  69.                         什么时候使用循环结构?
  70.                         当要对某些语句执行很多次时,就使用循环结构。
  71.                         */
  72.                         /*int x = 1;
  73.                         for(System.out.println("a"); x<3 ; System.out.println("c"))
  74.                 {
  75.                         System.out.println("d");
  76.                         x++;
  77.                        
  78.                         }
  79.                         //adcdc

  80. */
  81.                         /*
  82.                         无限循环的最简单表达形式。
  83.                         for(;;){}
  84.                         while(true){}
  85.                        
  86.                         */
  87.             /*
  88.                  1.获取1~10的和;并打印。
  89.                  2,1~100之间 7 的倍数的个数,并打印。
  90.                         */
  91.                        
  92.                         //1,定义变量用于存储不断变化的和。
  93.                 /*        int sum = 0;

  94.                         //2,定义变量,记录住不断变化的被加的数。
  95.                         int x = 1;
  96.                         //3,定义循环,重复加法的过程。
  97.                         while(x<=10)
  98.                 {
  99.                         sum = sum + x;
  100.                         x++;
  101.                        
  102.                        
  103.                         }
  104.                         System.out.println("sum="+sum);
  105.                                         */
  106.                         /*
  107.                         循环注意;
  108.                         一定要明确哪些语句需要参与循环,哪些不需要。

  109.                         0+1
  110.                          1+2
  111.                           3+3
  112.                            6+4
  113.                        
  114.                        
  115.                         */

  116. /*
  117.                   int sum = 0;

  118.                                   for(int x=1; x<=10; x++)
  119.                 {
  120.                                   sum     +=x;
  121.                                   
  122.                                   }
  123.                                   System.out.println("for sum = "+sum);

  124. */
  125. /*
  126.          思路:
  127.                  1, 先对1~100进行循环(遍历)通过循环的形式。
  128.                  2, 先遍历的过程中,定义条件,只对7的倍数进行操作。

  129.          步骤:
  130.                  1, 定义循环语句,选择for语句。
  131.                  2, 在循环中定义判断,只要是7的倍数即可,使用if语句,条件: 7的倍数  x%7==0;
  132.              3,  定义变量, 该变量随着7的倍数的出现而自增。
  133.   */      

  134.          /*    int  count = 0;
  135.          for(int x=1; x<=100; x++)
  136.                 {
  137.                  if(x%7==0)
  138.                          //System.out.println("x="+x);
  139.                  count++;
  140.                  
  141.                  }
  142.          System.out.println("count="+count);
  143. */
  144. /*
  145.       其实这就是累加思想。
  146.           原理:通过变量记录住循环操作后的结果。
  147.           通过循环的形式,进行累加的动作。



  148. */

  149. /*
  150. 计数器思想。
  151. 通过一个变量记录住数据的状态变化。
  152. 也许通过循环完成。

  153. */

  154. /*
  155. 语句嵌套形式,其实就是语句中还有语句。
  156. 循环嵌套。
  157. */
  158. /*                for(int x=0; x<3; x++)
  159.                 {
  160.                 for(int y=0; y<4; y++)
  161.                         {
  162.                 System.out.print("*");
  163.                 }
  164. System.out.println();//只有一个功能就是换行。
  165.                 }
  166. */
  167. /*


  168. ****
  169. ****
  170. ****
  171. 对于打印长方形;外循环控制的行数。内循环控制的是每一行的列数。也就是一行中元素的个数


  172. *****
  173. ****
  174. ***
  175. **
  176. *
  177. */
  178. //int z = 5;
  179. /*for(int x=0; x<5 ;x++)//x<5:因为外循环控制行数,一共5行、
  180.                 {
  181.                 for(int y=x; y<5;y++)
  182.                         {
  183.                         System.out.print("*");

  184.                 }
  185.                 System.out.println();
  186.                 //z++;
  187.                
  188.                
  189.                 }


  190.                 不是规律的规律;
  191.          尖朝上,可以改变条件,让条件随着 循环变化。
  192.                  尖朝下,可以初始化值,让初始化随着外循环变化。

  193. */












  194.         }
  195. }
复制代码
又是一天的小奋斗,可远方的路还很长,但我还需要脚踏实。我要成为黑马中脚踏实地的那匹黑马!
作者: 谢辉林    时间: 2012-12-24 00:43
{:soso_e100:}加油
作者: 陈泰延    时间: 2013-1-8 06:37
O(∩_∩)O谢谢




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2