程序流程控制

  1. 流程控制语句结构：
  2. 、顺序结构
  3.     语句的关系是从上到下依次执行的顺序关系，中间没有任何判断和跳转；
  4.     它是最基本的结构，Java程序总体来说都是从main()依次执行
  5. 、分支结构； 根据条件，选择性地执行某段代码，有if--else 和switch两种分支语句。
  6. 、循环结构；根据循环条件，重复性地执行某段代码，有while、do--while、for三种循环语句。jdk1.5提供了foreach循环，方便的遍历集合、数组元素。
  7.

1、顺序结构

  1. 键盘输入程序的步骤：
  2. 1、先准备键盘输入的工具类的对象 --》比喻成准备键盘
  3.     java.util.Scanner input = new java.util.Scanner(System.in);
  4.  
  5. 第一：Scanner是首字母是大写
  6. 第二：System也是首字母大写
  7. 第三：左右两边一样java.util.Scanner
  8. 第四：其他照抄，input可以自己命名，代表了键盘输入工具
  9.  
  10. 2、提示输入
  11. System.out.println(xxx);
  12.  
  13. 3、输入
  14. 输入字符串：input.next();
  15. 输入整数： input.nextInt();
  16.          input.nextLong();
  17. 输入小数：input.nextFloat();
  18.          input.nextDouble();
  19. 输入布尔：input.nextBoolean()
  20.  
  21. 输入一个字符：input.nextChar();错误的
  22.             input.next().charAt(0);
  23.  
  24. */
  25. class TestInput{
  26.     public static void main(String[] args){
  27.         //从键盘输入姓名和年龄等
  28.         java.util.Scanner input = new java.util.Scanner(System.in);
  29.  
  30.         System.out.print("请输入姓名：");
  31.         String name = input.next();//从键盘输入一个字符串，保存到name变量中。
  32.  
  33.         System.out.print("请输入年龄：");
  34.         int age = input.nextInt();
  35.  
  36.         System.out.print("请输入体重：");
  37.         double weight = input.nextDouble();
  38.  
  39.         System.out.print("请输入是否已婚(true/false)：");
  40.         boolean isMarry = input.nextBoolean();
  41.  
  42.         System.out.print("请输入性别：");
  43.         char gender = input.next().charAt(0);
  44.  
  45.         System.out.println("姓名：" + name);
  46.         System.out.println("性别：" + gender);
  47.         System.out.println("年龄：" + age);
  48.         System.out.println("体重：" + weight);
  49.         System.out.println("是否已婚：" + (isMarry?"是":"否")); 
  50.  
  51.     }
  52. }

2 、分支结构

switch穿透， 没加break就穿透了

  1. 1）条件判断：if..else  （有单分支条件判断、双分支条件判断、多分支条件判断、嵌套。）
  2. 2）选择结构：switch..case
  4. （一）条件判断系列（if语句3种格式：单、双、多）
  5. 1、单分支条件判断；　　只有一个选项，要么成立就做，要么不成立什么也不干。
  6. 语法结构：
  7.     if(条件表达式){
  8.         当条件表达式成立时，需要执行的语句块;
  9.     }
  10.  
  11. 说明：
  12. （1）if(条件表达式)中的条件表达式的结果必须是boolean值，即要么是true要么是false
  13. （2）{}中是语句块，意思就是可以是一句或多句
  14. （3）{}中的语句块只有一条语句时，这个{}是可以省略的，但是不建议大家省略。
  15.  
  16. 执行的特点：
  17.     if()条件成立就执行{}中的语句块，不成立就不执行。
  19. 2、双分支条件判断 ；（二选一）
  20. 语法结构：
  21.     if(条件表达式){
  22.         当条件表达式成立时，执行的语句块1；
  23.     }else{
  24.         当条件表达式不成立时，执行的语句块2；
  25.     }
  26.  
  27. 说明：
  28. （1）if(条件表达式)中的条件表达式的结果必须是boolean值，即要么是true要么是false
  29. （2）{}中是语句块，意思就是可以是一句或多句
  30. （3）{}中的语句块只有一条语句时，这个{}是可以省略的，但是不建议大家省略。
  31.  
  32. 执行特点：
  33.         双分支结构，一定会执行其中的一个分支，即二选一执行。
  34.         当条件表达式成立时，执行的语句块1；不成立，就执行语句块2；
  35.  
  36.         if(num%2==0){
  37.             System.out.println(num + "是偶数");
  38.             System.out.println(num + "是双数");
  39.         }else{
  40.             System.out.println(num + "是奇数");
  41.         }
  42.  
  43.         /*
  44.         //两个单分支; 条件满足可以同时走两个if条件语句。 注意注意注意与if..elseif..else的区别，条件成立只能选择走一个；而多个单分支if语句可以执行多个。  
  45.         if(num%2==0){  //条件成立就执行。
  46.             System.out.println(num + "是能被2整除");
  47.             System.out.println(num + "是双数");
  48.         }
  49.         if(num%4==0){  //条件成立就执行，例如num为4，两个if条件句都会执行。
  50.             System.out.println(num + "是能被4整除");
  51.             System.out.println(num + "也是偶数");
  52.         }
  53.         */
  54. 3、多分支条件判断：多选一
  55. 语法结构：
  56.     if(条件表达式1){
  57.         当条件表达式1成立时，执行的语句块1；
  58.     }else if(条件表达式2){
  59.         当条件表达式1不成立时，而条件表达式2成立，执行的语句块2；
  60.     }else if(条件表达式3){
  61.         当条件表达式1和2都不成立时，而条件表达式3成立，执行的语句块3；
  62.     }....
  63.     else{
  64.         当以上所有条件都不成立时，执行语句块n+1；
  65.     }
  66.  
  67. 说明：
  68. （1）if(条件表达式)中的条件表达式的结果必须是boolean值，即要么是true要么是false
  69. （2）{}中是语句块，意思就是可以是一句或多句
  70. （3）{}中的语句块只有一条语句时，这个{}是可以省略的，但是不建议大家省略。
  71. （4）如果多个条件之间的关系是“互斥”关系，它的顺序是随意的；
  72.                        是“包含”关系，它的顺序有要求，范围小的在上，范围大的在下；
  73.  
  74. 执行的特点：
  75.         从上往下依次判断条件，如果有一个条件成立了，后面的条件都不看了；
  76.         如果最后有单独的else，那么以上条件都不成立，就执行最后else中的；
  77.         如果最后没有单独的else，那么以上条件都不成立时，就什么也不执行。也可以没有else。
  78.         多个分支中最多执行一个。
  79. /*
  80.         if(score==100){
  81.             System.out.println("满分");
  82.         }else if(score>=80 && score<=99){
  83.             System.out.println("优秀");
  84.         }else if(score>=70 && score<80){
  85.             System.out.println("良好");
  86.         }else if(score>=60 && score<70){
  87.             System.out.println("及格");
  88.         }else{
  89.             System.out.println("不及格");
  90.         }
  91.         */
  92.         if(score==100){
  93.             System.out.println("满分");
  94.         }else if(score>=80){
  95.             System.out.println("优秀");
  96.         }else if(score>=70){
  97.             System.out.println("良好");
  98.         }else if(score>=60){
  99.             System.out.println("及格");
  100.         }else{
  101.             System.out.println("不及格");
  102.         }
  103. 4、嵌套：
  104.     当外层情况满足了，才会判断嵌套在里面的条件。
  105.  
  106. 前提条件是[0,100]
  107.         //如果是100分，显示满分
  108.         //如果是[80-99]，显示优秀
  109.         //如果是[70,80)，显示良好
  110.         //如果是[60,70)，显示及格
  111.         //其他的显示不及格
  112. 如果成绩不再[0,100]，提示它输入错误
  113. /*
  114.         if(score>=0 && score<=100){
  115.             if(score==100){
  116.                 System.out.println("满分");
  117.             }else if(score>=80){
  118.                 System.out.println("优秀");
  119.             }else if(score>=70){
  120.                 System.out.println("良好");
  121.             }else if(score>=60){
  122.                 System.out.println("及格");
  123.             }else{
  124.                 System.out.println("不及格");
  125.             }
  126.         }else{
  127.             System.out.println("成绩的范围是：[0,100]");
  128.         }
  129.         */
  130.  
  131.         if(score<0 || score>100){
  132.             System.out.println("成绩的范围是：[0,100]");
  133.         }else{
  134.             if(score==100){
  135.                 System.out.println("满分");
  136.             }else if(score>=80){
  137.                 System.out.println("优秀");
  138.             }else if(score>=70){
  139.                 System.out.println("良好");
  140.             }else if(score>=60){
  141.                 System.out.println("及格");
  142.             }else{
  143.                 System.out.println("不及格");
  144.             }
  145.         }

  147. （二）选择结构 （ switch()  case :    default: ）
  148. 语法格式：
  149.     switch(表达式){
  150.         case 常量值1:
  151.             语句块1;
  152.             break;
  153.         case 常量值2:
  154.              语句块2;
  155.              break;
  156.         case 常量值3:
  157.             语句块3;
  158.             break;
  159.         default:
  160.             语句块n+1;
  161.             break;
  162.     }
  163.  
  164. 说明：
  165.     （1）case后面必须是常量值；
  166.     （2）case后面的常量值不能重复
  167.     （3）switch(表达式)中表达式的结果的类型有要求：
  168.             四种基本数据类型：byte,short,int,char
  169.             两种引用数据类型：JDK1.5之后开始支持枚举类型，JDK1.7之后开始支持String类型
  170.  
  171. 执行过程：
  172. （1）入口
  173.     A：当switch(表达式)中表达式的值与某一个case后面的常量值“匹配”，就从这个case进入；
  174.     B：如果存在default，那么当所有的case都无法匹配时，从default进入；
  175. （2）出口
  176.     A：自然出口：switch的结束}
  177.     B：中断出口：break;
  178.  
  179. 一定找到“入口”，就会一直往下运行，直到遇到“出口”
  180.  
  181. 可以用switch..case，一定可以用if..else实现，
  182. 但是有的时候，用switch...case效率更好，可读性更好    
  183.  
  184. 当条件判断是常量==比较时，可以改用switch..case

3、循环结构：当程序需要“重复”执行某些代码

  1. （1）for
  2. （2）while
  3. （3）do...while
  4. （4）增强for循环：用于类似于数组、集合等这种容器迭代，遍历用
  5. （一）for循环
  6. 语法结构：
  7. 1、基本结构
  8. for(;;){
  9. 循环体语句块;//（就是需要重复执行的代码）
  10. 　　}
  11. 如果没有加条件，这个就是无限循环，或者说死循环。
  12.  
  13. 2、完整结构
  14. for(初始化表达式; 循环条件表达式; 迭代表达式){
  15. 循环体语句块;（就是需要重复执行的代码）
  16. }
  17. 说明;
  18. for循环一般需要一个循环变量，通过控制变量的值，来控制循环的次数。
  19.  
  20. 初始化表达式：一般用于声明循环变量并赋初始值，每一轮，初始化表达式执行一次。
  21. 循环条件表达式：控制什么时候结束；
  22. 迭代表达式：修改循环变量的值。
  23.  
  24. 3、执行的过程
  25. （1）先执行“初始化表达式”
  26. （2）判断“循环条件表达式”，
  27. （3）如果条件成立 ，就执行“循环体语句块”，然后再执行“迭代表达式”，接着回到（2）
  28. （4）如果条件不成立，结束for
  29.  
  30. （二）while循环
  31. 语法结构：
  32.     while(循环条件){
  33.         循环体语句块;
  34.     }
  35. 执行过程：
  36. （1）先判断循环条件
  37. （2）如果条件成立，执行循环体语句块，然后回到（1）
  38. （3）如果条件不成立，结束while循环    
  39.  
  40. 总结：
  41. （1）可以用for，也可以用while，因为他们都是表示“重复”执行某些代码
  42. （2）for循环更加适合于，循环次数比较明显的；
  43.      while循环更加适合于，循环条件比较明显，次数不是很在意
  44.  
  45. 例如：求2的n次方，n在[0,10]范围内整数
  46. for(int i=0; i<=10; i++){
  47.  
  48. }
  49.  
  50. while循环的经典的结构：
  51. while(true){
  52.     ....
  53.     if(条件){
  54.         break;
  55.     }
  56.     ....
  57. }
  58.  
  59. （三）do...while
  60. 语法结构：
  61. do{
  62. 循环体语句块;
  63. }while(循环条件);
  64.  
  65. 执行过程：
  66. （1）先do（干）一次循环体语句块
  67. （2）再判断循环条件
  68. （3）如果条件成立，在（1）
  69. （4）如果条件不成立，结束do..while
  70.  
  71. do..while和for,while的最大不同，就是它的循环体语句块，至少可以执行一次。
  72. 而for,while循环的循环体语句可能一次都不执行。
  73.  
  74. TestDoWhile.java:41: 错误: 找不到符号
  75. (1)是否写错单词
  76. (2)没有声明
  77. (3)不在作用域范围内
  78.  
  79. （四）循环嵌套： 
  80. 内层循环作为外层循环的循环体的一部分；   外层循环循环一次，内层循环循环一轮；
  81.  
  82. 打印：
  83. *
  84. **
  85. ***
  86.  
  87. 重复的代码：1）打印* ；   2）打印很多行*，每一行都有n个*
  88.  
  89. //1、求1-100的和
  90. //循环：为了重复执行某些代码
  91. //(1)重复执行xx代码；  2)重复执行几次；  3)如何控制次数，循环变量怎么修改，条件是什么
  92. /*
  93. (1)重复执行xx代码
  94. 累加一个数
  95. 0 + 1 + 2 + 3 + 4 + ... + 100
  96. (2)重复执行100次
  97. (3)int i = 1; i<=100; i++
  98. */
  99.  
  100. 从键盘输入整数，输入0结束，统计输入的正数、负数的个数。
  101. (1)哪些是需要重复的代码：键盘输入； 判断是正、负、0
  102. (2)次数不明显，条件是否明显，不是0就继续，是0就结束，
  103. 选择while
  104.  
  105. 这里需要几个变量？
  106. (1)变量1：存储输入的数
  107. (2)变量2：存储正数的个数
  108. (3)变量3：存储负数的个数
  1. break：
  2. 1、用于switch，表示结束switch结构
  3. 2、用于循环（for,while,do...while），表示结束当层循环
  4.  
  5. continue：
  6. 只能用于循环结构
  7. 表示提取结束本次循环或者说，跳过本次剩下的循环体语句
  8.  
  9. 补充：了解（在开发中，源代码中没见到过，但是在教科书看到过）
  10. break和continue可以配合标签使用
  11.  
  12. 学习的步骤：
  13. （1）先记循环结构的语法结构
  14. （2）再记它的执行的过程
  15. （3）阅读别人的代码，分析结果
  16. （4）自己灵活应用
  1. /*
  2. 1.格式：三种
  3. 2.执行if-else语句时,一定会选择其中的一个路径执行，而且仅选择一条路径。
  4. */
  5. class TestIf1 {
  6.     public static void main(String[] args) {
  7.         int age = 28;
  8.  
  9.         if (age > 18){
  10.             System.out.println("");
  11.         }else{
  12.             System.out.println("");
  13.  
  14.         if (age > 130 || age < 0){
  15.             System.out.println("");
  16.         }else if(age < 30){
  17.             System.out.println("");
  18.         }else{
  19.             System.out.println("");
  20.         }
  21.  
  22.         if(age < 30){
  23.         }else if(age < 60){
  24.         }else if(age < 100){
  25.         }else{
  26.         }
  27.  
  28.     }
  29. }
  1. //1.导包
  2. import java.util.Scanner;
  3. class TestScanner{
  4.     public static void main(String[] args) {
  5.         //2.创建一个Scanner类的对象
  6.         Scanner s = new Scanner(System.in);
  7.         System.out.println("请输入一个字符串:");
  8.         //3.调用此对象的相应的方法,完成键盘输入的值的获取
  9.         //next():表示从键盘获取一个字符串
  10.         String str = s.next();
  11.  
  12.         System.out.println(str);
  13.  
  14.     }
  15. }
  1. /*
  2. 从键盘输入小明的期末成绩；
  3. 当成绩为100分时，奖励一辆BMW；
  4. 当成绩为(80, 90)时，奖励一个iphone8;
  5. 当成绩为[60,80)时，奖励一本参考书;
  6. 其他，什么也没有。
  7. 1.条件判断之间可以嵌套；
  8. 2.如果多个条件之间是互斥关系，多个条件语句上下顺序是自由的。
  9.   如果多个条件之间存在包含关系，要求范围小的写在范围大的上面。
  10. */
  11. import java.util.Scanner;
  12. class TestIf2{
  13.     public static void main(String[] args) {
  14.         Scanner s = new Scanner(System.in);
  15.         System.out.println("请输入小明的成绩：（分）");
  16.         int score = s.nextInt();
  17.  
  18.         if (score >100 || score < 0){
  19.             System.out.println("你输入的数值有误!");
  20.         }else{
  21.             if(score == 100){
  22.                 System.out.println("奖励一辆BMW");
  23.             }else if(score > 80){ //(score > 80 && score <=99)
  24.                 System.out.println("奖励一个iphone8");
  25.             }else if(score >= 60){ //(score >= 60 && score <=80) //范围大的写下边哦
  26.                 System.out.println("奖励一本书");
  27.             }else{
  28.                 System.out.println("上面也没有");
  29.             }
  30.         }
  31.  
  32.     }
  33. }
  1. /*
  2. switch(变量){
  3.     case 值1;
  4.     case 值2;
  5.     case 值3;
  6.     default:
  7.     }
  8. 1.根据变量的值，选择相应的case去判断，一旦满足条件，就执行case的相应语句；如果没有break或者已经
  9. 结尾的话，会继续执行其下的case语句。
  10. 2.default：是可选的，而且位置是灵活的。
  11. 3.变量可以是哪些类型？char byte short int 枚举 String(jdk1.7)
  12. 4.case条件:其中条件只能是值，不能是取值范围
  13. */
  14.  
  15. class TestSwitch1 {
  16.     public static void main(String[] args) {
  17.         int i = 5;
  18.         switch(i){
  19.             case 0:
  20.                 System.out.println("zero");
  21.                 break;
  22.             case 1:
  23.                 System.out.println("one");
  24.                 break;
  25.             case 2:
  26.                 System.out.println("two");
  27.                 break;
  28.             case 3:
  29.                 System.out.println("three");
  30.                 break;
  31.             default:
  32.                 System.out.println("other");
  33.                 break;
  34.         }
  35.     }
  36. }

switch-case与if--else之间可以互换

  1. /*
  2. 对学生成绩大于60的,输出"合格"；低于60分的输出"不及格";
  3. 说明：
  4. 1.当多个case语句处理的语句块一致时,可以统一来写；
  5. 2.一定情况下switch-case与if-else之间可以互相转换。
  6. */
  7. class TestSwitch3{
  8.     public static void main(String[] args) {
  9.         int score = 67;
  10.         if (score >= 60){
  11.             System.out.println("及格");
  12.         }else{
  13.             System.out.println("不及格");
  14.         }
  15.  
  16.         /*
  17.         switch(score){
  18.             case 100:
  19.             ...
  20.             case 0:
  21.             default:
  22.         }
  23.         */
  24.         switch(score / 10){
  25.             case 10:
  26.             case 9:
  27.             case 8:
  28.             case 7:
  29.             case 6:
  30.                 System.put.println("及格");
  31.                 break;
  32.             case 5:
  33.             case 4:
  34.             case 3:
  35.             case 2:
  36.             case 1:
  37.             case 0:
  38.                 System.out.println("不及格");
  39.                 break;
  40.             default:
  41.                 System.out.println("输入有误");
  42.                 break;
  43.  
  44.     }
  45. }
  1. /*
  2. 编写程序：从键盘上输入2014年的"month"和"day"，要求通过程序输入输出的日期为2014年的第几天
  3. */
  4. import java.util.Scanner;
  5.  
  6. class TestSwitch4 {
  7.     public static void main(String[] args) {
  8.         Scanner s = new Scanner(System.in);
  9.         System.out.println("请输入月份:");
  10.         int month = s.nextInt();
  11.         System.out.println("请输入日期:");
  12.         int day = s.nextInt();
  13.  
  14.         int sum = 0;//用来记录month月day日是2014年第几天
  15.         //使用switch-case
  16.         switch(month){
  17.             case 12:
  18.                 sum += 30;//30天,十一月的总天数
  19.             case 11:
  20.                 sum += 31;
  21.             case 10:
  22.                 sum += 30;
  23.             case 9:
  24.                 sum += 31;
  25.             case 8:
  26.                 sum += 31;
  27.             case 7:
  28.                 sum += 30;
  29.             case 6:
  30.                 sum += 31;
  31.             case 5:
  32.                 sum += 30;
  33.             case 4:
  34.                 sum += 31;
  35.             case 3:
  36.                 sum += 28;
  37.             case 2:
  38.                 sum += 31;//31,是一月份的天数
  39.             case 1:
  40.                 sum += day; //最后再加上你输入的当月的天数
  41.             }
  42.             System.out.println(sum);
  43.     }
  44. }
  1. /*
  2. for循环结构:
  3. 1.格式：①初始化条件；②循环条件；③迭代条件；④循环体；
  4.         for(①;②;③){
  5.             //④
  6.         }
  7. 2.执行过程：①-②-④-③-②-④-③-     -④-③-②
  8.     即直至循环条件不满足，退出循环体
  9. */
  10. class TestFor {
  11.     public static void main(String[] args) {
  12.         for (int i = 0;i < 4 ;i++ ){
  13.             System.out.println("Hello World!");
  14.         }
  15.         int j = 1;
  16.         for (System.out.print('a'); j < 3 ;System.out.print('b'), j++ ){
  17.             System.out.print('c');
  18.         }
  19.         //acbcb
  20.  
  21.     //题目:输出100以内的所有偶数及所有偶数的和及偶数的个数
  22.     int sum = 0;
  23.     int count = 0;
  24.     for (int i = 1;i<= 100 ;i++ ){ //100以内的自然数的遍历
  25.         if(i % 2 == 0){
  26.             System.out.println(i);
  27.             sum += i;
  28.             count++;
  29.         }
  30.     }
  31.     System.out.println("总和为:" + sum);
  32.     System.out.println("100以内偶数的个数为:" + count);
  33.  
  34.     }
  35. }
  1. /*
  2.  
  3. ①初始化条件；
  4. ②循环条件；
  5. ③迭代条件；
  6. ④循环体；
  7. 1.格式：
  8. ①
  9. while(②){
  10.     ④
  11.     ③
  12. }
  13.  
  14. */
  15. class TestWhile{
  16.     public static void main(String[] args) {
  17.         //100以内的偶数的输出及其和
  18.         int i = 1;
  19.         int sum = 0;
  20.         while(i <= 100){
  21.             if(i % 2 == 0){
  22.                 System.out.println(i);
  23.                 sum += i;
  24.             }
  25.             i++;
  26.         }
  27.         System.out.println(sum);
  28.  
  29.     }
  30. }
  1. /*
  2. 1.格式:
  3. ①
  4. do{
  5.     ④
  6.     ③
  7. }while(②);
  8.  
  9. 2.do-while与while的区别,do-while循环至少执行一次
  10.  
  11. */
  12. class TestDowhile {
  13.     public static void main(String[] args) {
  14.         int i = 1;
  15.         do{
  16.             if(i % 2 == 0){
  17.                 System.out.println(i);
  18.             }
  19.             i++;
  20.         }while(i <= 100);
  21.  
  22.         //do-while 和 while的区别
  23.         int j = 10;
  24.         do{
  25.             System.out.println(j);
  26.             j++;
  27.         }while(j < 10);
  28.  
  29.         while(j < 10){
  30.             System.out.println(j);
  31.             j++;
  32.         }
  33.  
  34.     }
  35. }

do-while与while的区别,do-while循环至少执行一次

  1. class TestForFor {
  2.     public static void main(String[] args) {
  3.         /*
  4.         *****
  5.         *****
  6.         *****
  7.         *****
  8.  
  9.         */
  10.         for(int j = 0;j < 4;j++){      //外层循环控制行数
  11.             for(int i = 0;i < 5;i++){  //内层循环控制列数
  12.                 System.out.print("*");
  13.             }
  14.             System.out.println();
  15.         }
  16.         /*
  17.         *
  18.         **
  19.         ***
  20.         ****
  21.         */
  22.         for (int j = 0;j < 4 ; j++){      //外层循环控制行数
  23.             for(int i = 0;i < j + 1;i++){ //内层循环控制列数
  24.                 System.out.print("*");
  25.         }
  26.         System.out.println();
  27.         }
  28.  
  29.         /*
  30.  
  31.         ****
  32.         ***
  33.         **
  34.         *
  35.  
  36.         */
  37.  
  38.         for(int i = 0;i < 5;i++){
  39.             for(int j = 0;j < 5-i;j++){ //for(int j = i;j < 5;j++)
  40.                 System.out.print("*");
  41.             }
  42.             System.out.println();
  43.         }
  44.  
  45.         /*
  46.         *
  47.         **
  48.         ***
  49.         ****
  50.         ****
  51.         ***
  52.         **
  53.         *
  54.  
  55.         */
  56.         for (int j = 0;j < 4 ; j++){      //外层循环控制行数
  57.             for(int i = 0;i < j + 1;i++){ //内层循环控制列数
  58.                 System.out.print("*");
  59.         }
  60.         System.out.println();
  61.         }
  62.         for(int i = 0;i < 5;i++){
  63.             for(int j = 0;j < 5-i;j++){ //for(int j = i;j < 5;j++)
  64.                 System.out.print("*");
  65.             }
  66.             System.out.println();
  67.         }
  68.  
  69. /*
  70. 打印如下图形:
  71. ----*
  72. ---* *
  73. --* * *
  74. -* * * *
  75. * * * * *
  76. i  k-  j*  k = 4 - i    j = i + 1
  77. 0    4    1
  78. 1    3    2
  79. 2    2    3
  80. 3    1    4
  81. 4    0    5
  82.  
  83. -* * * *
  84. --* * *
  85. ---* *
  86. ----*
  87. i  k-  j*  k = i + 1   j = 4-i
  88. 0  1   4
  89. 1  2   3
  90. 2  3   2
  91. 3  4   1
  92.  
  93. */
  94.  
  95.         //上半部分
  96.         for(int i = 0;i < 5;i++){
  97.             for(int k = 0;k < 4 - i;k++){
  98.                 System.out.print("-");
  99.             }
  100.             for(int j = 0;j < i + 1;j++){
  101.                 System.out.print("* ");
  102.             }
  103.             System.out.println();
  104.         }
  105.         //下半部
  106.         for (int i = 0;i < 4;i++){
  107.             for(int k = 0;k < i + 1 ;k++){
  108.                 System.out.print("-");
  109.             }
  110.             for(int j = 0;j < 4-i;j++){
  111.                 System.out.print("* ");
  112.             }
  113.             System.out.println();
  114.         }
  115.  
  116.     }
  117. }
  1. /*
  2. break:使用在switch-case中或者循环中
  3. 如果使用在循环中，表示结束"当前"循环
  4.  
  5. continue:使用在循环结构中
  6. 表示:结束"当次"循环
  7. */
  8.  
  9. class TestBreakContinue {
  10.     public static void main(String[] args) {
  11.         for (int i = 1;i <= 10;i++){
  12.             if (i % 4 == 0){
  13.                 break;
  14.                 //continue;
  15.             }
  16.             System.out.println(i);
  17.         }
  18.  
  19.         label:for (int i =1;i < 5;i++){
  20.             for (int j = 1;j <= 10;j++){
  21.                 if (j % 4 == 0){
  22.                     //break;  //写在哪一层就结束哪一层
  23.                     //continue;
  24.                     //break label;
  25.                     continue label;
  26.                 }
  27.                 System.out.print(j);
  28.             }
  29.             System.out.println();
  30.         }
  31.  
  32.         for (int i = 1;i <= 10;i++){
  33.             if (i % 4 == 0){
  34.                 break;
  35.                 //continue;
  36.                 //在break和continue语句之后不能添加其他语句,永远也不能被执行；
  37.                 //System.out.println('我是执行不了的哦');
  38.             }
  39.             System.out.println(i);
  40.         }
  41.  
  42.     }
  43. }

returen关键字一定要有类型，不能省
return 临时变量 -returen关键字一定要有类型，不能省
return和i++都有临时变量；

JavaSE| 流程控制的更多相关文章

  1. Java 基础入门随笔（4） JavaSE版——程序流程控制

    上一节对于运算符有了大致的了解,这一节针对程序流程控制进行复习!程序流程控制包括顺序结构.判断结构(if).选择结构(switch).循环结构. 1.判断结构 ①if语句的第一种格式:        ...

  2. 【黑马JavaSE】1_1_9_流程控制：顺序结构、判断结构、选择结构、循环结构

    文章目录 1_1_9_01_ 流程控制概述 1_1_9_01_ 顺序结构 1_1_9_ 判断结构 1_1_9_02_ 判断语句1--if 1_1_9_03_ 判断语句2--if...else 1_1_ ...

  3. JavaSE学习笔记03流程控制

    Java流程控制 1.顺序结构 java的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句往下执行. 顺序结构是最简单的算法结构,它是任何一个算法都离不开的一种基本算法结构. 2. 选择结构 ...

  4. JavaSE基础语法学习-流程控制

    流程控制 用户交互Scanner Scanner**对象** 下面是创建 Scanner 对象的基本语法: Scanner s = new Scanner(System.in); 接下来我们演示一个最 ...

  5. 五、JavaSE语言基础之流程控制

    流程控制的简单概念 流程控制:指通过关键字控制代码的执行流程; 一.顺序结构:执行顺序从左到右从上到下; 顺序结构无关键字,一般而言大多数代码都是顺序结构; 二.选择结构:根据条件判断是否执行 选择结 ...

  6. 第4天 JavaDoc生成文档&Java流程控制（第一节：用户交互Scanner）

    JavaDoc生成文档 javadoc命令是用来生成自己的API文档 参数信息: @author 作者名 @version 版本号 @since 指明需要最早使用的jdk版本 @param 参数名 @ ...

  7. 第10章 Shell编程（4）_流程控制

    5. 流程控制 5.1 if语句 (1)格式: 格式1 格式2 多分支if if [ 条件判断式 ];then #程序 else #程序 fi if [ 条件判断式 ] then #程序 else # ...

  8. Shell命令和流程控制

    Shell命令和流程控制 在shell脚本中可以使用三类命令: 1)Unix 命令: 虽然在shell脚本中可以使用任意的unix命令,但是还是由一些相对更常用的命令.这些命令通常是用来进行文件和文字 ...

  9. PHP基础知识之流程控制的替代语法

    PHP 提供了一些流程控制的替代语法,包括 if,while,for,foreach 和 switch. 替代语法的基本形式是把左花括号({)换成冒号(:),把右花括号(})分别换成 endif;,e ...

随机推荐

  1. Golang的单引号、双引号与反引号

    Go语言的字符串类型string在本质上就与其他语言的字符串类型不同: Java的String.C++的std::string以及Python3的str类型都只是定宽字符序列 Go语言的字符串是一个用 ...

  2. centos6.5 有趣但是没有用的linux命令

    小火车 get http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm rpm -ivh epel-rele ...

  3. winform里面打开网页(转)

    首先,新建一个winform项目,我在想,如果想要实现打开网页功能的话,应该会有一个控件什么之类的吧?查了工具栏,真的有一个名叫 WebBrowser的家伙,应该就是这货没错了.在网上查了它的资料更加 ...

  4. Java中关于string的些许问题及解析

    问题一:String 和 StringBuffer 的区别JAVA 平台提供了两个类: String 和 StringBuf fer ,它们可以储存和操作字符串,即包含多个字符的字符数据.这个 Str ...

  5. python 爬虫简化树状图

  6. LeetCode（66）： 加一

    Easy! 题目描述: 给定一个非负整数组成的非空数组,在该数的基础上加一,返回一个新的数组. 最高位数字存放在数组的首位, 数组中每个元素只存储一个数字. 你可以假设除了整数 0 之外,这个整数不会 ...

  7. export default 和 export 区别

    转载:https://www.cnblogs.com/mengfangui/p/9073459.html   1.export与export default均可用于导出常量.函数.文件.模块等2.在一 ...

  8. jsp和

  9. 微信小程序--代码构成---WXML 模板

    WXML 模板 从事过网页编程的人知道,网页编程采用的是 HTML + CSS + JS 这样的组合,其中 HTML 是用来描述当前这个页面的结构,CSS 用来描述页面的样子,JS 通常是用来处理这个 ...

  10. python 在WINDOS虚拟环境部署

    #查看电脑的版本 C:\Users\lys>pip -V pip 8.1.1 from e:\python\python3.5\lib\site-packages (python 3.5) #安 ...