Java day3

一. java 三大流程控制

1. 顺序控制

依次执行我们的代码。程序至上而下逐行执行。

2. 条件控制

int a = 0;

a. 目的 ： 对程序执行，一些不可预知的流程，进行一个预先判断。

b. 条件:条件具有真假的特性。而且只可能为真，或者为假。

c. java条件控制有四种手段:

(1)if语句

结构:

if(条件){

//实现逻辑

}

(2)if...else语句

结构:

if(条件){

//实现逻辑

}else{

//实现逻辑

}

else后面之间跟我们的{//代码}

(3)if(条件)...else if(条件)...(接N个)...else

注意:

a.else if(条件): 条件的约束，和我们前面说的if(条件)，俩者是等价的。

b.else if 可以有多个。

c.else 可以省略掉的, 但是即使没有匹配所有条件，我们依然建议必须有else，来保证语句的完整和可读性。

d.如果满足条件只需要执行一行代码，{}也是可以省略的，但是不建议这么做。

(4)switch case

结构:

switch(判断值){

    case 值1:

    break;

    case 值2:

    break;

    .......

    case 值n:

    break;

    default:

}

条件控制语句来说：彼此可以嵌套使用的。

3. 表达式的类型:

int a = 5;

a*3 (结果15)

表达式的输出类型为表达式计算结果的类型。

例：double num = 1.5;

num * 4 (6.0, 表达式最终被当做的类型就是double类型)

4.循环控制

a. while 循环

结构:

while(循环条件){

//循环实现的代码

}

b. do .. while循环

结构:

do{

//实现的代码

}while(循环的条件);

c. for 循环

使用率最高的;

结构:

for(循环变量初始化 ;循环条件判断; 循环变量的改变){

    //循环需要实现的逻辑

}

d. foreach 循环(不是一个常规的java提供的循环的方式，他只是java提供的一种语法糖)

foreach: 对一种循环方式的命名，常规循环的简化方式。

语法糖： 针对基本的语法，提供了一种简化的实现方式。

重要知识点:

俩个关键字: 应用到循环控制中，continue的含义是跳出当次的循环，break的含义是跳出整个循环。

continue:

在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，

之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环; 跳出的仅是continue外层直接包裹的循环.

break:

在循环的代码体中，如果遇到break,则会跳出本循环代码块，break后的代码不会执行。并且整个循环的过程结束。

break后退出的循环也是直接包围break的循环。

5.数组

阶段性关键字总结:

public,class,static,void,int,boolean,char,byte,long,short,double,float,final.

new:

用来创建一个对象。

定义:

数组保存元素的类型 [] 数组变量的名称 = new 数组保存元素的类型[元素的数量];

数组元素的访问: index(数组保存元素的索引) , 从0开始(length-1)

数组来说，如果初始化一个数组，但是并没有保存任何的值，那么数组中会存放一些默认的值:

byte,short,int,long: 0

float，double:0.0

boolean: false

char: ''

数组对象中有一个变量length,能够让我们拿到数组的长度。

 

例题

数组初识：

例1：

public class ArrayDemo1{

    public static void main(String[] args){

       int [] arr = new int[3];

       for(int i=0;i<arr.length;i++){

           arr[i] = i;

       }

       for(int i=0;i<arr.length;i++){

           System.out.println(arr[i]);

       }

    }

}

例2：

/*

 java.lang.ArrayIndexOutOfBoundsException:

 数组越界的异常.

 数组特性:

        a. 长度一旦制定，长度就无法改变

        b. 定义的时候指定的类型，那么数组始终只能保存该类型的元素

*/

public class ArrayDemo2{

    public static void main(String[] args){

       int[] arr = new int[5];

       for(int i=0;i<5;i++){

           arr[i]=i+1;

       }

       for(int i=arr.length-1;i>=0;i--){

           System.out.println(arr[i]);

       }

    }

}

条件控制代码

例1：

/*

    条件:

    a. 可以是一个表达式(

      1.第一类表达式: 常量表达式 --2*2,6-5

      2.第二类表达式: 包含变量的表达式 --score > 90

    )

    b. boolean类型

    表达式需要最终输出boolean类型

    c. 尖括号:

       注意: 可以省略,当我们在条件成立的时候，仅需要执行一行代码的时候，可以省略掉尖括号，虽然可以省略掉，但是按照规范性和可读性，我们始终都需要{}。     

*/

public class IfDemo{

    public static void main(String[] args){

       int score = 90;

           /*

           if(score>90){

              //实现我们的代码

              System.out.println("iphone X");

           }else{

              System.out.println("iphone X 保护壳");

           }

       */

       if(score>=90){

           System.out.println("iphone X");

       }else if(score>70 && score < 90){

           System.out.println("ihpone 8");

       }else if(score>=60 && score <=70){

           System.out.println("xiao mi");

       }

    }

}

例2：

/*

仅会执行第一次匹配到的条件，之后就会退出我们的条件语句

*/

public class IfDemo2{

    public static void main(String[] a){

           int score = 60;

           int num =10;

           int c = 0;

           if(score>90){

              System.out.println("score>90");

           }else if(score>50){

              System.out.println("score>50");

           }else if((c=num)>5){

              System.out.println("num>5");

           }else{

              System.out.println("not match");

           }

           System.out.println(c);

    }

}

例3：

/*

    建议: 虽然条件判断语句可以彼此嵌套，而且也没有嵌套层数的限制，但是过多的嵌套很影响可读性。

    所以要避免过多的嵌套，一般最多建议嵌套3层。

*/

 

public class IfDemo3{

    public static void main(String[] args){

           //如果今天是周末，那么我们搞活动

           //如果周内, 我们上课

           //如果是周末，如果下雨，我们搞室内活动

           //如果是周末，如果不下雨，我们搞室外活动

          

           boolean isWeekend = true;

           boolean isRain = true;

           int joinPersonNum = 7;

           if(isWeekend){

              if(isRain){

                  if(joinPersonNum>5){

                     System.out.println("打游戏");

                  }else{

                     System.out.println("看书");

                  }

              }else{

                  System.out.println("室外活动");

              }

           }else{

              System.out.println("上课");

           }     

    }

}

例4：

/*

注意:

1. switch 后面的 () 一定不能省略

2. switch 后面跟的是整形或者是字符型

实际上，对于char型来说，在这里也是先转换成ascII码，然后进行比较的

3. case 值, 只能是字面常量(1,2,'A','c'); 常量表达式( 2 * 3, 'a'+3)。

4. break; 跳出我们匹配到的条件。 break 可以省略的。

break可以跳出我们的switch代码块，如果省略掉switch.那么代码将会在第一个匹配成功的条件，一直向下继续执行我们的switch语句，直到遇到break为止。

5. default: 可以省略，而且default 可以放到任何的位置。

   default作用: 当匹配不到任何条件的时候，执行的内容。

*/

//前三名的话，奖励800rmb

//4-5名的话，奖励500rmb

public class SwitchDemo{

    public static void main(String[] args){

       int turn = 10;

       switch(turn){

           default:

           System.out.println("100");

           break;

           case 1:

           case 2:

           case 3:

           System.out.println("800");

           break;

           case 4:

           case 5:

           System.out.println("500");

           break;

       }

    }

}

例5：

/*

对于 if..else if..else 语句，我们仅会执行第一个匹配到的条件

*/

public class ClassTest1{

    public static void main(String[] args){

       int age = -1;

       if(age<0){

           System.out.println("非法年龄");

       }

       if(age>60){

           System.out.println("老年");

       }else if(age>=40 && age<=60){

           System.out.println("中年");

       }else if(age>18 && age <40){

           System.out.println("少年");

       }else{

           System.out.println("未成年");

       }

    }

}

循环控制

例1：

/*

    首先for循环有三个部分组成:

    a. 循环变量初始化

    b. 循环条件判断

    c. 循环变量的改变

    这三个部分都可以省略，但是; 不可以省略。

    循环变量: 我们可以定义多个,对于循环变量的改变，我们也可以同时改变多组变量

    执行流程:

    a.循环变量初始化，这个在整个的循环过程中，只会执行一次

    b.进行循环条件的判断，如果满足条件，则执行，否则结束循环

    c.当循环条件满足之后，并且执行了我们循环中定义的代码，最后就会进行循环变量的改变。

*/

public class ForDemo1{

    public static void main(String[] args){

           int minNum = 1;

           final int MAX_NUM = 50;

           int sum = 0;

           for(int i=1;i<=MAX_NUM;i++){

              if(i%2 == 0){

                  sum+=i;

              }

           }

              System.out.println("sum:"+sum);

           }

    }

}

例2：

//要求一次输出 *

 

/*

嵌套的层数没有限制，编译不会出错。但是建议最多嵌套2层。

*/

public class StarOutPut{

    public static void main(String[] args){

       for(int j = 1;j<=5;j++){

           /*

           输出: *

                 **

                ***

                ****

                *****

           */

           for(int i =1;i<=j;i++){

              System.out.print("*");

           }

           System.out.println("");

       }

       //

       for(int j = 1;j<=5;j++){

           /*

           输出:

                *****

                 ****

                ***

                **

                *

           */

           for(int i =1;i<=(6-j);i++){

              System.out.print("*");

           }

           System.out.println("");

       }

    }

}

例3：

/*

循环条件: 可以是一个变量，也可以是一个字面的常量; 可以是我们的表达式(常量表达式，包含变量的表达式)

          类型: boolean

特点: 先判断后执行

*/

public class WhileDemo{

    public static void main(String[] args){

       int maxNum = 13;

       int minNum = 10;

       while(minNum<=maxNum){

           System.out.println(minNum);

       }

    }

}

例4：

/*

在循环的代码体中，如果遇到continue, 则会跳出当次循环，循环体内continue之后的代码都不会执行，并且循环变量进行一次改变操作，之后再次进行条件判断，如果满足条件，则进入循环，否则直接结束循环

*/

public class ContinueDemo1{

    public static void main(String[] args){

       int sum = 0;

       int times = 0;

       //1到50之间所有偶数的和

       for(int i = 1;i<=50;i++){

           times++;

           if(i%2 == 0){

              sum+=i;

           }else{

              break;

           }         

           System.out.println("一次循环结束");

       }

       System.out.println(sum);

       System.out.println(times);

    }

}

例5：

/*

    特点: 先执行后判断；不管条件是否成立，都会至少先执行一次do 中的代码

*/

public class DoWhile{

    public static void main(String[] args){

       int maxNum = 10;

       int minNum = 1;

       //打印1到10之间的自然数

       do{

           System.out.println(minNum);

           minNum++;

       }while(minNum<=maxNum);

    }

}

例6：

public class ClassTestDemo1{

    public static void main(String[] args){

           int minNum = 1;

           final int MAX_NUM = 50;

           int sum = 0;

           while(minNum<=MAX_NUM){

              sum += (minNum%2==0)?minNum:0;

              minNum++;

           }

           System.out.println(sum);

    }

}

例7：

public class ClassTestDemo2{

    public static void main(String[] args){

           int evenSum = 0;

           int unevenSum = 0;

           final int MAX_NUM = 100;

           for(int i = 1;i<=MAX_NUM;i++){

              if(i%2==0){

                  evenSum+=i;

              }else{

                  unevenSum+=i;

              }

           }

           System.out.println(evenSum - unevenSum);

    }

}