Java:62-78 if-else if、switch-case、do-while、for、break、continue、return

• 顺序结构：
• 分支结构：

1. if
2. if-else
3. if-else if
4. switch-case

   package 第四章;
   
   import java.util.Scanner;
   /*
     1.顺序结构：程序按照既定顺序完成的过程
     2.分支结构：if、if-else、if-else if、switch-case（一般与break联合使用）
     3.switch:(1)switch支持的数据类型：整型（byte、short、int）、字符型（char）
              (2)每个case后面的常量值必须不同
              (3)switch语句格式不受case语句顺序的影响，并且break和default可以省略
              (4)case和default语句顺序先后没有要求
              (5)switch()里类型与case后面的类型必须相同，例：String str = "1";
                 case 1:写法错误 case "1": 才正确，因为此时"1"为字符，case后面必须也写为字符型
              (6)引用数据类型：String字符串、enum枚举【包装类：Byte、Short、Integer、Character】
    */
   public class SwitchCase {
       public static void main(String[] args) {
           //顺序结构、分支结构if、if-else：
           Scanner scan = new Scanner(System.in);  //创建一个具有输入功能的对象 API Scanner
           System.out.println("请输入商品数量：");
           int num = scan.nextInt();
           System.out.println("请输入商品价格：");
           double price = scan.nextDouble();
           double total = num*price; //计算总价
           if(total>=500){  //如果if判断之后要执行的代码只有一句，则可以省略{}，但不建议
               total = total * 0.8;
               System.out.println("打折之后的总价为"+total);
           }else{
               System.out.println("商品总价为："+total);
           }
           System.out.println("请输入付款金额！");
           double money = scan.nextDouble();
           if(money>=total){
               double change = money-total;
               System.out.println("找零为："+change);
           }
           else{
               System.out.println("付款金额不够");
           }
           System.out.println();
   
           //分支结构：if-else if
           int score = 60;
           if(score>=90){
               System.out.println("A");
           }else if(score>=80){
               System.out.println("B");
           }else if(score>=60){
               System.out.println("C");
           }else{
               System.out.println("D");
           }
           System.out.println();
   
           //分支结构：switch-case
           double number = 4.56;
           switch ((int) number){  //double型不支持可转为支持的int型（此时小数部分被忽略不计）
               case 1:
                   System.out.println("情况1");
                   break;  //break为java关键字，表示结束当前的switch语句
               case 2:
                   System.out.println("情况2");
                   break;
               case 3:
                   System.out.println("情况3");
                   break;
               default:
                   System.out.println("default情况");
                   break;  //default语句break加不加都可以
           }
       }
   }
   

   请输入商品数量：
   5
   请输入商品价格：
   100
   打折之后的总价为400.0
   请输入付款金额！
   100
   付款金额不够
   
   C
   
   default情况

• 循环结构：

1. while
2. do-while
3. for

   package 第四章;
   /*
     循环结构：while、do-while、for
        1.while------先判断再执行
        2.do-while------先执行再判断
          (1)while条件不满足可能一次都不执行，但是do-while至少会执行一次
          (2)while可以实现的do-while都可以实现
          (3)语法结构：
               do{
                语句块;
               }while( boolean表达式 );
               顺序：先执行语句块,再判断boolean表达式，为true继续执行，为false结束
        3.for循环------完成固定次数的循环
           (1)语法结构：
               for(表达式1;表达式2;表达式3){
               循环体;（表达式4）
               }
           (2)特殊用法：
               1.可以省略表达式1（封号不能丢）例：for(; 表达式2; 表达式3)
               2.可以省略表达式3（封号不能丢）例：for(; 表达式2;)
               3.当省略表达式2时，会进入死循环，开发过程中一定要避免！
           (3)for循环搭配使用的关键字：break、continue、return
               1.break：表示结束当前整个循环，跳出整个for循环执行后续语句
               2.continue：结束当前这一次循环，进行下一次循环，只跳过一次
               3.return：(1)单独使用：表示结束return所在的整个方法/函数
                         (2)return 返回值：需要使用在要求有值返回的方法中，一般写在最后一行
        4.循环语句选择:
           (1)while：当......
           (2)do-while：直到......
           (3)for：固定次数
    */
   public class ForDoWhile {
       public static void main(String[] args) {
           //while语句
           int i = 1;
           int sum = 0;
           while(i<=100){
               if(i==5){
                   break;  //break跳出的为整个while循环，当不满足if则执行while语句
               }
               sum = sum+i;  //满足if条件时跳出整个while循环，sum+=i和i++语句不再执行
               i++;
           }
           System.out.println("while语句：1-4的和为："+sum);
           System.out.println();
   
           //do-while语句
           int num1 = 1;
           do {
               System.out.println("do-while语句：第" + num1 + "次输出");
               num1++;
           }while(num1<=0); //do-while条件不满足也会至少执行一次
   
           int num2 = 1;
           while(num2<=0){
               System.out.println("while语句：第" + num2 + "次输出"); //while语句条件不满足时可能一次都不执行
               num2++;
           }
           System.out.println();
   
           //for语句、break------跳出整个循环
           int sum1 = 0;
           for(int a = 1; a<=10; a++){
               sum1+=a;
               if(sum1==10){
                   System.out.println("break：sum1="+sum1);
                   break;
               }
               System.out.println("for：sum1="+sum1);  //不会输出，因为break跳出的为整个for循环
           }
           System.out.println("for：sum1="+sum1);  //这句才会输出
           System.out.println();
   
           //continue------只跳过该次一次循环
           int sum2 = 0;
           for(int b=1;b<=10;b++){
               if(b%2==1){  //判断b是否为奇数
                   System.out.println("continue：当前为奇数，跳过此次循环，b="+b);
                   continue;  //结束当前的循环，进行下一次循环
               }
               sum2+=b;
           }
           System.out.println("continue：偶数和为：sum2="+sum2);
           System.out.println();
   
   //        int sum2 = 0;
   //        for(int b=1;b<=10;b++){
   //            if(sum==10){
   //                return;  //如果执行到return，return所在的整个main方法不再执行，没有任何输出内容
   //            }
   //            sum2+=b;
   //        }
   //        System.out.println("continue：偶数和为：sum2="+sum2);
   
           //for循环特殊用法
           int sum4 = 0;
           int num = 1;
           for(; num<=10;) {
               sum4 += num;
               num++;
           }
           System.out.println("for特殊用法：sum4=" + sum4);
       }
   }
   

   while语句：1-4的和为：10
   
   do-while语句：第1次输出
   
   for：sum1=1
   for：sum1=3
   for：sum1=6
   break：sum1=10
   for：sum1=10
   
   continue：当前为奇数，跳过此次循环，b=1
   continue：当前为奇数，跳过此次循环，b=3
   continue：当前为奇数，跳过此次循环，b=5
   continue：当前为奇数，跳过此次循环，b=7
   continue：当前为奇数，跳过此次循环，b=9
   continue：偶数和为：sum2=30
   
   for特殊用法：sum4=55

• 循环嵌套：九九乘法表

  package 第四章;
  
  public class Demo1_XunHuan {
      public static void main(String[] args) {
          for(int i=1;i<=9;i++){
              for(int j=1;j<=i;j++){ //j<=i是为了限制j每次从1到9
                  System.out.print(j+"*"+i+"="+(j*i)+"\t"); //\t是编码集合中的特殊符号，表示空格
              }  //同时要写为ptint，表示输出后不换行，如果写为println则会每输出一个等式后都会换行
              System.out.println(); //目的：外层循环一次，换行一次
          }
      }
  }
  

  1*1=1	
  1*2=2	2*2=4	
  1*3=3	2*3=6	3*3=9	
  1*4=4	2*4=8	3*4=12	4*4=16	
  1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
  1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
  1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
  1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
  1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81