Java中跨类访问数组与方法：面向对象实践指南-java教程-PHP中文网

Java中跨类访问数组与方法：面向对象实践指南

本文旨在指导Java初学者如何在不同类之间高效且符合面向对象原则地访问和操作数组与方法，避免对static import的依赖。我们将探讨通过对象实例化（组合）、静态方法调用等多种方式实现跨类协作，并分析其适用场景与最佳实践，以构建结构清晰、可维护的Java应用程序。

理解跨类访问的需求

在java编程中，为了保持代码的模块化和可维护性，我们通常会将相关的功能封装在不同的类中。例如，一个类可能专门负责数组的操作（如输入、打印、排序），而另一个主类则负责协调这些操作的执行。当主类需要调用其他类中定义的方法或访问其数据时，就需要掌握正确的跨类访问机制。

原始代码示例展示了一个名为Arrays（为避免与java.util.Arrays混淆，通常建议重命名为ArrayOperations或ArrayUtils）的类，其中包含获取整数数组、打印数组和排序数组的静态方法。主类Main试图直接调用这些方法。虽然static import可以简化静态方法的调用，但有时我们希望遵循更严格的面向对象原则，通过对象实例来交互。

原始 ArrayOperations 类（为清晰起见，已重命名）：

import java.util.Scanner;

public class ArrayOperations {

    // 静态Scanner，所有静态方法共享
    public static Scanner scan = new Scanner(System.in);

    // 静态方法：获取用户输入的整数数组
    public static int[] getIntegers(int number) {
        System.out.println("请输入 " + number + " 个整数\r");
        int[] entered = new int[number];
        for(int i = 0; i < entered.length; i++) {
            entered[i] = scan.nextInt();
        }
        return entered;
    }

    // 静态方法：打印数组内容
    public static void printArray(int[] entered) {
        for(int i = 0; i < entered.length; i++) {
            System.out.println("元素 " + i + ", 输入的值为 " + entered[i]);
        }
    }

    // 静态方法：对数组进行降序排序
    public static int[] sortIntegers(int[] entered) {
        // 创建一个副本进行排序，不修改原数组
        int[] sortedArray = new int[entered.length];
        System.arraycopy(entered, 0, sortedArray, 0, entered.length); // 更高效的数组复制

        boolean flag = true;
        int temp;
        while(flag) {
            flag = false;
            for(int i = 0; i < sortedArray.length - 1; i++) {
                if(sortedArray[i] < sortedArray[i + 1]) { // 降序排列
                    temp = sortedArray[i];
                    sortedArray[i] = sortedArray[i + 1];
                    sortedArray[i + 1] = temp;
                    flag = true; // 发生了交换，可能还需要下一轮
                }
            }
        }
        return sortedArray;
    }
}

登录后复制

原始 Main 类：

public class Main {
    public static void main (String[] args) {
        // 直接调用 ArrayOperations 类中的静态方法
        int[] myIntegers = ArrayOperations.getIntegers(5); // 注意：这里需要通过类名调用
        int[] sorted = ArrayOperations.sortIntegers(myIntegers);
        ArrayOperations.printArray(myIntegers);
        ArrayOperations.printArray(sorted);
    }
}

登录后复制

请注意，即使没有static import，只要ArrayOperations类在同一个包中或被正确导入，Main类也可以通过ArrayOperations.methodName()的形式直接调用其public static方法。用户提出的问题是想了解在不使用static import的情况下，如何以“OOP标准”来访问这些功能。

立即学习“Java免费学习笔记（深入）”；

Java中跨类成员访问的几种主要方式

在Java中，实现跨类访问有多种策略，每种策略都有其特定的适用场景和优缺点。

1. 通过对象实例化（组合）：推荐的面向对象方法

这是最符合面向对象封装原则的方法。当一个类（如Main）需要使用另一个类（如ArrayOperations）的功能时，它应该创建该类的一个实例（对象），然后通过这个实例来调用其非静态方法。这种关系被称为“组合”或“has-a”关系。

优点：

多面鹅

面向求职者的AI面试平台

查看详情

封装性好： 不同的对象可以拥有自己的状态。
灵活性高： 可以轻松地替换实现（多态）。
符合OOP原则： 鼓励通过对象而不是类本身进行交互。
易于测试： 方便进行单元测试和模拟。

实现步骤：

将目标类中的方法改为非静态（如果它们依赖于对象状态或你希望每个对象有独立的行为）。
在需要调用这些方法的类中，创建目标类的一个实例。
通过该实例调用其方法。

重构 ArrayOperations 类（方法改为非静态）：

import java.util.Scanner;

public class ArrayOperations {

    // Scanner现在是实例字段，每个ArrayOperations对象都有自己的Scanner
    private Scanner scan;

    // 构造器：初始化Scanner
    public ArrayOperations() {
        this.scan = new Scanner(System.in);
    }

    // 非静态方法：获取用户输入的整数数组
    public int[] getIntegers(int number) {
        System.out.println("请输入 " + number + " 个整数\r");
        int[] entered = new int[number];
        for(int i = 0; i < entered.length; i++) {
            entered[i] = scan.nextInt();
        }
        // 注意：通常不建议关闭System.in，除非程序即将退出
        // scan.close(); // 如果Scanner是本地创建的，则可以关闭
        return entered;
    }

    // 非静态方法：打印数组内容
    public void printArray(int[] entered) {
        for(int i = 0; i < entered.length; i++) {
            System.out.println("元素 " + i + ", 输入的值为 " + entered[i]);
        }
    }

    // 非静态方法：对数组进行降序排序
    public int[] sortIntegers(int[] entered) {
        int[] sortedArray = new int[entered.length];
        System.arraycopy(entered, 0, sortedArray, 0, entered.length);

        boolean flag = true;
        int temp;
        while(flag) {
            flag = false;
            for(int i = 0; i < sortedArray.length - 1; i++) {
                if(sortedArray[i] < sortedArray[i + 1]) {
                    temp = sortedArray[i];
                    sortedArray[i] = sortedArray[i + 1];
                    sortedArray[i + 1] = temp;
                    flag = true;
                }
            }
        }
        return sortedArray;
    }
}

登录后复制

重构 Main 类（通过实例化调用）：

public class Main {
    public static void main (String[] args) {
        // 创建 ArrayOperations 类的实例
        ArrayOperations operations = new ArrayOperations();

        // 通过实例调用其非静态方法
        int[] myIntegers = operations.getIntegers(5);
        int[] sorted = operations.sortIntegers(myIntegers);
        operations.printArray(myIntegers);
        operations.printArray(sorted);
    }
}

登录后复制

注意事项： 当Scanner作为实例变量时，它的生命周期与ArrayOperations对象绑定。如果ArrayOperations对象在main方法中创建并使用完毕后，Scanner也应该被关闭以释放资源。然而，关闭System.in通常会导致整个应用程序无法再次从标准输入读取，因此在实际应用中需要谨慎处理。对于本教程的简单示例，我们暂时忽略scan.close()，但请在生产代码中注意资源管理。

2. 使用静态成员（工具类方法）

如果一个方法不依赖于任何对象的状态（即它不需要访问类的实例变量），并且它执行的是通用工具性质的操作，那么将其声明为static是合理的。例如，数学函数Math.sqrt()就是静态方法。

优点：

无需实例化： 可以直接通过类名调用，无需创建对象。
内存效率： 没有实例字段，不会占用额外的对象内存。
适用于工具类： 非常适合提供通用实用功能的类。

缺点：

面向对象特性弱化： 静态方法不能访问非静态成员，限制了其与对象状态的交互。
难以测试： 静态方法难以被模拟或替换，增加了单元测试的难度。
过度使用可能导致设计问题： 如果所有方法都是静态的，那么这个类可能更像一个模块而不是一个真正的面向对象类。

实现方式（如原始代码所示）： 将方法声明为public static。在调用时，通过ClassName.methodName()的方式访问。

// ArrayOperations 类保持原始的静态方法声明不变
// ...

public class Main {
    public static void main (String[] args) {
        // 直接通过类名调用静态方法
        int[] myIntegers = ArrayOperations.getIntegers(5);
        int[] sorted = ArrayOperations.sortIntegers(myIntegers);
        ArrayOperations.printArray(myIntegers);
        ArrayOperations.printArray(sorted);
    }
}

登录后复制

这种方式是原始代码实际采用的，也是非常常见的工具类设计模式。用户提到的import static className.*只是为了在调用时省略ClassName.前缀，本质上仍是调用静态方法。

3. 继承（extends）：不适用于此场景

继承（public class Child extends Parent）用于建立“is-a”关系。如果Main类是ArrayOperations类的一种特殊类型，那么使用继承是合适的。例如，Car extends Vehicle。

为什么不适用于此场景：

Main类和ArrayOperations类之间没有“is-a”的逻辑关系。Main不是一个ArrayOperations，它只是使用ArrayOperations的功能。
Java只支持单继承，如果Main类继承了ArrayOperations，它就不能再继承其他类了，这会限制其未来的扩展性。
继承会暴露父类的所有protected和public成员给子类，这可能违反封装原则。

因此，对于这种仅仅是使用另一个类功能的场景，继承通常不是一个好的选择。

4. 接口（interface）：通常过于复杂

接口（interface）定义了一组行为规范。一个类可以实现（implements）一个或多个接口，从而承诺提供这些行为的实现。

为什么不适用于此场景：

对于仅仅是调用一些工具方法的需求，引入接口会增加不必要的复杂性。
接口主要用于定义契约、实现多态或解耦，而不是直接提供功能实现。
虽然可以定义一个包含数组操作方法的接口，然后让ArrayOperations实现它，再让Main通过接口引用ArrayOperations对象，但这对于简单的工具方法调用来说是过度设计。

重构与最佳实践

根据上述讨论，对于你的需求，最符合“OOP标准”且灵活的方式是通过对象实例化（组合）。如果你确定这些方法确实不依赖于任何对象状态，并且仅仅是提供通用工具功能，那么保持它们为静态方法也是一种合理且常见的做法。

推荐的重构思路：

类名优化： 将Arrays类重命名为更具描述性的ArrayOperations或ArrayUtils，以避免与java.util.Arrays混淆，并清晰表达其职责。
方法性质判断：
- 如果方法需要维护状态（例如，如果Scanner是每次操作独立的，或者类中还有其他需要被不同方法共享和修改的实例变量），则使用非静态方法并通过对象实例化来调用。这是更典型的面向对象设计。
- 如果方法是纯粹的函数式，不依赖于任何实例状态，并且可以被广泛重用，那么将其设计为public static方法，并封装在一个工具类中（如ArrayUtils），是完全合理的。
资源管理： 如果类中创建了Scanner或其他需要关闭的资源，确保在对象不再需要时关闭它们。对于System.in，通常不建议在应用程序中关闭，因为它会影响整个应用程序的标准输入。

总结

在Java中，从另一个类中获取（或更准确地说，是使用）数组和方法，主要有两种符合不同“OOP标准”的实践：

面向对象实例化（组合）：将方法设计为非静态，并在需要使用的类中创建目标类的一个实例。通过这个实例调用方法。这强调了对象间的协作，提供了更高的灵活性和更好的封装性。
静态方法调用：将方法设计为public static。在需要使用的类中，直接通过类名调用这些静态方法。这适用于提供通用工具功能或不依赖任何对象状态的方法。

继承和接口在更复杂的场景中发挥作用，但对于仅仅是调用其他类提供的数组操作功能而言，它们通常不是最直接或最合适的解决方案。理解这两种主要方式的优缺点和适用场景，将有助于你编写出结构清晰、高效且符合Java编程范式的代码。

以上就是Java中跨类访问数组与方法：面向对象实践指南的详细内容，更多请关注php中文网其它相关文章！