day15-三大基本结构

顺序结构

• Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

• 顺序结构是最简单的算法结构。

• 语句和语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

 package com.dlq.struct;
 ​
 public class ShunXuDemo {
     public static void main(String[] args) {
         System.out.println("hello1");
         System.out.println("hello2");
         System.out.println("hello3");
         System.out.println("hello4");
         System.out.println("hello5");
         System.out.println("hello6");
     }
 }
 ​

选择结构

• if单选择结构

  • 我们很多时候现需要去判断一个东西是否可行，然后我们 才去执行，这样一个过程在程序中用if语句来表示

  

  • 语法：

   if(布尔表达式){
       //如果布尔表达式的值为true将执行{}内语句
   }

   package com.dlq.struct;
   ​
   import java.util.Scanner;
   ​
   public class IfDemo1 {
       public static void main(String[] args) {
           Scanner scanner=new Scanner(System.in);
   ​
           System.out.println("请输入内容：");
           String s=scanner.nextLine();
   ​
           //equals:判断字符串是否相等，一般不用==
           if (s.equals("hello")){
               System.out.println(s);
           }
           System.out.println("end");
           
           scanner.close();
       }
   }
   ​

• if双选择结构

  • 某公司收购一个软件，成功了，支付100万元，失败了，自己找人开发。这样就需要有两个判断，需要一个双选择结构，即if-else结构。

  

  • 语法：

   if(布尔表达式){
       //如果布尔表达式的值为true将执行此{}内语句
   }else{
       //如果布尔表达式的值为false将执行此{}内语句
   }

   package com.dlq.struct;
   ​
   import java.util.Scanner;
   ​
   public class IfDemo2 {
       public static void main(String[] args) {
           //大于等于60为及格，小于60不及格
           Scanner scanner=new Scanner(System.in);
   ​
           System.out.println("请输入分数：");
           double s=scanner.nextDouble();
           if(s>=60){
               System.out.println("恭喜你！你及格了！");
           }else{
               System.out.println("很遗憾！你没有及格！");
           }
      scanner.close();
       }
   }
   ​

• if多选择结构

  • 实际生活中，真实的情况还可能存在很多选择，存在区间多级判断，比如90-100是A，80-90是B……所以我们需要一个多选择结构来实现。

  

  • 语法：

   if(布尔表达式1){
       //如果布尔表达式1的值为true将执行此{}内语句
   }else if(布尔表达式2){
       //如果布尔表达式2的值为true将执行此{}内语句
   }else if(布尔表达式3){
       //如果布尔表达式3的值为true将执行此{}内语句
   }
   ……
   else{
       //如果以上布尔表达式的值都不为true将执行此{}内语句
   }

   package com.dlq.struct;
   ​
   import java.util.Scanner;
   ​
   public class IfDemo3 {
       public static void main(String[] args) {
           //大于等于60为及格，小于60不及格
           Scanner scanner=new Scanner(System.in);
   ​
           /*
           if语句中至多有一个else语句，且else语句在else if语句之后
           一旦一个else if语句检测为true，将跳过其他所有else if语句以及else语句
            */
   ​
           System.out.println("请输入分数：");
           double s=scanner.nextDouble();
           if(s==100){
               System.out.println("恭喜满分！");
           }else if (s<100&&s>=90){
               System.out.println("A");
           }else if (s<90&&s>=80){
               System.out.println("B");
           }else if (s<80&&s>=70){
               System.out.println("C");
           }else if (s<70&&s>=60){
               System.out.println("D");
           }else if (s<60&&s>=0){
               System.out.println("不及格！");
           }else{
               System.out.println("成绩不合法！");
           }
           scanner.close();
       }
   }
   ​

• 嵌套的if结构

  • 你可以在if或者else if语句中使用if或else if语句。

  • 语法：

   if(布尔表达式1){
       //如果布尔表达式1的值为true将执行此{}内语句
        if(布尔表达式2){
       //如果布尔表达式2的值为true将执行此{}内语句
       }
       ……
   }
   else if……

• switch多选择结构

  • 多选择结构还有一个实现方式就是switch case语句。

  • switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

  • 语法：

   switch(表达式){
       case value1:
           //语句
           break;
       case value2:
           //语句
           break;
           ……
       //你可以有任意数量的case语句
       default:
           //语句
   }

   package com.dlq.struct;
   ​
   import java.util.Scanner;
   ​
   public class SwitchDemo {
       public static void main(String[] args) {
   ​
           //switch  匹配的是一个具体的值
           //case穿透：没有break的情况下，会输出后续case或者default里的内容，直到遇见第一个break
           char grade='E';
   ​
           switch (grade){
               case 'A':
                   System.out.println("优秀！");
                   break;//可选
               case 'B':
                   System.out.println("良好！");
                   break;//可选
               case 'C':
                   System.out.println("合格！");
                   break;//可选
               case 'D':
                   System.out.println("再接再厉！");
                   break;//可选
               case 'E':
                   System.out.println("不及格！");
                   break;//可选
               default:
                   System.out.println("无法查询到结果！");
           }
       }
   }
   ​

   package com.dlq.struct;
   ​
   public class SwitchDemo2 {
       public static void main(String[] args) {
           String name="123";
           //JDK7的新特性，表达式结果可以是字符串
   ​
           //   字符 的 本质 是 数字
   ​
           //反编译  java----class(字节码文件)----反编译(IDEA)
           //将编译器输出路径中的.class文件复制至.java文件所在目录(从文件夹层面拷)，在IDEA打开即可实现反编译
   ​
           //      看  源  码
   ​
           switch (name){
               case "凤求凰":
                   System.out.println("凤求凰");
                   break;
               case "至尊宝":
                   System.out.println("至尊宝");
                   break;
               default:
                   System.out.println("啥也不是！");
           }
       }
   }
   ​

  • switch语句中的变量类型可以是：

    • byte、short、int或者char。

    • 从Java SE7开始

    • switch 支持字符串String类型了

    • 同时case标签必须为字符串常量或字面量。

循环结构

• while循环

  • while循环是最基本的循环，它的结构为：

   while(布尔表达式){
       //循环内容
   }

  • 只要布尔表达式为true，循环就会一直执行下去。

  • 为了让循环停止下来，我们需要一个让表达式失效的方式来结束循环 。

  • 少部分情况需要循环一直执行下去，比如服务器的请求响应监听等。

  • 循环条件一直为true就会造成无限循环【死循环】，正常的业务编程中应尽量避免死循环。会影响程序性能或者造成程序卡死奔溃！

   package com.dlq.struct;
   ​
   public class WhileDemo2 {
       public static void main(String[] args) {
           int i=0;
           //   死 循 环
           while(true){
               i++;
               System.out.println(i);
               //等待客户端连接
               //定时检查
               //。。。。。。
           }
       }
   }
   ​

  • 思考：计算1+2+3+…+100=？

   package com.dlq.struct;
   ​
   public class WhileDemo {
       public static void main(String[] args) {
           //输出1~100
           int i=0;
           int s=0;
           while(i<100){
               i++;
               System.out.println(i);
           }
           //思考：计算1+2+3+…+100=？   高斯
           int j=0;
           int sum=0;
           while (j<=100){
               sum+=j;
               j++;
           }
           System.out.println(sum);//5050
       }
   }
   ​

• do...while循环

  • 对于while语句而言，如果不满足条件，则不能进入循环。但我们有时候需要即使不满足条件，也至少执行一次。

  • do...whlie循环和while循环类似，不同的是do...while循环至少会执行一次。

  • 语法：

   do{
       //代码语句
   }while(布尔表达式);

  • while和do...while的区别：

    • while先判断后执行。do...while先执行后判断。

     package com.dlq.struct;
     ​
     public class DoWhileDemo1 {
         public static void main(String[] args) {
             int i=0;
             int sum=0;
             do {
                 sum+=i;
                 i++;
             }while (i<=100);
             System.out.println(sum);//5050
         }
     }
     ​

    • do...while总是保证循环体会至少被执行一次！这是他们的主要差别。

     package com.dlq.struct;
     ​
     public class DoWhileDemo2 {
         public static void main(String[] args) {
             int a=0;
             while(a<0){
                 System.out.println(a);//一次都不执行
                 a++;
             }
             System.out.println("===================");
             do {
                 System.out.println(a);//  0   先执行一次
                 a++;
             }while(a<0);
         }
     }
     ​

• for循环

  • 虽然所有循环结构都可以用while或者do...while表示，但是Java提供了另一种语句—for循环，使一些循环结构变得更加简单。

  • for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

  • for循环执行的次数实在执行前就确定的。

  • 语法：

   for(舒适化;布尔表达式;更新){
       //代码语句
   }

   package com.dlq.struct;
   ​
   public class ForDemo {
       public static void main(String[] args) {
           int a=1;//初始化
   ​
           while (a<=100){//条件判断
               System.out.println(a);//循环体
               a+=2;//迭代
           }
   ​
           System.out.println("while输出结束了！");
   ​
           //   初始化;条件判断;迭代
           for (int i=0;i<=100;i+=2){
               System.out.println(i);
           }
   ​
           System.out.println("for循环结束了！");
   ​
           //  100.for   可以快速生成一个for循环！
   ​
           /*
           关于for循环的说明：
           最先执行初始化步骤。只可以声明一种类型,但可以初始化一个或多个循环控制变量，也可以是空语句。
           然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
           执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)。
           再次检测布尔表达式。
           循环执行上面的过程。
            */
           //死循环    三处都为空！！！
           for ( ; ; ) {
   ​
           }
       }
   }

  • 练习1：计算0~100之间的奇数和偶数的和。

   package com.dlq.struct;
   ​
   public class ForDemo1 {
       public static void main(String[] args) {
           //练习1：计算0~100之间的奇数和偶数的和。
   ​
           int OddSum=0;//奇数和
           int EvenSum=0;//偶数和
           for (int i=0;i<=100;i++){
   //            if(i%2==1){
   //                OddSum+=i;
   //            }
   //            if(i%2==0){
   //                EvenSum+=i;
   //            }
               //优化
               if (i%2!=0){
                   OddSum+=i;
               }else{
                   EvenSum+=i;
               }
   ​
           }
           System.out.println("奇数的和为："+OddSum);
           System.out.println("偶数的和为："+EvenSum);
       }
   }

  • 练习2：用while或for循环输出1~1000之间能被五整除的数，并且每行输出三个。

   package com.dlq.struct;
   ​
   public class ForDemo2 {
       public static void main(String[] args) {
           //练习2：用while或for循环输出1~1000之间 能 被五整除 的数，并且每行输出三个。
   ​
           for (int i = 1; i <= 1000; i++) {
                   if(i%5==0){
                       System.out.print(i+"\t");
                       //\t是补全当前字符串长度到8的整数倍，最少1个最多8个空格
                       //
                       //补多少要看你\t前字符串长度
                       //
                       //比如当前字符串长度10，那么\t后长度是16，也就是补6个空格
                       //
                       //如果当前字符串长度12，此时\t后长度是16，补4个空格
                   }
                   if (i%(5*3)==0){
                       System.out.println();//换行
                       //System.out.print("\n");
                       //System.out.println("\n");//相当于输出两次换行符，所以行距更大
                   }
                   //println  输出完会换行
                   //print    输出完不会换行
   ​
   ​
           }
       }
   }

  • 练习3：打印九九乘法表。

   package com.dlq.struct;
   ​
   public class ForDemo3 {
       public static void main(String[] args) {
           //打印九九乘法表
           for (int i = 1; i <= 9; i++) {
               for (int j = 1; j <= i; j++) {
                   System.out.print(i + "*" + j + "=" + (i * j)+"\t");//Ctrl+Shift+Enter实现代码间距自动排版
   //                if (j==i){
   //                    System.out.print("\n");
   //                }
               }
               System.out.println();
           }
       }
   }

• 在Java5中引入了一种主要用于数组的增强型for循环。

  • 这里我们先了解一下，之后学到数组的时候重点使用。

  • Java5引入了一种主要用于数组或集合的增强型for循环。

  • Java增强for循环语法格式如下：

   for(声明语句:表达式){
       //代码语句
   }

  • 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

  • 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

   package com.dlq.struct;
   ​
   public class ForDemo4 {
       public static void main(String[] args) {
           int[] numbers = {10,20,30,40,50};//定义一个数组
   ​
           //遍历数组中元素
           for (int i = 0; i < 5; i++) {
               System.out.println(numbers[i]);//0~4
           }
   ​
           System.out.println("==============");
           //简化
           for (int x:numbers) {
               System.out.println(x);
           }
       }
   }