学习Java第三天：1、Java中的语句 2、Java中的数组

1、Java中的语句

1. 顺序结构(代码从上往下一行一行的逐条执行)

2. 选择结构（if语句 ， switch语句）

   public class IfDemo{
       public static void main(String args[]){
           //if(判断){java代码}
           //先执行判断，true时执行{java代码}，false时不执行
           int i = 59;
           if(i>=60){
               System.out.println("及格");
           }
           //if(判断){java代码}else{java代码1}
           //先执行判断，true时执行{java代码1}，false时执行{java代码2}
           int i = 59;
           if(i >= 60){
               System.out.println("及格");
           }else{
               System.out.println("不及格");
           }
           //if(判断1){java代码1}else if(判断2){java代码2}...else{java代码n}
           //先执行判断1，判断1true时执行{java代码1}，false时执行判断2，判断2为true时执行{java代码2}
           //所有的判断都为false,则执行最后一个else中的{java代码n}
           int i = 59;
           if(i >= 60){
               System.out.println("及格");
           }else if(i>=70 && i<80){
               System.out.println("良好");
           }else if(i>=80 && i<=100){
               System.out.println("相当优秀");
           }else{
               System.out.println("继续努力");
           }
       }
   }

   public class SwitchDemo{
       public static void main(String args[]){
           /*
           switch语句
           switch（表达式）{
           case 常量值1 ：java代码1; break;
           case 常量值2 ：java代码2; break;
           case 常量值3 ：java代码3; break;
           ......
           default:java代码; break;
           }
           先执行表达式，表达式的结果与case后面的常量值匹配，如果匹配结果相等，执行对应case后面的java代码，如果有break就结果switch语句的执行。如果没有break，那么执行下一个case对应的java代码，直到有break结束，表达式的结果与所有case后面的常量值都不匹配，那么执行default后面的代码。
           注意1：表达式的类型可以是byte,short,char,int,long,String(JDK8.0)，枚举
           注意2：有没有break，有break就结果执行，没有break执行下一个case对应的java代码，直到有break。
           */
           int num1 = 10;
           int num2 = 3;
           char c = '+';
           switch(c){
               case '+':System.out.println(num1 + "+" + num2 + "=" +(num1 + num2));
                   break;
               case '-':System.out.println(num1 + "-" + num2 + "=" +(num1 - num2));
                   break;
               case '*':System.out.println(num1 + "*" + num2 + "=" +(num1 * num2));
                   break;
               case '/':System.out.println(num1 + "/" + num2 + "=" +(num1 / num2));
                   break;
               default:System.out.println("运算有误");
           }
       }
   }

3. 循环结构（for循环，while循环，do...while循环）学习的关键：语法格式，执行过程

public class ForDemo{
    public static void main(String args[]){
        //for循环
        /*
        for(①初始条件; ②判断条件; ④循环增量/减量){
            ③java代码
        }
        初始条件---决定循环的开始
        判断条件---决定循环的结束
        循环增量/减量---控制初始条件值
        执行过程：
        先执行初始条件，在执行判断条件，
        判断条件的结果为true,执行java代码，接下来 执行循环增量/减量,接着执行判断条件
        判断条件的结果为false，循环结束
        */
        //输出1-10的整数
        for(int i = 1;i<=10;i++){
            System.out.println("i=" + i);
        }
        //计算1-10的整数和
        //定义一个变量，来保存和的值
        int sum = 0;
        for(int i = 1; i <= 10; i++){
            sum = sum + i;
        }
    }
}

public class WhileDemo{
    public static void main(String args[]){
        //While循环
        /*
        初始化条件
        while(判断条件){
            java代码
            循环增量/减量
        }
        执行过程：
            先执行判断条件
                判断条件结果为true时，执行{java代码}，继续执行判断条件，
                判断条件结果为false时，结果循环。
        注意1：初始条件定义为while循环的格式之外。
        注意2：把循环增量/减量的条件写在{java代码......最后一句}
        */
        //循环输出1-10的整数
        int i = 1;
        while(i <= 10){
            System.out.println("i=" + i);
            i++;
        }
        //计算1-10的整数和
        int sum = 0;
        int i = 1;
        while(i <= 1){
            sum += i;
            i++;
        }
        System.out.println("sum=" + sum);
    }
}

总结：比较三个循环的区别？应用的场景。

for循环有定义循环增量/减量具体位置，需要明确循环次数。

while循环和do...while循环没有定义循环增量/减量具体位置，往往都是自己定义在循环体中的最后一句，不需要考虑循环次数。

import java.util.Scanner;
public class Test{
    public static void main(String args[]){
        //创建输入对象
        Scanner input = new Scanner(System.in);
        boolean flag = true;//控制循环持续执行
        while(flag){
            //得到第一个运算数字
            int num1 = input.nextInt();
            //得到一个运算符号
            String op = input.text();
            //得到第二个运算数字
            int num2 = input.nextInt();
            switch(op){
                case "+":System.out.println(num1 +"+"+num2+"="+(num1+num2));break;
                case "-":System.out.println(num1 +"-"+num2+"="+(num1-num2));break;
                case "*":System.out.println(num1 +"*"+num2+"="+(num1*num2));break;
                case "/":System.out.println(num1 +"/"+num2+"="+(num1/num2));break;
                case "@":flag =false;break;
                default:System.out.println("输入有误无法计算");break;
            }
        }
    }
}

1. break语句与continue语句的用法和区别

   1. break语句---循环中就表示中断循环的执行

      如果循环是嵌套的，那么break语句出现在那一层就中断那一次的循环

      ---switch中表示结束switch的执行。

   2. continue语句---往往出现在循环中表示结束 当前循环，继续下一次循环执行。

2、Java中的数组

1. 什么是数组？

   相同数据类型的数据

   按照顺序

   复合数据类型（引用数据类型）

2. 如何定义一个一维数组？如下：

public class ArrayDemo{
    public static void main(String args[]){
        //先定义，后创建
        int arr[];
        arr = new int[4];
        //定义+创建
        //数据类型 数组名称[] = new 数据类型[指定的存储空间]; 注意：存储空间的数据值是int整型。
        int arr[] = new int[8];
        String str[] = new String[3];
        //逐个赋值
        str[0] = "张三";
        str[1] = "李四";
        str[2] = "王五";
        //直接赋值
        int arr[] = new int[]{1,2,3};
        String str[] = {"张三","李四","王五"};
    }
}

数组的定义和变量的定义类似，只是需要[]与变量区分，因此有[]就是数组的标志。

名称的前面/后面出现一个[] 就是一维数组，有两个 “[] []”就是二维数组，两个以上就是多维数组。

创建数组的本质就是确定数组的具体存储空间。

1. 如何给一维数组赋值？

   1. 逐个赋值---就是挨个为数组的每一个存储空间存放数据值。（需要数组的下标）

      数组的下标---因为数组是按照顺序保存数据，此时每一个存储空间就有一个顺序的编号，维持数组数据顺序的编号就是下标。通过下标得到具体的数据存储空间。下标从0开始。

      第一个存储空间的下标就是0，依次类推。

   2. 直接赋值---就是在创建数组的时候将数据值保存到数组中。

      2.1 数据类型 数组名称[] = new 数据类型[]{数据值1，数据值2，......}；

      2.2 数据类型 数组名称[] = {数据值1，数据值2，......};

      （创建数组的时候不能指定存储空间）

注意：当保存在数组中的数据超过数组指定的存储空间就会出错。

java.lang.ArrayIndexOutOfBoundsException;(数组下标越界异常)

1. 何如从一维数组中取值？

   只要我们能够得到数组的存储位置，就可以得到数组中的数据值。

   格式：数组名称[下标]

2. 一维数组的length属性

   如果数组通过直接赋值的方式创建，那么length属性就表示元素个数。

   char charArray[] = new char[]{'h','e','l','l','o'};
   System.out.println(charArray.length); // 5

   如果数组通过定义创建的方式创建，那么length属性就表示创建数组是给出的指定空间大小，与数组的元素个数无关。

   int intArray[] = new int[5];
   intArray[0] = 1;
   System.out.pintln(intArray.length); // 4

1. 循环遍历一维数组

   public class Array{
       public static void main(String args[]){
           String str[] = new String[]{"张三","李四","王五"};
           //for循环
           for(int i =0;i < str.length;i++){
               System.out.println(str[i]);
           }
           //while循环
           int j = 0;
           while(j < str.length){
               System.out.println(str[j]);
               j++;
           }
           //增强for循环（JDK1.5）
           for(String s : str){
               System.out.println(s);
           }
       }
   }

1. 认识Arrays类（数组的帮助类）

   Arrays常用函数（都是静态的）

   1. void Array.sort(Object[] array) 对数组按照升序排序。

   2. void Array.sort(Object[] array,int from,int to) 对数组元素指定范围进行排序（排序范围是从元素下标为from,到下标为to-1的元素进行排序）。

   3. Arrays.fill(Object[] array, Object object)可以为数组元素填充相同的值。

   4. Arrays.fill(Object[] array, int form , int to , Object object)对数组的部分元素填充一个值，从起始位置到结束位置，取头部取尾。

   5. Arrays.toString(Object[] array) 返回数组的字符串形式。

扩展：认识计算机结构

 

基本数据类型 只在内存栈区保存数据。

符合数据类型在 内存的栈区和堆区都有保存数据，栈区保存的数据是堆区的存储位置，堆区则保存真实的数据值。

由于计算在执行的时候，总是先从内存的栈区获取数据，因此基本数据类型的执行速度要比复合数据类型的执行速度快。