Java跨类方法与数据共享：面向对象设计实践指南-java教程-PHP中文网

Java跨类方法与数据共享：面向对象设计实践指南

本文旨在探讨在Java中如何在不同类之间共享方法和数据，特别是当需要从一个类（如Arrays工具类）调用另一个类（如Main主程序）的方法时。文章将详细阐述如何通过直接类名调用静态方法以及通过对象实例实现组合两种主要策略，并分析继承和接口在此场景下的适用性，最终提供遵循面向对象原则的最佳实践建议。

理解问题：跨类方法调用与OOP原则

在java开发中，我们经常需要将功能模块化到不同的类中，以提高代码的可维护性和复用性。然而，当一个类需要使用另一个类中定义的方法和数据时，如何正确地进行引用和调用，同时遵循面向对象（oop）的设计原则，是初学者常遇到的问题。

例如，考虑以下两个Java类：一个名为Arrays的类，其中包含用于获取、打印和排序整数数组的静态方法；另一个名为Main的类，作为程序的入口，需要调用Arrays类中的这些方法。

原始Arrays类代码：

import java.util.Scanner;

public class Arrays {

    public static Scanner scan = new Scanner(System.in); // 注意：静态Scanner可能导致资源管理问题

    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];
        // 复制数组内容
        for(int i = 0; i < entered.length; i++) {
            sortedArray[i] = entered[i];
        }

        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类代码（尝试直接调用，这需要static import或方法存在于Main中）：

public class Main {

    public static void main (String[] args) {
        // 以下调用在没有 static import 或方法定义在 Main 类中的情况下会编译错误
        int[] myIntegers = getIntegers(5);
        int[] sorted = sortIntegers(myIntegers);
        printArray(myIntegers);
        printArray(sorted);
    }
}

登录后复制

用户希望在Main类中调用Arrays类中的getIntegers、printArray和sortIntegers方法，但又不想使用static import（import static com.example.Arrays.*），而是希望通过更符合OOP“标准”的方式来实现。

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

方案一：直接通过类名调用静态方法

如果一个方法被声明为static，它属于类本身而不是类的任何特定实例。在这种情况下，最直接且符合OOP规范的调用方式是使用ClassName.methodName()的格式。这避免了static import，同时明确指出了方法所属的类。

修改后的Main类代码：

public class Main {

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

        // 注意：静态Scanner在程序结束时需要关闭，否则可能导致资源泄露
        // 可以在Arrays类中添加一个方法来关闭它，或者在Main中处理
        Arrays.scan.close();
    }
}

登录后复制

适用场景： 这种方法适用于当方法是纯粹的工具函数，不依赖于任何对象实例的状态，或者说，它们的操作只与输入参数有关，而与Arrays类的任何特定“对象”无关。java.lang.Math类中的所有方法就是典型的静态方法示例。

注意事项：

静态资源管理： Arrays类中声明了一个静态的Scanner对象。静态资源在整个应用程序生命周期中只初始化一次。在使用完毕后，必须手动关闭它以释放系统资源，否则可能导致资源泄露。通常，Scanner对象应在需要时创建，使用后关闭，而不是作为静态成员。
OOP原则： 尽管这种方式是合法的，但过度使用静态方法可能导致面向对象设计的“贫血模型”，即类只包含数据和静态方法，缺乏行为和状态的封装。

方案二：通过对象实例实现组合（更符合面向对象设计）

如果方法需要操作对象的状态，或者我们希望更好地封装行为，那么通过创建类的实例（对象）并调用其方法是更符合面向对象设计（OOP）的“组合”原则的方式。这意味着一个类“拥有”另一个类的对象，并委托该对象执行特定任务。

为了实现这一点，我们需要对Arrays类进行改造，使其方法成为实例方法。

步骤1：将Arrays类改造为非静态方法

移除方法前的static关键字，并将Scanner作为实例成员，以便每个Arrays对象都能管理自己的输入流。

import java.util.Scanner;

public class ArrayOperations { // 将类名改为ArrayOperations以避免与java.util.Arrays冲突，并更符合其职责

    private Scanner scan; // 作为实例成员

    // 构造函数，用于初始化Scanner
    public ArrayOperations() {
        this.scan = new Scanner(System.in);
    }

    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];
        for(int i = 0; i < entered.length; i++) {
            sortedArray[i] = entered[i];
        }

        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;
    }

    // 添加一个方法来关闭Scanner资源
    public void closeScanner() {
        if (scan != null) {
            scan.close();
        }
    }
}

登录后复制

步骤2：在Main类中创建ArrayOperations对象实例

美图设计室

5分钟在线高效完成平面设计，AI帮你做设计

查看详情

在Main类中创建ArrayOperations的一个实例，并通过该实例来调用其方法。

public class Main {

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

        int[] myIntegers = arrayOps.getIntegers(5);
        int[] sorted = arrayOps.sortIntegers(myIntegers);
        arrayOps.printArray(myIntegers);
        arrayOps.printArray(sorted);

        // 使用完毕后关闭资源
        arrayOps.closeScanner();
    }
}

登录后复制

优势：

封装性： Scanner现在是ArrayOperations对象的一部分，其生命周期与对象实例绑定，管理更清晰。
灵活性： 如果需要，可以创建多个ArrayOperations实例，每个实例可以有不同的内部状态（尽管在这个例子中不明显）。
可测试性： 实例方法更容易进行单元测试，因为它们可以针对特定的对象状态进行测试。
符合OOP： 这种“has-a”（Main类“拥有”一个ArrayOperations对象）的关系是组合的核心，它促进了更好的模块化和解耦。

不推荐的方案：继承与接口

在原始问题中，也提到了继承（extends）和接口（interface）作为可能的方案。然而，对于这种简单的跨类方法调用需求，它们通常不是最佳选择。

1. 继承（extends）

继承表示一种“is-a”的关系。如果Main类继承ArrayOperations类（public class Main extends ArrayOperations），那么Main类将拥有ArrayOperations类的所有非私有成员和方法。

为什么不推荐：

不符合“is-a”语义： Main类“是”一个ArrayOperations类，这在逻辑上是不合理的。Main类是一个程序的入口，而ArrayOperations是一个执行数组操作的工具。它们之间没有自然的父子关系。
Java单继承限制： Java只支持单继承，这意味着如果Main已经继承了ArrayOperations，它就不能再继承其他任何类，这会极大地限制其未来的扩展性。
过度耦合： 继承会造成父子类之间紧密的耦合，子类会继承父类的实现细节，使得代码难以修改和维护。

2. 接口（interface）

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

为什么不推荐：

过度设计： 对于仅仅是调用另一个类的现有方法而言，引入接口会增加不必要的复杂性。接口主要用于定义多态行为或实现回调机制。
不适用于静态方法： 接口不能直接包含静态方法的抽象定义（Java 8及以后版本允许接口有静态方法实现，但这与定义行为契约的目的不同）。如果ArrayOperations的方法是静态的，接口就无法直接定义这些行为。
增加工作量： 如果要使用接口，你需要先定义一个接口，然后让ArrayOperations实现它，再考虑Main如何利用这个接口，这比直接调用或组合要复杂得多。

总结与最佳实践

在Java中实现跨类方法调用时，选择合适的机制至关重要：

静态方法调用（ClassName.methodName()）：
- 适用场景： 当方法是无状态的、纯粹的工具函数，不依赖于任何对象实例的内部数据时。例如，数学计算、字符串工具等。
- 优点： 简单直接，无需创建对象。
- 缺点： 过度使用可能导致“贫血模型”，难以进行依赖注入和测试。静态资源（如Scanner）需要特别注意生命周期管理。
通过对象实例实现组合：
- 适用场景： 当方法需要操作对象的状态，或者希望将相关行为和数据封装在一个独立的模块中时。这是最符合面向对象原则的方式。
- 优点： 良好的封装性、高内聚低耦合、易于扩展和测试、资源管理更清晰。
- 缺点： 需要创建对象实例。
避免继承和接口（在此特定场景下）：
- 继承： 仅在存在明确的“is-a”关系时使用，且要警惕Java的单继承限制和紧密耦合问题。
- 接口： 主要用于定义行为契约和实现多态，不适用于简单的工具方法共享。

对于本教程中的数组操作示例，如果这些方法确实是无状态的工具函数，方案一（通过类名调用静态方法）是简洁有效的。但如果考虑到Scanner等资源管理以及更严格的OOP设计，将ArrayOperations改造为实例类并通过组合方式调用（方案二）会是更健壮和灵活的选择。在实际开发中，应根据方法的性质和类的职责来权衡选择。

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