实验3：数组的初始化和逻辑运算符的使用

3.1实验目的

1. 学习数组的定义；

2. 学习数组的初始化；

3. 学习对数组的访问；

4. 掌握整数除法、浮点数除法、混合除法；

5. 掌握基本的逻辑运算符的用法；

3.2 实验内容

3.2.1 定义两个长度为5的数组，一个采用静态初始化，一个采用动态初始化，分别将其输出。

【前提引入】

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引入类型。即数组就是一组数据。

数组创建以后，如果没有复制，则有默认值：int - 0 ，short - 0 ，double - 0.0，boolean - false 等

• 静态初始化：已知数组元素个数和具体值

  1. 数据类型[ ] 数组名 = {元素值，元素值，…};
  2. 数据类型 数组名[ ] = {元素值，元素值，…};

• 动态初始化

  1. 先声明数组：此时还未分配内存空间，为null

     数据类型[ ] 数组名;

  2. 创建数组：分配内存空间，可以存放数据

     数组名 = new 数组类型[大小];

【运行流程】

    public static void main(String[] args) {
        //动态初始化
        int[] dynamicArray = new int[5];
        //动态初始化的默认值输出
        System.out.println("动态初始化默认值输出：" + Arrays.toString(dynamicArray));

        //静态初始化
        int[] quietArray = new int[]{1, 2, 3, 4, 5};
        System.out.println("静态初始化值输出：" + Arrays.toString(quietArray));
    }

3.2.2 定义一个长度为6的整型数组，采用键盘输入相应的数，并实现数组元素由小到大的排序。

【前提引入】

冒泡排序法，时间复杂度为 O($n^2$)

【运行流程】

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] sortArray = new int[6];
        for (int i = 0;i<sortArray.length;i++) {
            sortArray[i] = scanner.nextInt();
        }
        sort(sortArray);
        System.out.println(Arrays.toString(sortArray));
    }

    /**
     * 冒泡排序法
     * @param sortArray 需要排序的数组
     */
    public static void sort(int[] sortArray){
        int temp;
        for (int i = 0; i < sortArray.length - 1; i++) {
            for (int j = 0; j < sortArray.length - 1 - i; j++) {
                if(sortArray[j]>sortArray[j+1]){
                    temp = sortArray[j];
                    sortArray[j] = sortArray[j+1];
                    sortArray[j+1] = temp;
                }
            }
        }
    }

3.2.3 新建Java代码，实现Java的整数除法，浮点数除法和整数与浮点数混合除法。分别计算int a1，b1, c1,为4/5，4.0/5.0，4/5.0的值和当变量为double a2，b2，c2时的值，并输出结果，当出现错误时，采用强制类型转换保证程序的正确性。

3.2.3.1 出错

【前提引入】

数据类型按精度（容量）大小排序规则：

1. byte -> short -> int -> long -> float -> double
2. char -> int -> long -> float -> double

注意事项：

• 数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
• 当我们把精度（容量）大的数据类型复制给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换

【运行流程】

    public static void main(String[] args) {
        int a1 = 4/5;
        int b1 = 4.0/5.0;
        int c1 = 4/5.0;
        double a2 = 4/5;
        double b2 = 4.0/5.0;
        double c2 = 4/5.0;
        System.out.println("a1 = " + a1 + ",b1 = " + b1 + ",c1 = " + c1);
        System.out.println("a2 = " + a2 + ",b2 = " + b2 + ",c2 = " + c2);
    }

3.2.3.2 改进

【前提引入】

• 强制类型转换是自动类型转换的逆过程，将容量大的数据类型转换成容量小的数据类型，使用的时候要加上强制类型转换符（）
• 但可能会造成 精度损失 或 数据溢出
• 强制符号只针对于最近的操作数有效，往往会使用小括号提升优先级

【运行流程】

    public static void main(String[] args) {
        int a1 = 4/5;
        int b1 = (int)(4.0/5.0);
        int c1 = (int)(4/5.0);
        double a2 = 4/5;
        double b2 = 4.0/5.0;
        double c2 = 4/5.0;
        System.out.println("a1 = " + a1 + ",b1 = " + b1 + ",c1 = " + c1);
        System.out.println("a2 = " + a2 + ",b2 = " + b2 + ",c2 = " + c2);
    }

3.2.4 新建Java代码，实现Java的逻辑运算。给定布尔变量i, j, k, l，i的值为5>6的比较结果，j为i的非，k为i和j的与，l为i和j的或，最后分别将4个结果输出。

【前提引入】

• && 与 || 都是短路

  1. &&：全真则真，否则为假
  2. ||：一真为真，否则为假

• boolean 类型的值只能为 false 或 true ，不能用数字代替，数字也无法表示 true 或 false

• > < == || && 的结果都是 boolean 类型的数据

• boolean 类型不参与自动类型转换与强制类型转换

【运行流程】

    public static void main(String[] args) {
        boolean i = 5>6;
        boolean j = !i;
        boolean k = i&&j;
        boolean l = i || j;
        System.out.println("i = " + i + ",j = " + j + ",k = " + k + ",l = " + l);
    }