面向对象【对象数组的使用与内存分析、方法重载、可变个数形参】

对象数组

存储对象引用的数组。它允许您在单个数组中存储多个对象，并通过索引访问和操作这些对象。

实例

创建一个 Student 学生类，该类可以具有学生的属性（例如姓名、年龄等）。

public class Student {
    private String name;
    private int age;
     public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
	 public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
     // Getters and setters (省略)
     // 其他方法 (省略)
}

创建一个学生对象数组，并对其进行初始化和操作

	public class Main {
	    public static void main(String[] args) {
	        Student[] studentArray = new Student[3];
	         // 初始化学生对象数组
	        studentArray[0] = new Student("张三", 20);
	        studentArray[1] = new Student("李四", 22);
	        studentArray[2] = new Student("王五", 21);
	         // 遍历学生对象数组并输出学生信息
	        for (int i = 0; i < studentArray.length; i++) {
	            System.out.println("姓名：" + studentArray[i].getName() + "，年龄：" + studentArray[i].getAge());
	        }
	    }
	}

对象内存分析

方法的重载

方法的重载（Method Overloading）是指在同一个类中，允许存在多个同名方法，但这些方法的参数列表必须不同。方法的重载是通过改变方法的参数类型、参数个数或参数顺序来实现的（不包括参数名称）。

重载方法调用

1. 如果传入的参数类型与某个重载方法的参数类型完全匹配，则直接调用该方法。
2. 如果传入的参数类型与多个重载方法的参数类型都匹配，但有一个方法的参数类型更具体，则调用该方法。例如，如果有一个方法接受参数类型为 int ，而另一个方法接受参数类型为 double ，而传入的参数为 5.0 ，则会调用参数类型为 double 的方法。
3. 如果传入的参数类型与多个重载方法的参数类型都匹配，且没有一个方法的参数类型更具体，则会产生编译错误，因为编译器无法确定具体调用哪个方法。

public class MyClass {
    public void printMessage() {
        System.out.println("Hello!");
    }
     public void printMessage(String message) {
        System.out.println("Hello, " + message);
    }
     public void printMessage(int number) {
        System.out.println("The number is: " + number);
    }
     public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.printMessage(); // 调用无参方法
        myObj.printMessage("World"); // 调用带有字符串参数的方法
        myObj.printMessage(10); // 调用带有整数参数的方法
    }
}

打印方法的重载

    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3};
        System.out.println(arr);//地址值

        char[] arr2 = new char[]{'a', 'b', 'c'};
        System.out.println(arr2);//abc

        boolean[] arr3 = new boolean[]{true, false};
        System.out.println(arr3);//地址值
    }

可变个数形参的方法

使用可变个数的形参来定义一个方法，这样可以接受任意数量的参数。可变个数的形参使用三个点(…)来表示，放在方法的参数列表中的最后一个参数位置。

特点

1. 可以接受任意数量的参数：可变个数的形参允许方法接受任意数量的参数，包括零个参数。这使得方法在处理不同数量的参数时更加灵活。
2. 使用数组来处理参数：在方法体内，可变个数的形参被当作数组来处理。方法可以使用数组相关的操作，如遍历、获取长度等来处理这些参数。
3. 必须是方法的最后一个参数：可变个数的形参必须是方法参数列表中的最后一个参数。这是因为在方法调用时，编译器会根据参数的数量和类型来匹配方法，如果可变个数的形参不是最后一个参数，会导致参数的匹配出现歧义。
4. 可以与其他参数共存：可变个数的形参可以与其他参数共存。方法可以同时拥有可变个数的形参和其他类型的参数，但可变个数的形参必须是最后一个参数。
5. 可以传递数组或多个参数：在方法调用时，可以直接传递一个数组作为可变个数的形参，也可以传递多个参数，编译器会将这些参数封装为一个数组。

举例：

传递任意数量的参数

public static void printNumbers(int... numbers) {
    for (int number : numbers) {
        System.out.println(number);
    }
}
 public static void main(String[] args) {
    printNumbers(1, 2, 3);
    printNumbers(4, 5);
    printNumbers();
}

与其他参数共存

public static void printInfo(String name, int... scores) {
    System.out.println("姓名：" + name);
    System.out.println("成绩：");
    for (int score : scores) {
        System.out.println(score);
    }
}
 public static void main(String[] args) {
    printInfo("张三", 80, 90, 85);
    printInfo("李四");
}

传递数组或多个参数

public static void printNames(String... names) {
    for (String name : names) {
        System.out.println(name);
    }
}
 public static void main(String[] args) {
    String[] studentNames = {"张三", "李四", "王五"};
    printNames(studentNames);
    printNames("赵六", "孙七");
}