欢迎来到奈瑶·映南科技互联网学院
技术教程

如何在Java中从主类访问由其他类构造函数创建的对象

霞舞 次阅读

本文深入探讨了在java中从主类访问由另一个类的构造函数内部创建的对象的常见问题。核心症结在于对象被错误地声明为局部变量，导致其作用域受限。教程将详细阐述如何通过将此类对象提升为类的成员变量来解决作用域问题，并通过实例化的对象进行正确访问，同时强调了使用getter方法来遵循封装原则，并提供了处理多个相关对象的最佳实践建议。

在Java面向对象编程中，理解变量的作用域至关重要。当一个对象在另一个类的构造函数中创建时，如果它被声明为局部变量，那么它将只在该构造函数的作用域内有效，外部类或方法将无法直接访问它。本教程将通过一个具体的案例，详细讲解如何正确地创建和访问这类对象。

理解问题：局部变量的作用域

考虑以下初始代码示例：

Bus.java (部分)

public class Bus {
    // ... 其他成员变量 ...

    public Bus(int tripNumber) {
        this.tripNumber = tripNumber;
        if (tripNumber == 1) {
            // ... 初始化Bus的其他属性 ...
            Trip trip1 = new Trip(this, tripNumber); // trip1 是局部变量
        }
    }
    // ... toString() 方法 ...
}

Interface.java (主类)

public class Interface {
    public static void main(String args[]) {       
        Bus bus1 = new Bus(1);
        Trip.trip1.toString(); // 尝试访问 Trip 类中的静态 trip1，但不存在
    }
}

在上述代码中，Bus 类的构造函数内部创建了一个 Trip 类的实例 trip1。然而，trip1 被声明为一个局部变量，其生命周期仅限于 if (tripNumber == 1) 块内。一旦构造函数执行完毕，trip1 就会超出作用域，无法从外部（例如 Interface 类的 main 方法）访问。

Interface 类中 Trip.trip1.toString() 的尝试访问更是错误的，因为它试图将 trip1 作为 Trip 类的静态成员来访问，而实际上 trip1 是在 Bus 类的构造函数中创建的一个实例。即使 trip1 不是局部变量，也应该通过 Bus 类的实例来访问。

解决方案一：将对象提升为类的成员变量

要使在构造函数中创建的对象能够在类的外部被访问，需要将其声明为类的成员变量（也称为实例变量）。这样，该对象将与类的每个实例绑定，并在实例的整个生命周期内都可访问。

修改 Bus.java

public class Bus {
    private int tripNumber;
    private String model;
    private String type;
    private int age;
    private int capacity;
    private int remainingCapacity;
    private boolean[][] seats;

    // 将 trip1 声明为 Bus 类的成员变量
    private Trip trip1; 

    public Bus(int tripNumber) {
        this.tripNumber = tripNumber;

        if (tripNumber == 1) {
            this.model = "Setra";
            this.type = "2+2";
            this.age = 8;
            this.capacity = 40;
            this.remainingCapacity = 23;

            // 初始化成员变量 trip1
            this.trip1 = new Trip(this, tripNumber); 
        }
    }

    // ... toString() 方法 ...
}

通过将 trip1 声明为 Bus 类的 private Trip trip1; 成员，它现在是 Bus 实例的一部分。

解决方案二：通过实例访问并使用 Getter 方法

一旦 trip1 成为 Bus 类的成员变量，就可以通过 Bus 类的实例来访问它。为了遵循面向对象编程的封装原则，最佳实践是提供一个公共的 getter 方法来获取这个成员变量。

修改 Bus.java (添加 Getter)

public class Bus {
    // ... 其他成员变量 ...
    private Trip trip1; // 成员变量

    public Bus(int tripNumber) {
        this.tripNumber = tripNumber;

        if (tripNumber == 1) {
            this.model = "Setra";
            this.type = "2+2";
            this.age = 8;
            this.capacity = 40;
            this.remainingCapacity = 23;

            this.trip1 = new Trip(this, tripNumber); 
        }
    }

    // 提供一个公共的 getter 方法来访问 trip1
    public Trip getTrip() {
        return this.trip1;
    }

    public String toString() {
        return ("\n\tBus Information:\n\t\tBus: " + this.model + "\n\t\tType: " + this.type + "\n\t\tAge: " + this.age + "\n\t\tCapacity" + this.capacity + "\n\t\tRemainingCapacity" + this.remainingCapacity);
    }
}

修改 Interface.java (主类)

public class Interface {
    public static void main(String args[]) {       
        Bus bus1 = new Bus(1);

        // 通过 bus1 实例的 getTrip() 方法获取 trip1 对象
        if (bus1.getTrip() != null) { // 检查 trip1 是否已被创建
            System.out.println(bus1.getTrip().toString());
        } else {
            System.out.println("Trip object not created for bus1 with tripNumber 1.");
        }
    }
}

现在，main 方法可以正确地通过 bus1.getTrip() 获取到 Trip 对象，并调用其 toString() 方法。添加 if (bus1.getTrip() != null) 检查是一个良好的编程习惯，以防止在 tripNumber 不为1时 trip1 未被初始化而导致的 NullPointerException。

进一步优化与最佳实践

上述解决方案解决了核心问题，但针对更复杂的场景，还有一些优化建议：

  1. 处理多个行程 (Trips)： 如果一辆巴士可能与多个行程相关联，或者一个行程可以分配给不同的巴士，那么将 Trip 对象存储在一个集合（如 List 或 Map) 中会更灵活。

    Bus.java (使用 List)

    import java.util.ArrayList;
import java.util.List;

public class Bus {
    // ... 其他成员变量 ...
    private List trips; // 可以存储多个行程

    public Bus(int tripNumber) {
        this.trips = new ArrayList<>(); // 初始化列表
        // ... 构造函数逻辑 ...
        if (tripNumber == 1) {
            // ... 初始化Bus属性 ...
            Trip newTrip = new Trip(this, tripNumber);
            this.trips.add(newTrip); // 将行程添加到列表中
        }
    }

    public List getTrips() {
        return this.trips;
    }

    // 可以添加一个方法根据行程号获取特定行程
    public Trip getTripByNumber(int tripNumber) {
        for (Trip trip : trips) {
            if (trip.getTripNumber() == tripNumber) {
                return trip;
            }
        }
        return null; // 未找到
    }
    // ... toString() 方法 ...
}

    Interface.java (访问 List)

    public class Interface {
    public static void main(String args[]) {       
        Bus bus1 = new Bus(1);

        // 访问所有行程
        for (Trip trip : bus1.getTrips()) {
            System.out.println(trip.toString());
        }

        // 或者通过行程号访问特定行程
        Trip specificTrip = bus1.getTripByNumber(1);
        if (specificTrip != null) {
            System.out.println("Specific Trip (ID 1): " + specificTrip.toString());
        }
    }
}

  2. 构造函数逻辑分离： 在构造函数中直接根据 tripNumber 创建 Trip 对象可能不是最灵活的设计。考虑将 Trip 对象的创建和分配逻辑从 Bus 的构造函数中分离出来，例如，通过一个单独的方法 assignTrip(Trip trip) 或者在 main 方法中创建 Trip 后再将其传递给 Bus。

  3. 错误处理和健壮性： 在实际应用中，需要考虑 tripNumber 无效、Trip 对象创建失败等情况。使用 null 检查或抛出异常可以提高代码的健壮性。

总结

从一个类的构造函数中创建的对象，如果希望在外部访问，必须将其声明为该类的成员变量，而非局部变量。然后，通过该类的实例来访问这个成员变量，并推荐使用公共的 getter 方法来封装对内部对象的访问。对于一对多关系（如一辆巴士有多个行程），使用集合（如 List）是更灵活和可扩展的设计模式。遵循这些原则，可以确保对象在整个应用程序中的正确创建、管理和访问。

ai java 常见问题 作用域 面向对象编程

相关文章

按ESC键退出。