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

一、顺序结构 如：

键盘输入程序的步骤：
1、先准备键盘输入的工具类的对象 --》比喻成准备键盘
    java.util.Scanner input = new java.util.Scanner(System.in);
    
第一：Scanner是首字母是大写
第二：System也是首字母大写    
第三：左右两边一样java.util.Scanner
第四：其他照抄，input可以自己命名，代表了键盘输入工具

2、提示输入
System.out.println(xxx);

3、输入
输入字符串：input.next();
输入整数： input.nextInt();
         input.nextLong();
输入小数：input.nextFloat();
         input.nextDouble();
输入布尔：input.nextBoolean()

输入一个字符：input.nextChar();错误的
            input.next().charAt(0);

*/
class TestInput{
    public static void main(String[] args){
        //从键盘输入姓名和年龄等
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入姓名：");
        String name = input.next();//从键盘输入一个字符串，保存到name变量中。
        
        System.out.print("请输入年龄：");
        int age = input.nextInt();
        
        System.out.print("请输入体重：");
        double weight = input.nextDouble();
        
        System.out.print("请输入是否已婚(true/false)：");
        boolean isMarry = input.nextBoolean();
        
        System.out.print("请输入性别：");
        char gender = input.next().charAt(0);
        
        System.out.println("姓名：" + name);
        System.out.println("性别：" + gender);
        System.out.println("年龄：" + age);
        System.out.println("体重：" + weight);
        System.out.println("是否已婚：" + (isMarry?"是":"否")); 
        
    }
}

二、分支结构
1）条件判断：if..else  （有单分支条件判断、双分支条件判断、多分支条件判断、嵌套。）
2）选择结构：switch..case

（一）条件判断系列（if语句3种格式：单、双、多）
1、单分支条件判断；　　只有一个选项，要么成立就做，要么不成立什么也不干。
语法结构：
    if(条件表达式){
        当条件表达式成立时，需要执行的语句块;
    }

说明：
（1）if(条件表达式)中的条件表达式的结果必须是boolean值，即要么是true要么是false
（2）{}中是语句块，意思就是可以是一句或多句
（3）{}中的语句块只有一条语句时，这个{}是可以省略的，但是不建议大家省略。

执行的特点：
    if()条件成立就执行{}中的语句块，不成立就不执行。
    
2、双分支条件判断 ；（二选一）
语法结构：
    if(条件表达式){
        当条件表达式成立时，执行的语句块1；
    }else{
        当条件表达式不成立时，执行的语句块2；
    }

说明：
（1）if(条件表达式)中的条件表达式的结果必须是boolean值，即要么是true要么是false
（2）{}中是语句块，意思就是可以是一句或多句
（3）{}中的语句块只有一条语句时，这个{}是可以省略的，但是不建议大家省略。

执行特点：
        双分支结构，一定会执行其中的一个分支，即二选一执行。
        当条件表达式成立时，执行的语句块1；不成立，就执行语句块2；
        
        
        if(num%2==0){
            System.out.println(num + "是偶数");
            System.out.println(num + "是双数");
        }else{
            System.out.println(num + "是奇数");
        }
        
        /*
        //两个单分支
        if(num%2==0){
            System.out.println(num + "是偶数");
            System.out.println(num + "是双数");
        }
        if(num%2!=0){
            System.out.println(num + "是奇数");
            System.out.println(num + "是单数");
        }
        */
3、多分支条件判断：多选一
语法结构：
    if(条件表达式1){
        当条件表达式1成立时，执行的语句块1；
    }else if(条件表达式2){
        当条件表达式1不成立时，而条件表达式2成立，执行的语句块2；
    }else if(条件表达式3){
        当条件表达式1和2都不成立时，而条件表达式3成立，执行的语句块3；
    }....
    else{
        当以上所有条件都不成立时，执行语句块n+1；
    }
    
说明：
（1）if(条件表达式)中的条件表达式的结果必须是boolean值，即要么是true要么是false
（2）{}中是语句块，意思就是可以是一句或多句
（3）{}中的语句块只有一条语句时，这个{}是可以省略的，但是不建议大家省略。
（4）如果多个条件之间的关系是“互斥”关系，它的顺序是随意的；
                       是“包含”关系，它的顺序有要求，范围小的在上，范围大的在下；

执行的特点：
        从上往下依次判断条件，如果有一个条件成立了，后面的条件都不看了；
        如果最后有单独的else，那么以上条件都不成立，就执行最后else中的；
        如果最后没有单独的else，那么以上条件都不成立时，就什么也不执行。
        多个分支中最多执行一个。
/*
        if(score==100){
            System.out.println("满分");
        }else if(score>=80 && score<=99){
            System.out.println("优秀");
        }else if(score>=70 && score<80){
            System.out.println("良好");
        }else if(score>=60 && score<70){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        */
        if(score==100){
            System.out.println("满分");
        }else if(score>=80){
            System.out.println("优秀");
        }else if(score>=70){
            System.out.println("良好");
        }else if(score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
4、嵌套：
    当外层情况满足了，才会判断嵌套在里面的条件。

前提条件是[0,100]
        //如果是100分，显示满分
        //如果是[80-99]，显示优秀
        //如果是[70,80)，显示良好
        //如果是[60,70)，显示及格
        //其他的显示不及格
如果成绩不再[0,100]，提示它输入错误    
/*
        if(score>=0 && score<=100){
            if(score==100){
                System.out.println("满分");
            }else if(score>=80){
                System.out.println("优秀");
            }else if(score>=70){
                System.out.println("良好");
            }else if(score>=60){
                System.out.println("及格");
            }else{
                System.out.println("不及格");
            }
        }else{
            System.out.println("成绩的范围是：[0,100]");
        }
        */
        
        if(score<0 || score>100){
            System.out.println("成绩的范围是：[0,100]");
        }else{
            if(score==100){
                System.out.println("满分");
            }else if(score>=80){
                System.out.println("优秀");
            }else if(score>=70){
                System.out.println("良好");
            }else if(score>=60){
                System.out.println("及格");
            }else{
                System.out.println("不及格");
            }
        }

（二）选择结构 （ switch()  case :    default: ）
语法格式：
    switch(表达式){
        case 常量值1:
            语句块1;
            break;
        case 常量值2:
             语句块2;
             break;
        case 常量值3:
            语句块3;
            break;
        default:
            语句块n+1;
            break;
    }
    
说明：
    （1）case后面必须是常量值；
    （2）case后面的常量值不能重复
    （3）switch(表达式)中表达式的结果的类型有要求：
            四种基本数据类型：byte,short,int,char
            两种引用数据类型：JDK1.5之后开始支持枚举类型，JDK1.7之后开始支持String类型

执行过程：
（1）入口
    A：当switch(表达式)中表达式的值与某一个case后面的常量值“匹配”，就从这个case进入；
    B：如果存在default，那么当所有的case都无法匹配时，从default进入；
（2）出口    
    A：自然出口：switch的结束}
    B：中断出口：break;

一定找到“入口”，就会一直往下运行，直到遇到“出口”

可以用switch..case，一定可以用if..else实现，
但是有的时候，用switch...case效率更好，可读性更好    

当条件判断是常量==比较时，可以改用switch..case

/*
1.格式：三种
2.执行if-else语句时,一定会选择其中的一个路径执行，而且仅选择一条路径。
*/
class TestIf1 {
    public static void main(String[] args) {
        int age = 28;

        if (age > 18){
            System.out.println("");
        }else{
            System.out.println("");

        if (age > 130 || age < 0){
            System.out.println("");
        }else if(age < 30){
            System.out.println("");
        }else{
            System.out.println("");
        }

        if(age < 30){
        }else if(age < 60){
        }else if(age < 100){
        }else{
        }


    }
}

//1.导包
import java.util.Scanner;
class TestScanner{
    public static void main(String[] args) {
        //2.创建一个Scanner类的对象
        Scanner s = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        //3.调用此对象的相应的方法,完成键盘输入的值的获取
        //next():表示从键盘获取一个字符串
        String str = s.next();

        System.out.println(str);


    }
}

/*
从键盘输入小明的期末成绩；
当成绩为100分时，奖励一辆BMW；
当成绩为(80, 90)时，奖励一个iphone8;
当成绩为[60,80)时，奖励一本参考书;
其他，什么也没有。
1.条件判断之间可以嵌套；
2.如果多个条件之间是互斥关系，多个条件语句上下顺序是自由的。
  如果多个条件之间存在包含关系，要求范围小的写在范围大的上面。
*/
import java.util.Scanner;
class TestIf2{
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入小明的成绩：（分）");
        int score = s.nextInt();

        if (score >100 || score < 0){
            System.out.println("你输入的数值有误!");
        }else{
            if(score == 100){
                System.out.println("奖励一辆BMW");
            }else if(score > 80){ //(score > 80 && score <=99)
                System.out.println("奖励一个iphone8");
            }else if(score >= 60){ //(score >= 60 && score <=80) //范围大的写下边哦
                System.out.println("奖励一本书");
            }else{
                System.out.println("上面也没有");
            }
        }

    }
}

/*
switch(变量){
    case 值1;
    case 值2;
    case 值3;
    default:
    }
1.根据变量的值，选择相应的case去判断，一旦满足条件，就执行case的相应语句；如果没有break或者已经
结尾的话，会继续执行其下的case语句。
2.default：是可选的，而且位置是灵活的。
3.变量可以是哪些类型？char byte short int 枚举 String(jdk1.7)
4.case条件:其中条件只能是值，不能是取值范围
*/

class TestSwitch1 {
    public static void main(String[] args) {
        int i = 5;
        switch(i){
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");
                break;
        }
    }
}

/*
对学生成绩大于60的,输出"合格"；低于60分的输出"不及格";
说明：
1.当多个case语句处理的语句块一致时,可以统一来写；
2.一定情况下switch-case与if-else之间可以互相转换。
*/
class TestSwitch3{
    public static void main(String[] args) {
        int score = 67;
        if (score >= 60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        
        /*
        switch(score){
            case 100:
            ...
            case 0:
            default:
        }
        */
        switch(score / 10){
            case 10:
            case 9:
            case 8:
            case 7:
            case 6:
                System.put.println("及格");
                break;
            case 5:
            case 4:
            case 3:
            case 2:
            case 1:
            case 0:
                System.out.println("不及格");
                break;
            default:
                System.out.println("输入有误");
                break;

    }
}

/*
编写程序：从键盘上输入2014年的"month"和"day"，要求通过程序输入输出的日期为2014年的第几天
*/
import java.util.Scanner;

class TestSwitch4 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入月份:");
        int month = s.nextInt();
        System.out.println("请输入日期:");
        int day = s.nextInt();

        int sum = 0;//用来记录month月day日是2014年第几天
        //使用switch-case
        switch(month){
            case 12:
                sum += 30;//30天,十一月的总天数
            case 11:
                sum += 31;
            case 10:
                sum += 30;
            case 9:
                sum += 31;
            case 8:
                sum += 31;
            case 7:
                sum += 30;
            case 6:
                sum += 31;
            case 5:
                sum += 30;
            case 4:
                sum += 31;
            case 3:
                sum += 28;
            case 2:
                sum += 31;//31,是一月份的天数
            case 1:
                sum += day; //最后再加上你输入的当月的天数
            }
            System.out.println(sum);

    }
}

/*
for循环结构:
1.格式：①初始化条件；②循环条件；③迭代条件；④循环体；
        for(①;②;③){
            //④
        }
2.执行过程：①-②-④-③-②-④-③-     -④-③-②
    即直至循环条件不满足，退出循环体
*/
class TestFor {
    public static void main(String[] args) {
        for (int i = 0;i < 4 ;i++ ){
            System.out.println("Hello World!");
        }


        int j = 1;
        for (System.out.print(‘a‘); j < 3 ;System.out.print(‘b‘), j++ ){
            System.out.print(‘c‘);
        }
        //acbcb
    
    //题目:输出100以内的所有偶数及所有偶数的和及偶数的个数
    int sum = 0;
    int count = 0;
    for (int i = 1;i<= 100 ;i++ ){ //100以内的自然数的遍历
        if(i % 2 == 0){
            System.out.println(i);
            sum += i;
            count++;
        }
    }
    System.out.println("总和为:" + sum);
    System.out.println("100以内偶数的个数为:" + count);

    }
}

/*

①初始化条件；
②循环条件；
③迭代条件；
④循环体；
1.格式：
①
while(②){
    ④
    ③
}

*/
class TestWhile{
    public static void main(String[] args) {
        //100以内的偶数的输出及其和
        int i = 1;
        int sum = 0;
        while(i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
            i++;
        }
        System.out.println(sum);

    }
}

/*
1.格式:
①
do{
    ④
    ③
}while(②);

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

*/
class TestDowhile {
    public static void main(String[] args) {
        int i = 1;
        do{
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }while(i <= 100);

        //do-while 和 while的区别
        int j = 10;
        do{
            System.out.println(j);
            j++;
        }while(j < 10);


        while(j < 10){
            System.out.println(j);
            j++;
        }

    }
}

class TestForFor {
    public static void main(String[] args) {
        /*
        *****
        *****
        *****
        *****

        */
        for(int j = 0;j < 4;j++){      //外层循环控制行数
            for(int i = 0;i < 5;i++){  //内层循环控制列数
                System.out.print("*");
            }
            System.out.println();
        }
        /*
        *
        **
        ***
        ****
        */
        for (int j = 0;j < 4 ; j++){      //外层循环控制行数
            for(int i = 0;i < j + 1;i++){ //内层循环控制列数
                System.out.print("*");
        }
        System.out.println();
        }

        /*

        ****
        ***
        **
        *

        */

        for(int i = 0;i < 5;i++){
            for(int j = 0;j < 5-i;j++){ //for(int j = i;j < 5;j++)
                System.out.print("*");
            }
            System.out.println();
        }

        /*
        *
        **
        ***
        ****
        ****
        ***
        **
        *

        */
        for (int j = 0;j < 4 ; j++){      //外层循环控制行数
            for(int i = 0;i < j + 1;i++){ //内层循环控制列数
                System.out.print("*");
        }
        System.out.println();
        }
        for(int i = 0;i < 5;i++){
            for(int j = 0;j < 5-i;j++){ //for(int j = i;j < 5;j++)
                System.out.print("*");
            }
            System.out.println();
        }

/*
打印如下图形:
----*
---* *
--* * *
-* * * *
* * * * *
i  k-  j*  k = 4 - i    j = i + 1
0    4    1
1    3    2
2    2    3
3    1    4
4    0    5

-* * * *
--* * *
---* *
----*
i  k-  j*  k = i + 1   j = 4-i
0  1   4  
1  2   3
2  3   2
3  4   1

*/

        //上半部分
        for(int i = 0;i < 5;i++){
            for(int k = 0;k < 4 - i;k++){
                System.out.print("-");
            }
            for(int j = 0;j < i + 1;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
        //下半部
        for (int i = 0;i < 4;i++){
            for(int k = 0;k < i + 1 ;k++){
                System.out.print("-");
            }
            for(int j = 0;j < 4-i;j++){
                System.out.print("* ");
            }
            System.out.println();
        }

    }
}

/*
break:使用在switch-case中或者循环中
如果使用在循环中，表示结束"当前"循环

continue:使用在循环结构中
表示:结束"当次"循环
*/

class TestBreakContinue {
    public static void main(String[] args) {
        for (int i = 1;i <= 10;i++){
            if (i % 4 == 0){
                break;
                //continue;
            }
            System.out.println(i);
        }

        
        label:for (int i =1;i < 5;i++){
            for (int j = 1;j <= 10;j++){
                if (j % 4 == 0){
                    //break;  //写在哪一层就结束哪一层
                    //continue;
                    //break label;
                    continue label;
                }
                System.out.print(j);
            }
            System.out.println();
        }


        
        for (int i = 1;i <= 10;i++){
            if (i % 4 == 0){
                break;
                //continue;
                //在break和continue语句之后不能添加其他语句,永远也不能被执行；
                //System.out.println(‘我是执行不了的哦‘);
            }
            System.out.println(i);
        }


    }
}

public class TestArray {
    public static void main(String[] args){

        //1.如何定义一个数组
        //1.1数组的声明
        String[] names;
        int scores[];
        //1.2初始化
        //第一种：静态初始化：初始化数组与给数组赋值同时进行。
        names = new String[]{"kris","alex","egon"};
        
        //第二种：动态初始化：初始化数组与给数组元素赋值分开进行。
        scores = new int[4];
        //2.如何调用相应的数组元素:通过数组元素的下角标的方式来调用。
        //下角标从0开始，到n-1结束，其中n表示数组的长度。
        scores[0] = 87;
        scores[1] = 88;
        scores[3] = 90;
        //3.数组的长度：通过数组的length属性。
        System.out.println(names.length);//3
        System.out.println(scores.length); //4
        //4.如何遍历数组元素
//        System.out.println(names[0]);
//        System.out.println(names[1]);
//        System.out.println(names[2]);
        for (int i = 0; i < names.length; i++){
            System.out.println(names[i]);
        }
        
    }
}

public class TestArray0 {
    public static void main(String[] args){
        
        //对于基于基本数据类型的变量创建的数组:byte short int long float double char boolean
        //1.对于byte short int long而已：创建数组以后，默认值为0
        int[] scores = new int[4];
        scores[0] = 89;
        scores[3] = 90;
        for(int i = 0;i < scores.length;i++){
            System.out.println(scores[i]);
        }
        //2.对于float  double而言；默认值是0.0
        float[] f = new float[3];
        f[0] = 1.2F;
        for(int i = 0; i < f.length;i++){
            System.out.println(f[i]);
        }
        System.out.println();
        
        //3.对于char而言，默认是空格
        char[] c = new char[3];
        for(int i = 0; i < c.length;i++){
            System.out.println(c[i]);
        }
        System.out.println();
        
        //4.对于boolean而言，默认是false
        boolean[] b = new boolean[3];
        for(int i = 0; i < b.length;i++){
            System.out.println(b[i]);
        }
        System.out.println();        
        
        //5.对于引用类型的变量构成的数组而言：默认初始化值为null。以String为例
        String[] strs = new String[4];
        strs[0] = "AA";
        strs[1] = "BB";
        //strs[2] = "CC"; 默认为null
        strs[3] = "DD";
        //遍历数组的元素
        for (int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
        
        
        //自定义的类
        System.out.println();
        Person[] pers = new Person[3];
        for(int i = 0; i < pers.length;i++){
            System.out.println(pers[i]);
        }
    }
}
class Person{
    
}

//数组一旦初始化，其长度是不可变的
public class TestAarry1 {
    public static void main(String[] args){
        int[] i = new int[]{12,13,14};
        int[] j = new int[10];
        for(int k = 0;k < i.length;k++){
            j[k] = i[k];
        }
        j[3] = 15;
        j[4] = 16;
        
        for(int k = 0; k < j.length;k++){
            System.out.println(j[k]);
        }
    }

}

package com.du.bai.www;

public class TestArry2 {
    public static void main(String[] args){
        int[] scores1 = new int[10];
        int[][] scores2;
        String[][] names;
        //1.二维数组的初始化
        scores2 = new int[][]{{1,2,3},{3,4,5},{6}}; //静态初始化
        
        names = new String[6][5];//动态初始化的方式一
        names = new String[6][0]; //动态初始化的方式二
        names[0] = new String[5];
        names[1] = new String[3];
        names[2] = new String[7];
        names[3] = new String[9];
        names[4] = new String[2];
        names[5] = new String[4];
        
        //错误的初始化方式
        //names = new String[][];
        //names = new String[][5];
        
        //2.如何来引用具体的某一个元素
        int[][] i = new int[3][2]; //int[] i[] = new int[3][2];
        i[1][0] = 90;
        i[2][1] = 89;
        
        //3.数组的长度
        //二维数组的长度;length属性
        System.out.println(i.length); //3
        //二维数组中元素的长度
        System.out.println(i[0].length); //2
        System.out.println(names.length); //6
        System.out.println(names[4].length); //8
        System.out.println(); 
        
        //4.如何遍历二维数组
        for(int m = 0; m < scores2.length;m++){ //控制行数
            for(int n = 0;n < scores2[m].length;n++){
                System.out.print(scores2[m][n] + "  ");
            }
            System.out.println();
        }
        
    }

}

public class TestException {
    public static void main(String[] args){
        //1.数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException
        int[] i = new int[10];
        //i[0] = 90;
        //i[10] = 99;
//        for (int m = 0;m <= i.length;m++){
//            System.out.println(i[m]);
//        }
        
        //2.空指针的异常：NullPointerException
        //第一种：
//        boolean[] b = new boolean[3];
//        b = null;
//        System.out.println(b[0]);
        
        //第二种：
//        String[] str = new String[4];
//        str[3] = new String("AA"); //str[3] = "AA";
//        System.out.println(str[3].toString());
        //第三种：
        int[][] j = new int[3][];
        j[2][0] = 12;
    }
}

public class TestGetSum {
    public static void main(String[] args){
        int[][] m = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
        int sum = 0;
        for (int i = 0;i < m.length;i++){
            for(int j = 0;j < m[i].length;j++){
                System.out.print(m[i][j] + "\t");
                sum += m[i][j];
            }
            System.out.println();
        }
        System.out.println("总和为:" + sum);
    }

}

public class TestYangHui {
    public static void main(String[] args){
        int[][] yangHui = new int[10][];
        //1.初始化二维数组
        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];
        }
        //2.显示的为二维数组的每个元素赋值
        for(int i = 0;i < yangHui.length;i++){
            for(int j = 0;j < yangHui[i].length;j++){
                yangHui[i][0] = yangHui[i][i] = 1;
                
                if (i > 1 && j > 0 && j < i){
                    yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
                    
                }
            }
            
        }
        
        //遍历二维数组
        for(int i = 0;i < yangHui.length;i++){
            for(int j = 0; j < yangHui[i].length;j++){
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }

}

public class TestArray3 {
    public static void main(String[] args){
        int[] arr = new int[] {12, 43, 6, 9, 0, -65, -99, 100, 8};
        //最大值
        int max = arr[0];
        for (int i = 1;i < arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("数组的最大值为:" + max);
        
        //最小值
        int min = arr[0];
        for (int i = 1; i < arr.length;i++){
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("数组的最小值为：" + min);
        
        //总和
        int sum = 0;
        for (int i = 0;i < arr.length;i++){
            sum += arr[i];
        }
        System.out.println("总和为:" + sum);
        
        //平均数
        int avg = 0;
        avg = sum / arr.length;
        System.out.println("平均值为：" + avg);
    }

}