Java跨类操作数组与方法的面向对象技巧

在Java编程中，将功能模块化到不同的类中是良好的实践。当我们需要在一个类（如 Main 类）中调用另一个类（如 ArrayProcessor 类）中定义的数组操作方法时，有多种方式可以实现，其中最常见且符合面向对象原则的方法包括直接引用静态成员和通过对象实例化调用实例方法。

1. 理解静态方法与直接引用

在您提供的初始代码中，Arrays 类（为避免与 java.util.Arrays 混淆，我们后续将其重命名为 ArrayProcessor）中的 getIntegers、printArray 和 sortIntegers 方法都被声明为 static。这意味着它们是类级别的成员，不依赖于任何特定的对象实例。

原始 ArrayProcessor 类（重命名并包含原始逻辑）:

import java.util.Scanner;

public class ArrayProcessor { // 重命名为 ArrayProcessor

    public static Scanner scan = new Scanner(System.in);

    public static int[] getIntegers(int number) {
        System.out.println("Please enter " + number + " numbers\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("Element " + i + ", typed value was " + entered[i]);
        }
    }

    public static int[] sortIntegers(int[] entered) {
        int[] sortedArray = new int[entered.length];
        // 使用 System.arraycopy 提高数组复制效率
        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;
    }
}

对于静态方法，您无需创建 ArrayProcessor 类的实例即可调用它们。您可以通过 类名.方法名() 的形式直接访问。这满足了您“不使用 import static”的要求，因为 import static 只是允许您省略 类名. 前缀，但直接使用 类名.方法名() 仍然是有效的。

在 Main 类中调用静态方法：

public class Main {

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

这种方式对于工具类（Utility Class）非常常见，例如 java.lang.Math 或 java.util.Collections 中的许多方法都是静态的。

2. 面向对象设计：实例方法与对象实例化

如果您的 ArrayProcessor 类需要维护某种状态（例如，一个特定的数组实例），或者您希望其方法行为与特定的对象实例相关联，那么就应该使用实例方法（非静态方法）并通过对象实例化来调用它们。

修改 ArrayProcessor 类为实例方法：

我们将移除方法前的 static 关键字。Scanner 作为一个共享资源，可以保持为静态，或者也可以根据设计需要将其封装到 ArrayProcessor 的实例中。这里我们保持 Scanner 静态以简化示例。

import java.util.Scanner;

public class ArrayProcessor {

    public static Scanner scan = new Scanner(System.in); // Scanner 保持静态

    // 变为实例方法
    public int[] getIntegers(int number) {
        System.out.println("Please enter " + number + " numbers\r");
        int[] entered = new int[number];
        for(int i = 0; i < entered.length; i++) {
            entered[i] = scan.nextInt();
        }
        return entered;
    }

    // 变为实例方法
    public void printArray(int[] entered) {
        for(int i = 0; i < entered.length; i++) {
            System.out.println("Element " + i + ", typed value was " + 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 类中通过对象实例化调用实例方法：

现在，为了在 Main 类中使用这些方法，您需要先创建 ArrayProcessor 类的一个实例。

public class Main {

    public static void main (String[] args) {
        // 创建 ArrayProcessor 类的实例
        ArrayProcessor processor = new ArrayProcessor();

        // 通过实例对象调用方法
        int[] myIntegers = processor.getIntegers(5);
        int[] sorted = processor.sortIntegers(myIntegers);
        processor.printArray(myIntegers);
        processor.printArray(sorted);
    }
}

这种方法是更典型的面向对象编程范式，它允许您创建多个 ArrayProcessor 对象，每个对象都可以独立地执行其操作，如果 ArrayProcessor 内部有实例变量，它们的状态将是独立的。

3. 其他高级OOP模式：继承与接口

在Java中，除了直接引用和对象实例化外，继承（Inheritance）和接口（Interfaces）是两种重要的面向对象机制。然而，对于简单地“引入”其他类的功能，它们通常不是首选，除非存在特定的设计需求。

3.1 继承 (Inheritance)

继承允许一个类（子类）从另一个类（父类）获取字段和方法。在Java中，使用 extends 关键字实现。

// 假设 ArrayProcessor 是父类
public class MyMainProcessor extends ArrayProcessor {
    public static void main(String[] args) {
        // 子类可以直接访问父类的公共（或受保护）方法
        // 注意：如果 ArrayProcessor 的方法是实例方法，子类需要先创建实例
        // 或者将父类方法变为静态，如原始代码所示

        // 如果 ArrayProcessor 的方法是静态的，可以直接通过父类名或子类名访问
        int[] myIntegers = ArrayProcessor.getIntegers(5); // 推荐使用父类名

        // 如果 ArrayProcessor 的方法是实例方法，且子类需要使用，
        // 则子类也需要创建 ArrayProcessor 实例或自身实例来调用
        MyMainProcessor mainProcessor = new MyMainProcessor();
        // int[] myIntegers = mainProcessor.getIntegers(5); // 假设 getIntegers 是非静态的
    }
}

适用性与局限性：

• “is-a”关系： 继承应该用于表达“is-a”（是一个）的关系，例如“猫是一种动物”。Main 类通常不是一个 ArrayProcessor。
• 单继承： Java只支持单继承，一个类不能同时继承多个父类，这限制了其在某些场景下的灵活性。
• 紧耦合： 继承会创建父类和子类之间的紧密耦合，可能导致设计僵化。
• 不适用于工具方法： 对于像 getIntegers 这样的工具方法，继承通常不是一个好的选择，因为它混淆了类的职责。

3.2 接口 (Interfaces)

接口定义了一组方法签名，但不提供实现。一个类可以实现（implements）一个或多个接口，从而承诺提供这些方法的具体实现。

// 定义一个接口
public interface ArrayOperations {
    int[] getIntegers(int number);
    void printArray(int[] entered);
    int[] sortIntegers(int[] entered);
}

// ArrayProcessor 实现该接口
public class ArrayProcessor implements ArrayOperations {
    public static Scanner scan = new Scanner(System.in);

    @Override
    public int[] getIntegers(int number) { /* 实现细节 */ return new int[0]; }
    @Override
    public void printArray(int[] entered) { /* 实现细节 */ }
    @Override
    public int[] sortIntegers(int[] entered) { /* 实现细节 */ return new int[0]; }
}

// Main 类可以依赖于接口，而不是具体的实现
public class Main {
    public static void main(String[] args) {
        ArrayOperations processor = new ArrayProcessor(); // 多态性
        int[] myIntegers = processor.getIntegers(5);
        // ...
    }
}

适用性与局限性：

• “can-do”关系： 接口用于表达“can-do”（能做）的关系，例如“鸟会飞”。它定义了行为契约。
• 多实现： 一个类可以实现多个接口，提供了更大的灵活性。
• 解耦： 接口有助于实现代码的解耦，使得 Main 类不直接依赖于 ArrayProcessor 的具体实现，而是依赖于其定义的行为。
• 过度设计： 对于仅仅是想在 Main 类中调用 ArrayProcessor 的几个方法而言，引入接口可能会增加不必要的复杂性，除非您有明确的多态性或插件式架构需求。

4. 设计考量与最佳实践

• 静态方法 vs. 实例方法：
  • 如果方法不依赖于对象的任何特定状态（即它不使用任何实例变量），并且它执行的是一个通用操作，那么将其设计为静态方法是合理的。例如，数学函数、工厂方法或简单的工具方法。
  • 如果方法需要访问或修改对象的特定状态，或者其行为与对象的身份紧密相关，那么它应该是一个实例方法。
• Main 类的职责： Main 类通常作为程序的入口点，其主要职责是协调和启动其他类的功能。它不应该包含过多的业务逻辑。将数组处理逻辑封装在 ArrayProcessor 类中是一个很好的实践。
• 单一职责原则 (SRP)： 每个类或模块都应该只有一个改变的理由。ArrayProcessor 负责数组处理，Main 负责程序流程控制。
• import static 的作用： import static 只是一个语法糖，它允许您在调用静态方法时省略类名。它并不会改变方法本身的静态性质或访问权限。对于偶尔使用的静态方法，直接使用 类名.方法名() 往往更清晰，因为它明确指出了方法的来源。

总结

在Java中，从另一个类“引入”数组和方法，最直接且符合您需求的方式是：如果方法是静态的，则通过 类名.方法名() 直接调用；如果方法是实例方法，则需要先创建类的实例，然后通过 实例对象.方法名() 调用。继承和接口是更高级的OOP设计模式，它们在构建复杂、可扩展的系统时发挥重要作用，但对于简单的功能共享场景，可能显得过于复杂。选择哪种方式取决于您类的设计意图和方法的功能特性。