自学JAVA知识点总结 - 初级

控制语句 - 循环结构

while语句

• while循环结构：当类循环，先判断后执行，当符合条件则执行循环，如果不符合条件则跳出循环。循环语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

  // while格式
  while（布尔表达式）{ //当满足条件执行循环
    循环语句;
  }
  
  // 求 1+2+3+4+5...+100 的和，使用暴力算法累加计算
  public class test {
    public static void main（String[] args） {
      int a = 1; //开始的值
      int sum = 0; //sum变量代表和
      while（a<=100） { //判断a<=100是否为true，符合执行循环
        sum = sum+a; //计算和，第一次sum=0+1; 第二次sum=1+2; 第三次sum=3+3.....加到100后求最终和
        a++; //a自增1，用来计数
      }
      System.out.println（sum）;
    }
  }
    
  // 解读循环步骤
      //第一次循环
      while（a<=100） { //此时a=1，符合条件继续循环
        sum = sum+a; //此时sum=0 加上 a=1
        a++;
      }
      // 第二次循环
      while（a<=100） { //此时a=2，符合条件继续循环
        sum = sum+a; //此时sum=1 加上 a=2
        a++; //此时a=2然后自增为3
      }
      //第三次循环
      while（a<=100） { //此时a=3，符合条件继续循环
        sum = sum+a; //此时sum=3 加上 a=3
        a++; //此时a=3然后自增为4
      }
      //第四次循环
      while（a<=100） { //此时a=4，符合条件继续循环
        sum = sum+a; //此时sum=6 加上 a=4
        a++; //此时a=4然后自增为5
      }

• do-while循环结构：当类循环，先执行后判断，先执行一次循环，当符合条件则继续执行循环，如果不符合条件则跳出循环。

  // do-while格式格式
  do{ //先执行一次循环
    循环语句;
  }while（布尔表达式）; //再判断，符合条件则继续循环，否则跳出循环
  
  // 求 1+2+3+4+5...+100 的和，使用暴力算法累加计算
  public class test {
    public static void main（String[] args） {
      int a = 1; //开始的值
      int sum = 0; //sum变量代表和
      do { //先执行一次
        sum += a; //sum = sum+a
        a++;
      } while （a<=100）; //再判断
      System.out.println（sum）;
    }
  }
  

for语句

• for循环结构：for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环，否则终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

  // for循环格式
  for （初始化表达式,初始化表达式2; 布尔表达式; 迭代因子,迭代因子2）{
    循环语句;
  }
   
  // 求 1+2+3+4+5...+100 的和，使用暴力算法累加计算
  public class test {
    public static void main（String[] args） {
      int sum = 0; //sum变量代表和
      // 先执行初始化表达式int a=1；执行后进行判断a<=100；判断后进行循环；循环后迭代因子自增计数
      for（int a=1; a<=100; a++） {
        sum += a; //计算和
      }
      System.out.println（a）; // 报错，for循环中的变量，只能在for循环中使用
      System.out.println（sum）;
    }
  }

嵌套循环

• while、do-while、for嵌套循环：在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层。

  // 输出99乘法表
  public class test {
    public static void main（String[] args） {
      for（int a=1; a<=9; a++） {
        for（int b=1; b<=a; b++） {
          System.out.print（b + "*" + a + "=" + b*a + "\t"）;
      }
      System.out.println（）;
      }
    }
  }
   
  // 解读循环步骤
      // 第一层for，第一次循环
      for（int a=1; a<=9; a++） { //a=1，a<=9符合条件，进行循环
        // 第二层for，第一次循环
        for（int b=1; b<=a; b++） { //b=1，（b=1）<=（a=1）符合条件，进行循环
          System.out.print（b + "*" + a + "=" + b*a + "\t"）; //输出1*1=1+\t制表符
        } //b自增
        // 第二层for，第二次循环
        for（int b=1; b<=a; b++） { //b=2，（b=2）<=（a=1）不符合条件，跳出循环
          System.out.print（b + "*" + a + "=" + b*a + "\t"）; //不执行
        } //跳出循环，b=1
        System.out.println（）; //输出空行
      }
      
      // 第一层for，第二次循环
      for（int a=1; a<=9; a++） { //a=2，a<=9符合条件，进行循环
        // 第二层for，第一次循环
        for（int b=1; b<=a; b++） { //b=1，（b=1）<=（a=2）符合条件，进行循环
          System.out.print（b + "*" + a + "=" + b*a + "\t"）; //输出1*2=2+\t制表符
        } //b自增
        // 第二层for，第二次循环
        for（int b=1; b<=a; b++） { //b=2，（b=2）<=（a=2）符合条件，进行循环
          System.out.print（b + "*" + a + "=" + b*a + "\t"）; //输出2*2=4+\t制表符
        } //b自增
        // 第二层for，第三次循环
        for（int b=1; b<=a; b++） { //b=3，（b=3）<=（a=2）不符合条件，跳出循环
          System.out.print（b + "*" + a + "=" + b*a + "\t"）; //不执行
        } //跳出循环，b=1
        System.out.println（）; //输出空行
      }
  

break和continue语句

• break语句：在任何循环语句的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句。
• continue语句：continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分；在for循环中，跳到for循环的迭代因子部分。

  public class test {
    public static void main（String[] args） {
      int count = 0; //定义计数器
      for （int i = 100; i < 150; i++） {
        // 如果是3的倍数，则跳过本次循环，继续进行下一次循环
        if （i % 3 == 0）{
          continue; //跳过本次循环，继续进行下一次循环
        }
        // 否则（不是3的倍数），输出该数
        System.out.print（i + "\t"）;
        count++; //没输出一个数，计数器加1
        // 根据计数器判断每行是否已经输出了10个数
        if （count % 10 == 0） {
        	break; //输出达到10个数结束循环
        }
      }
    }
  }

• 带标签的break语句：类似goto，强行退出循环，不执行循环中剩余的语句。
• 带标签的continue语句：类似goto，跳过本次循环，跳到指定标签位置。

  public class test {
      public static void main（String args[]） {
          // 打印101-150之间所有的质数
      	outer: for （int i = 101; i < 150; i++） {
              for （int j = 2; j < i / 2; j++） {
                  if （i % j == 0）{
                      continue outer; //跳过本次循环，跳到outer标签位置
                  }
              }
              System.out.print（i + "  "）;
          }
      }
  }