Java中跨类构造器创建对象的访问与封装实践-java教程-PHP中文网

Java中跨类构造器创建对象的访问与封装实践

心靈之曲

发布： 2025-11-07 10:41:11

原创

438人浏览过

Java中跨类构造器创建对象的访问与封装实践

本文深入探讨了在java中从一个类的构造器内部创建的局部对象，如何在主类中进行有效访问的问题。通过分析局部变量作用域的限制，文章逐步演示了如何将局部变量提升为类成员变量，并通过实例进行访问。同时，强调了使用getter方法进行封装的必要性，以实现更好的代码结构和可维护性，并提供了详细的代码示例和最佳实践建议。

理解Java中的对象作用域与可访问性

在Java编程中，理解变量的作用域是至关重要的。当在一个方法（包括构造器）内部声明一个变量时，该变量被称为局部变量，其生命周期和可访问性仅限于该方法内部。这意味着一旦方法执行完毕，局部变量就会超出作用域，无法从外部访问。

原始代码示例中，Bus 类的构造器内部创建了一个 Trip 对象：

public class Bus
{
    // ... 其他成员变量
    public Bus(int tripNumber)
    {
        this.tripNumber = tripNumber;
        if (tripNumber==1)
        {
            // ... 初始化其他Bus属性
            Trip trip1 = new Trip(this, tripNumber); // trip1 是一个局部变量
        }
    }
    // ...
}

登录后复制

这里，Trip trip1 变量被声明在 Bus 构造器内部的 if 语句块中，因此它是一个局部变量。这意味着，在 Interface（主类）中尝试通过 Trip.trip1.toString(); 或 bus1.trip1.toString(); 直接访问它时，编译器会报告“找不到符号”错误，因为它在构造器外部是不可见的。

解决方案一：将局部变量提升为类成员变量

要使在构造器中创建的对象能够在类的其他方法或外部被访问，需要将其声明为类的成员变量。这样，该对象将与类的实例绑定，并且在整个实例的生命周期内都可访问。

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

首先，在 Bus 类中声明一个 Trip 类型的成员变量：

public class Bus
{
    private int tripNumber;
    private String model;
    // ... 其他成员变量
    private Trip trip1; // 将 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); // 使用 this.trip1 赋值给成员变量
        }
    }
    // ...
}

登录后复制

通过将 trip1 声明为 Bus 类的成员变量，并在构造器中使用 this.trip1 进行赋值，trip1 现在成为了 Bus 实例的一部分。

解决方案二：通过实例访问成员变量

一旦 trip1 成为 Bus 类的成员变量，就可以通过 Bus 类的实例来访问它。在 Interface（主类）中，创建 Bus 对象后，可以直接使用该 Bus 实例来访问其内部的 trip1 对象。

修改 Interface 类：

public class Interface
{
    public static void main(String args[])
    {
        Bus bus1 = new Bus(1);
        // 现在可以通过 bus1 实例访问其成员变量 trip1
        if (bus1.trip1 != null) { // 检查 trip1 是否已被初始化
            System.out.println(bus1.trip1.toString());
        } else {
            System.out.println("Trip object not initialized for this bus.");
        }
    }
}

登录后复制

现在，bus1.trip1.toString() 可以成功调用，因为 trip1 是 bus1 实例的一个公共（或默认访问修饰符，此处为默认）成员。

最佳实践：使用Getter方法封装

尽管直接通过 bus1.trip1 访问成员变量可行，但在面向对象编程中，这通常不是最佳实践。直接访问成员变量违反了封装原则。更好的做法是提供一个公共的Getter方法来访问私有成员变量。这允许类内部控制如何暴露其内部状态，并为未来的修改提供了灵活性。

AI封面生成器

专业的AI封面生成工具，支持小红书、公众号、小说、红包、视频封面等多种类型，一键生成高质量封面图片。

108

查看详情

在 Bus 类中添加一个 getTrip() 方法：

public class Bus
{
    private int tripNumber;
    private String model;
    // ... 其他成员变量
    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 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 类以使用 getTrip() 方法：

public class Interface
{
    public static void main(String args[])
    {
        Bus bus1 = new Bus(1);
        // 通过 Getter 方法访问 Trip 对象
        Trip currentTrip = bus1.getTrip();
        if (currentTrip != null) {
            System.out.println(currentTrip.toString());
        } else {
            System.out.println("Trip object not initialized for this bus.");
        }
    }
}

登录后复制

这种方式不仅遵循了封装原则，还提高了代码的可读性和可维护性。

进一步的考虑

处理多个行程（Trip）：如果一辆巴士可能有多趟行程，那么将 trip1 声明为单个 Trip 对象可能不够。在这种情况下，可以考虑使用 List<Trip> 或 Trip[] 来存储多个行程。例如：

public class Bus {
    private List<Trip> trips; // 使用列表存储多个行程

    public Bus(...) {
        this.trips = new ArrayList<>();
        // ...
        // 在构造器或方法中添加行程
        if (tripNumber == 1) {
            this.trips.add(new Trip(this, tripNumber));
        }
    }

    public List<Trip> getTrips() {
        return trips;
    }
}

登录后复制

然后，在主类中可以通过 bus1.getTrips().get(0).toString() 或遍历列表来访问行程。

构造器逻辑的健壮性：在 Bus 构造器中，trip1 只在 tripNumber==1 时被初始化。如果 tripNumber 不是1，trip1 将保持为 null。在访问 trip1 之前，务必进行 null 检查，以避免 NullPointerException。

依赖注入：对于更复杂的应用，当一个对象（如 Bus）需要依赖另一个对象（如 Trip）时，可以考虑使用依赖注入模式。这意味着 Trip 对象不是在 Bus 构造器内部创建的，而是作为参数传递给 Bus 构造器。这使得 Bus 类更加灵活和可测试。

public class Bus {
    private Trip assignedTrip;

    // Trip 对象作为参数传入
    public Bus(int tripNumber, Trip trip) {
        this.tripNumber = tripNumber;
        this.assignedTrip = trip;
        // ...
    }

    public Trip getAssignedTrip() {
        return assignedTrip;
    }
}

// 在主类中
public static void main(String[] args) {
    Trip myTrip = new Trip(null, 1); // 先创建 Trip 对象
    Bus bus1 = new Bus(1, myTrip); // 将 Trip 对象注入 Bus
    System.out.println(bus1.getAssignedTrip().toString());
}

登录后复制

（注意：这里的 Trip 构造器需要调整以接受 null 或一个实际的 Bus 实例，或者在创建 Trip 后再设置 assignedBus。）

总结

在Java中，要从外部访问在类的构造器中创建的对象，核心在于理解变量的作用域。将局部变量提升为类的成员变量是解决此问题的关键一步。在此基础上，遵循面向对象设计原则，通过提供公共的Getter方法来访问私有成员变量，能够更好地实现封装，提高代码的健壮性、可读性和可维护性。对于更复杂的场景，应考虑使用集合来管理多个相关对象，并探索依赖注入等高级设计模式。

以上就是Java中跨类构造器创建对象的访问与封装实践的详细内容，更多请关注php中文网其它相关文章！