面向对象程序设计实践（Java）书面作业1

1.数组： 

1.1 数组复制：

与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange和copyOf方法进行数组复制。

不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。

除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，但是具体的细节是怎样的呢？

自己编程实现数组复制，并且使用copyOfRange、copyOf和arraycopy进行数组复制。

1. `System.arraycopy`:
`System.arraycopy` 是 Java 中用于数组复制的静态方法。它可以将源数组的指定范围的元素复制到目标数组的指定位置。它的语法如下：

System.arraycopy(源数组, 源数组起始位置, 目标数组, 目标数组起始位置, 要复制的元素个数)

其中，
- 源数组：要复制元素的源数组。
- 源数组起始位置：要复制的元素在源数组中的起始位置。
- 目标数组：复制元素的目标数组。
- 目标数组起始位置：要将元素复制到目标数组中的起始位置。
- 要复制的元素个数：要复制的元素个数。

`System.arraycopy` 方法会按照给定的起始位置和元素个数将源数组中的元素复制到目标数组中。这个方法可以用来实现数组的复制、数组的合并等操作。

2. `Arrays.copyOfRange` 和 `Arrays.copyOf`:
`Arrays` 类是 Java 提供的一个工具类，其中包含了很多对数组进行各种操作的方法。

- `Arrays.copyOfRange` 方法用于复制指定范围的元素到一个新数组中。它的语法如下：

Arrays.copyOfRange(源数组, 起始位置, 结束位置)

其中，
- 源数组：要复制元素的源数组。
- 起始位置：要复制的元素的起始位置。
- 结束位置：要复制的元素的结束位置（不包括该位置的元素）。

`Arrays.copyOfRange` 方法将返回一个新的数组，其中包含了源数组中指定范围的元素。

- `Arrays.copyOf` 方法用于复制指定长度的元素到一个新数组中。它的语法如下：

Arrays.copyOf(源数组, 新数组长度)

其中，
- 源数组：要复制元素的源数组。
- 新数组长度：新数组的长度。

`Arrays.copyOf` 方法将返回一个新的数组，其中包含了源数组中指定长度的元素。如果新数组长度大于源数组长度，将用默认值填充新数组的剩余部分。

这两个方法都是使用数组复制的常见场景，能够方便地对数组进行复制操作，提供了更灵活的方式来处理数组的拷贝需求。

答：

// 多个复制数组方法均写在下方，根据需求开关注释即可
package JavaHomework.Homework01;

import java.util.Arrays;
import java.util.Scanner;

public class homework1_1_1_V1 {
    public static void main(String[] args) {
        try {
            int[] sourceArray = getInts();

            // 获取复制的起始和终止范围
            Scanner scanner = new Scanner(System.in);
            System.out.print("请输入复制的起始位置：");
            int sourcePos = scanner.nextInt();
            System.out.print("请输入复制的终止位置：");
            int endPos = scanner.nextInt();

            // 计算复制的长度
            int length = endPos - sourcePos + 1;

            // 创建目标数组
            int[] targetArray = new int[length];

            // 执行数组复制

            // 输出目标数组
            System.out.println("复制后的目标数组为：");
            // 我实现的arrayCopy
            myArrayCopy(sourceArray, sourcePos, targetArray, 0, length);

            // System.arraycopy
            System.arraycopy(sourceArray, sourcePos, targetArray, 0, endPos - sourcePos + 1);

            // copyOfRange
            targetArray = Arrays.copyOfRange(sourceArray, sourcePos, endPos);

            // copyOf
            targetArray = Arrays.copyOf(sourceArray, endPos - sourcePos + 1);

            for (int num : targetArray) {
                System.out.print(num + " ");
            }

        } catch (NumberFormatException e) {
            System.out.println("输入的数组元素格式不正确，请输入整数值。");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("输入的起始位置或终止位置超出了数组的范围。");
        }
    }

    public static int[] getInts() {
        // 获取源数组
        System.out.print("请输入源数组元素（以空格分隔）：");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] sourceArrayString = input.split(" ");
        int[] numbers = new int[sourceArrayString.length];
        for (int i = 0; i < sourceArrayString.length; i++) {
            numbers[i] = Integer.parseInt(sourceArrayString[i]);
        }
        return numbers;
    }

    public static void myArrayCopy(int[] source, int sourcePos, int[] target, int targetPos, int length) {
        for (int i = 0; i < length; i++) {
            target[targetPos + i] = source[sourcePos + i];
        }
    }
}

以下是copyOfRange的源代码，展示其实现细节：

    public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

1.2 打印数组内容：

如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印，但是Arrays提供了一个toString(数组变量)方法，直接把一个数组，转换为字符串，这样方便观察数组的内容。请编写程序用两种方式实现打印数组内容。

答：

package JavaHomework.Homework01;

import java.util.Arrays;
import java.util.Scanner;

public class homework1_1_2_V1 {
    public static void main(String[] args) {
        int[] numbers = getInts();

        // 使用 for 循环逐个打印数组元素
        System.out.println("方式一：通过 for 循环逐个遍历并打印数组元素");
        printArrayUsingForLoop(numbers);
        System.out.println("方式二：使用 Arrays.toString() 方法将数组转换为字符串并打印");
        printArrayUsingToString(numbers);
    }

    private static int[] getInts() {
        // 获取源数组
        System.out.print("请输入源数组元素（以空格分隔）：");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] sourceArrayString = input.split(" ");
        int[] numbers = new int[sourceArrayString.length];
        for (int i = 0; i < sourceArrayString.length; i++) {
            numbers[i] = Integer.parseInt(sourceArrayString[i]);
        }
        return numbers;
    }

    // 通过 for 循环逐个遍历并打印数组元素的函数
    public static void printArrayUsingForLoop(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    // 使用 Arrays.toString() 方法将数组转换为字符串并打印的函数
    public static void printArrayUsingToString(int[] array) {
        System.out.println(Arrays.toString(array));
    }
}

1.3 数组元素排序：

Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。

创建一个长度为100的一维数组，填充以0-100的随机数，分别使用sort方法、选择法排序和冒泡法排序，对一维数组进行排序。

关于随机数：0-100的 随机整数的获取办法有多种，下面是参考办法之一:(int) (Math.random() * 100)，Math.random() 会得到一个0-1之间的随机浮点数，然后乘以100，并强转为整型即可。

答：

package JavaHomework.Homework01;

import java.util.Arrays;

public class homework1_1_3_V1 {
    public static void main(String[] args) {
        int[] array = new int[100];

        // 填充数组
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random() * 101); // 生成0-100的随机整数
        }

        // 使用sort方法排序
        int[] sortedArray1 = array.clone(); // 克隆一个数组用于排序
        Arrays.sort(sortedArray1);

        // 使用选择法排序
        int[] sortedArray2 = array.clone();
        selectionSort(sortedArray2);

        // 使用冒泡法排序
        int[] sortedArray3 = array.clone();
        bubbleSort(sortedArray3);

        // 输出排序后的数组
        System.out.println("使用sort方法排序后的数组：" + Arrays.toString(sortedArray1));
        System.out.println("使用选择法排序后的数组：" + Arrays.toString(sortedArray2));
        System.out.println("使用冒泡法排序后的数组：" + Arrays.toString(sortedArray3));
    }

    // 选择法排序
    public static void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
    }

    // 冒泡法排序
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

1.4 搜索：

编写search方法，查询指定数据在数组中的下标，没有指定数据返回位置为-1。使用直接遍历和binarySearch两种方法。

需要注意的是，使用binarySearch进行查找之前，必须对数组进行排序。如果数组中有多个相同的指定数据，则查找结果是不确定的。

答：

package JavaHomework.Homework01;

import java.util.Arrays;
import java.util.Scanner;

public class homework1_1_4_V1 {
    public static void main(String[] args) {
        int[] array = getInts();
        Arrays.sort(array);
        System.out.print("请输入待查找数据：");
        Scanner scanner = new Scanner(System.in);
        int target = scanner.nextInt();

        int index1 = linearSearch(array, target);           // 自行实现

        int index2 = Arrays.binarySearch(array, target);    // 调用Arrays类的库函数

        System.out.println("直接遍历方法：");
        if (index1 != -1) {
            System.out.println(target + "的下标是：" + index1);
        } else {
            System.out.println(target + "不存在数组中");
        }

        System.out.println("\n二分查找方法：");
        if (index2 >= 0) {
            System.out.println(target + "的下标是：" + index2);
        } else {
            System.out.println(target + "不存在数组中");
        }
    }

    // 直接遍历方法
    public static int linearSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                return i;
            }
        }
        return -1; // 没有找到目标值
    }

    private static int[] getInts() {
        // 获取源数组
        System.out.print("请输入源数组元素（以空格分隔）：");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] sourceArrayString = input.split(" ");
        int[] numbers = new int[sourceArrayString.length];
        for (int i = 0; i < sourceArrayString.length; i++) {
            numbers[i] = Integer.parseInt(sourceArrayString[i]);
        }
        return numbers;
    }
}

1.5 判断数组是否相同：

比较两个数组的内容是否一样：首先判断数组长度是否一致，然后逐一比较相同下标元素是否一样，全部一样返回真，否则假。

答：

package JavaHomework.Homework01;

import java.util.Scanner;

public class homework1_1_5_V1 {
    public static void main(String[] args) {
        int[] array1 = getInts(1);
        int[] array2 = getInts(2);


        boolean isEqual1 = compareArrays(array1, array2);

        if (isEqual1) {
            System.out.println("array1 和 array2 相等");
        } else {
            System.out.println("array1 和 array2 不相等");
        }
    }

    public static boolean compareArrays(int[] array1, int[] array2) {
        if (array1.length != array2.length) {
            return false; // 数组长度不一致，直接返回假
        }

        for (int i = 0; i < array1.length; i++) {
            if (array1[i] != array2[i]) {
                return false; // 逐一比较元素，如果有不同则返回假
            }
        }

        return true; // 所有元素都一样，返回真
    }

    // 获取源数组
    private static int[] getInts(int loop) {
        System.out.print("请输入第 " + loop + " 个源数组元素（以空格分隔）：");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] sourceArrayString = input.split(" ");
        int[] numbers = new int[sourceArrayString.length];
        for (int i = 0; i < sourceArrayString.length; i++) {
            numbers[i] = Integer.parseInt(sourceArrayString[i]);
        }
        return numbers;
    }
}

1.6 使用Arrays.fill使用某一个数值填充整个数组中的的各个元素中。

答：

package JavaHomework.Homework01;

import java.util.Arrays;
import java.util.Scanner;

public class homework1_1_6_V1 {
    public static void main(String[] args) {
        int[] array = new int[5];
        System.out.print("请输入想填充的数据：");
        Scanner scanner = new Scanner(System.in);
        int fillValue = scanner.nextInt();

        Arrays.fill(array, fillValue);

        System.out.println("填充后的数组：" + Arrays.toString(array));
    }
}

1.7 二维数组排序：

创建一个10*10二维数组，填充以0-100的随机数，使用选择法或者冒泡法排序。数组arr[0]的十个元素的排序优先于arr[1]，以此类推。可以使用sort方法进行排序吗？为什么不能或者编程实现之。

参考思路：先把二维数组使用System.arraycopy进行数组复制到一个一维数组，然后使用sort进行排序，最后再复制回到二维数组。

答：

package JavaHomework.Homework01;

import java.util.Arrays;

public class homework1_1_7_V1 {
    public static void main(String[] args) {
        int[][] array = new int[10][10];

        // 填充二维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = (int) (Math.random() * 101); // 生成0-100的随机整数
            }
        }

        // 对每行使用选择法排序
        for (int i = 0; i < array.length; i++) {
            selectionSort(array[i]);
        }

        // 输出排序后的二维数组
        for (int i = 0; i < array.length; i++) {
            System.out.println("第 " + i + " 行排序后的数组：" + Arrays.toString(array[i]));
        }
    }

    // 选择法排序
    public static void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
    }
}

2.数学方法

2.1 产生一个随机数，输出其小数部分四舍五入，开方，平方。再输出π和自然常数e。

package JavaHomework.Homework01;

public class homework1_2_1_V1 {
    public static void main(String[] args) {
        double randomValue = Math.random(); // 生成0-1之间的随机浮点数
        double roundedValue = Math.round(randomValue * 100) / 100.0; // 小数部分四舍五入
        double squareRoot = Math.sqrt(randomValue); // 开方
        double squaredValue = Math.pow(randomValue, 2); // 平方

        double pi = Math.PI; // π
        double e = Math.E; // 自然常数e

        System.out.println("随机数：" + randomValue);
        System.out.println("小数部分四舍五入：" + roundedValue);
        System.out.println("开方：" + squareRoot);
        System.out.println("平方：" + squaredValue);
        System.out.println("π：" + pi);
        System.out.println("自然常数e：" + e);
    }
}

2.2 计算自然数e

正在上传…重新上传取消

上图是自然对数的计算方式。

借助Math中的方法，把自然对数计算出来，看看经过自己计算的自然对数和Math.E的区别有多大。

提示：e的计算有另外一个等价的级数公式：

e=1+1/1!+1/2!+1/3!+…+1/n!+…

答：

package JavaHomework.Homework01;

public class homework1_2_2_V1 {
    public static void main(String[] args) {
        int n = 200; // 迭代次数，值越大，计算结果越精确

        double e = calculateE(n);
        System.out.println("自己计算的 e 的近似值为：" + e);
        System.out.println("Math.E = " + Math.E);
        double diff = e - Math.E;
        System.out.println("二者差异 = " + diff);
    }

    public static double calculateE(int n) {
        double e = 1.0; // 初始值为1

        // 计算阶乘
        for (int i = 1; i <= n; i++) {
            double factorial = 1.0;
            for (int j = 1; j <= i; j++) {
                factorial *= j;
            }

            e += 1.0 / factorial;
        }

        return e;
    }
}

2.3 声明Patient类表示在门诊室中的病人。

此类对象应包括ｎａｍｅ（ａ　ｓｔｒｉｎｇ）、ｓｅｘ（ａ　ｃｈａｒ）、age(an integer)、weight(a float)、allergies(a boolean)五个属性。

声明存取及修改方法。在一个单独的类中，声明测试方法，并用此方法生成两个Patient的例子：

              Patient april=new Patient();

              april.setName(“zhangli”)

april.setSex(‘f’);

april.setAge(330);

april.setWeigeht(154.72);

april.setAllergies(true);

System.out.println(“name：  ”+april.getName());

System.out.println(“sex:  ”+april.getSex());

System.out.println(“age:   ”+april.getAge());

System.out.println(“weight:  ”+april.getWeight());

System.out.println(“allergies:  ”+april.getAllergies());

声明并测试toString（）方法，它用来显示一个病人的age、sex、name及allergies属性（即打印功能）。

答：

package JavaHomework.Homework01;

class Patient {
    private String name;
    private char sex;
    private int age;
    private float weight;
    private boolean allergies;

    // Getter methods
    public String getName() {
        return name;
    }

    public char getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }

    public float getWeight() {
        return weight;
    }

    public boolean getAllergies() {
        return allergies;
    }

    // Setter methods
    public void setName(String name) {
        this.name = name;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setWeight(float weight) {
        this.weight = weight;
    }

    public void setAllergies(boolean allergies) {
        this.allergies = allergies;
    }

    @Override
    public String toString() {
        return "Name: " + name + " Sex: " + sex + " Age: " + age + " Weight: " + weight + " Allergies: " + allergies;
    }

}

public class homework1_2_3_V1 {
    public static void main(String[] args) {
        Patient april = new Patient();
        april.setName("zhangli");
        april.setSex('f');
        april.setAge(30);
        april.setWeight(184.72f);
        april.setAllergies(true);

        Patient neaby = new Patient();
        neaby.setName("lihua");
        neaby.setSex('f');
        neaby.setAge(50);
        neaby.setWeight(153.98f);
        neaby.setAllergies(false);

        System.out.print("Name: " + april.getName());
        System.out.print(" Sex: " + april.getSex());
        System.out.print(" Age: " + april.getAge());
        System.out.print(" Weight: " + april.getWeight());
        System.out.print(" Allergies: " + april.getAllergies() + "\n");

        System.out.println(april.toString());
        System.out.println(neaby.toString());
    }
}

2.4 声明并测试一个复数类，其方法包括toString（）及复数的加、减、乘运算（注意：虚数和实数计算方法的不同）。

答：

package JavaHomework.Homework01;

import java.util.Scanner;

class ComplexNumber  implements Comparable<ComplexNumber> {
    private double real;
    private double imaginary;

    public ComplexNumber(double real, double imaginary) {
        this.real = real;
        this.imaginary = imaginary;
    }

    public double getReal() {
        return real;
    }

    public double getImaginary() {
        return imaginary;
    }

    public ComplexNumber add(ComplexNumber other) {
        double realSum = this.real + other.real;
        double imaginarySum = this.imaginary + other.imaginary;
        return new ComplexNumber(realSum, imaginarySum);
    }

    public ComplexNumber subtract(ComplexNumber other) {
        double realDiff = this.real - other.real;
        double imaginaryDiff = this.imaginary - other.imaginary;
        return new ComplexNumber(realDiff, imaginaryDiff);
    }

    /*
    给定两个复数：z1 = a + bi 和 z2 = c + di，其中 a、b、c、d 是实数部分和虚数部分。
    1. 将两个复数相乘，得到实部和虚部的乘积：
    实部部分：(a * c) - (b * d)
    虚部部分：(a * d) + (b * c)
    2. 将实部和虚部组合成一个新的复数，得到乘积结果。
     */
    public ComplexNumber multiply(ComplexNumber other) {
        double realProduct = (this.real * other.real) - (this.imaginary * other.imaginary);
        double imaginaryProduct = (this.real * other.imaginary) + (this.imaginary * other.real);
        return new ComplexNumber(realProduct, imaginaryProduct);
    }

    @Override
    public String toString() {
        if (imaginary >= 0) {
            return real + " + " + imaginary + "i";
        } else {
            return real + " - " + Math.abs(imaginary) + "i";
        }
    }

    // Implementing compareTo method for comparing the magnitude of complex numbers
    @Override
    public int compareTo(ComplexNumber other) {
        double magnitude1 = Math.sqrt(real * real + imaginary * imaginary);
        double magnitude2 = Math.sqrt(other.real * other.real + other.imaginary * other.imaginary);

        if (magnitude1 < magnitude2) {
            return -1;
        } else if (magnitude1 > magnitude2) {
            return 1;
        } else {
            return 0;
        }
    }
}

public class homework1_2_4_6_V1 {
    public static void main(String[] args) {
        System.out.print("请输入第一个复数的实部和虚部（以空格分隔）：");
        Scanner scanner = new Scanner(System.in);
        String[] input = scanner.nextLine().split(" ");
        ComplexNumber num1 = new ComplexNumber(Integer.parseInt(input[0]), Integer.parseInt(input[1]));

        System.out.print("请输入第一个复数的实部和虚部（以空格分隔）：");
        input = scanner.nextLine().split(" ");
        ComplexNumber num2 = new ComplexNumber(Integer.parseInt(input[0]), Integer.parseInt(input[1]));

        ComplexNumber sum = num1.add(num2);
        ComplexNumber diff = num1.subtract(num2);
        ComplexNumber product = num1.multiply(num2);

        System.out.println("num1: " + num1);    // 注意这里和写 num1.toString() 效果是一样的
        System.out.println("num2: " + num2);
        System.out.println("Sum: " + sum);
        System.out.println("Difference: " + diff);
        System.out.println("Product: " + product);
    }
}

2.5 编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音。可以弹奏的乐器包括二胡、钢琴和琵琶。  

1)定义乐器类Instrument，包括抽象方法makeSound()

2)定义乐器类的子类：二胡Erhu、钢琴Piano和小提琴Violin

3)定义乐手类Musician，可以弹奏各种乐器play(Instrument i)

4)定义测试类，给乐手不同的乐器让他弹奏

答：

package JavaHomework.Homework01;

// 定义乐器类 Instrument
abstract class Instrument {
    public abstract void makeSound();
}

// 定义乐器类的子类
class Erhu extends Instrument {
    @Override
    public void makeSound() {
        System.out.println("二胡发出声音");
    }
}

class Piano extends Instrument {
    @Override
    public void makeSound() {
        System.out.println("钢琴发出声音");
    }
}

class Violin extends Instrument {
    @Override
    public void makeSound() {
        System.out.println("小提琴发出声音");
    }
}

// 定义乐手类 Musician
class Musician {
    public void play(Instrument i) {
        i.makeSound();
    }
}

// 测试类
public class homework1_2_5_V1 {
    public static void main(String[] args) {
        Musician musician = new Musician();

        // 创建不同的乐器对象并让乐手弹奏
        Instrument erhu = new Erhu();
        Instrument piano = new Piano();
        Instrument violin = new Violin();

        musician.play(erhu);
        musician.play(piano);
        musician.play(violin);
    }
}

2.6 增加一个按模比较复数大小的接口，并在题4的Complex类基础上实现之。

答：

代码见2.4

2.7 设计针对整数数组的多个接口：

接口1：返回数组元素的最大值

接口2：返回数组元素的最小值

接口3：返回数组的平均值

接口4：返回数组元素的方差

用一个类去实现所有这些接口。并编写代码进行正确性测试。

答：

package JavaHomework.Homework01;

import java.util.Scanner;

class IntArrayAnalyzer implements Maximum, Minimum, Average_Int, Variance {
    private int[] array;

    public IntArrayAnalyzer(int[] array) {
        this.array = array;
    }

    @Override
    public int findMaximum() {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }

    @Override
    public int findMinimum() {
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }
        return min;
    }

    @Override
    public double calculateAverage() {
        int sum = 0;
        for (int num : array) {
            sum += num;
        }
        return (double) sum / array.length;
    }

    @Override
    public double calculateVariance() {
        double average = calculateAverage();
        double sumOfSquares = 0;
        for (int num : array) {
            sumOfSquares += Math.pow(num - average, 2);
        }
        return sumOfSquares / array.length;
    }
}

public class homework1_2_7_V1 {
    public static void main(String[] args) {
        int[] array = getInts();
        IntArrayAnalyzer analyzer = new IntArrayAnalyzer(array);

        for (int num : array) {
            System.out.print(num + " ");
        }
        System.out.println();

        System.out.println("Maximum: " + analyzer.findMaximum());
        System.out.println("Minimum: " + analyzer.findMinimum());
        System.out.println("Average: " + analyzer.calculateAverage());
        System.out.println("Variance: " + analyzer.calculateVariance());
    }

    private static int[] getInts() {
        // 获取源数组
        System.out.print("请输入源数组元素（以空格分隔）：");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] sourceArrayString = input.split(" ");
        int[] numbers = new int[sourceArrayString.length];
        for (int i = 0; i < sourceArrayString.length; i++) {
            numbers[i] = Integer.parseInt(sourceArrayString[i]);
        }
        return numbers;
    }
}

interface Maximum {
    int findMaximum();
}

interface Minimum {
    int findMinimum();
}

interface Average_Int {
    double calculateAverage();
}

interface Variance {
    double calculateVariance();
}

2.8 （选做）增加一个求数组平均值的接口，让你可以计算复数数组、浮点数数组和整数数组的平均值。因为返回值类型不一样，你有什么办法呢？若不可能说明理由，若可能按照你的方法编写程序和相关测试代码验证之。  

答：

package JavaHomework.Homework01;

interface Average<T> {
    T calculateAverage(T[] array);
}

class Complex {
    private double real;
    private double imaginary;

    // 构造函数和其他方法
    public Complex(double real, double imaginary) {
        this.real = real;
        this.imaginary = imaginary;
    }

    // getter 和 setter 方法
    public double getReal() {
        return real;
    }

    public double getImaginary() {
        return imaginary;
    }

    public Complex add(Complex other) {
        double realSum = this.real + other.real;
        double imaginarySum = this.imaginary + other.imaginary;
        return new Complex(realSum, imaginarySum);
    }

    @Override
    public String toString() {
        if (imaginary >= 0) {
            return real + " + " + imaginary + "i";
        } else {
            return real + " - " + Math.abs(imaginary) + "i";
        }
    }
}

class ArrayAnalyzer {
    public static <T> T calculateAverage(T[] array) {
        if (array == null || array.length == 0) {
            return null;
        }

        if (array[0] instanceof Integer) {
            int sum = 0;
            for (T num : array) {
                sum += (Integer) num;
            }
            return (T) Integer.valueOf(sum / array.length);
        } else if (array[0] instanceof Double) {
            double sum = 0.0;
            for (T num : array) {
                sum += (Double) num;
            }
            return (T) Double.valueOf(sum / array.length);
        } else if (array[0] instanceof Complex) {
            Complex sum = new Complex(0, 0);
            for (T num : array) {
                sum = sum.add((Complex) num);
            }
            double averageReal = sum.getReal() / array.length;
            double averageImaginary = sum.getReal() / array.length;
            return (T) new Complex(averageReal, averageImaginary);
        }

        return null;
    }
}

public class homework1_2_8_V1 {
    public static void main(String[] args) {
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.5, 2.5, 3.5, 4.5, 5.5 };
        Complex[] complexArray = { new Complex(1, 2), new Complex(2, 3), new Complex(3, 4) };

        Integer intAvg = ArrayAnalyzer.calculateAverage(intArray);
        Double doubleAvg = ArrayAnalyzer.calculateAverage(doubleArray);
        Complex complexAvg = ArrayAnalyzer.calculateAverage(complexArray);

        System.out.println("Integer array average: " + intAvg);
        System.out.println("Double array average: " + doubleAvg);
        System.out.println("Complex array average: " + complexAvg);
    }
}