Java中处理子类toString()方法访问父类私有属性的策略-java教程-PHP中文网

java中处理子类tostring()方法访问父类私有属性的策略

本文探讨了在Java中，子类toString()方法无法直接访问父类私有属性的问题，并提供了两种解决方案。第一种是修改父类属性的访问修饰符为protected，允许子类直接访问；第二种是更符合面向对象原则的做法，即在父类中实现toString()方法，并在子类的toString()方法中通过super.toString()调用父类实现，从而避免破坏封装性。文章通过代码示例详细阐述了这两种方法及其适用场景。

理解Java中的封装与继承

在Java面向对象编程中，封装是一个核心概念，它通过将数据（属性）和操作数据的方法（行为）捆绑在一起，并限制外部直接访问对象内部的某些组件来保护数据。private访问修饰符是实现封装的主要手段，被private修饰的成员只能在其声明的类内部访问。

当一个子类继承父类时，它继承了父类的所有公共（public）和受保护（protected）成员，但不能直接访问父类的私有（private）成员。这是因为private成员是父类内部的实现细节，不应暴露给外部，即使是子类也不例外。

考虑以下示例，其中Vehicle是抽象父类，Car是其子类：

public abstract class Vehicle {
    private String imatriculation;
    private int nb_chevaux;
    private double consomation;

    public Vehicle(String imatriculation, int nb_chevaux, double consomation) {
        this.imatriculation = imatriculation;
        this.nb_chevaux = nb_chevaux;
        this.consomation = consomation;
    }

    public abstract void setConsomation(int conso_input);
}

public class Car extends Vehicle {

    public Car(String imatriculation, int nb_chevaux, double consomation) {
        super(imatriculation, nb_chevaux, consomation);
    }

    @Override
    public void setConsomation(int conso_input) {
        // 假设这里需要访问 consomation，但由于是private，这里无法直接访问
        // this.consomation = conso_input; // 编译错误
    }

    @Override
    public String toString() {
        // 尝试直接访问父类的private属性会导致编译错误
        // return "car" + this.imatriculation + " " + this.nb_chevaux + " " + this.consomation;
        return "car details..."; // 占位符
    }
}

在上述Car类的toString()方法中，如果尝试直接使用this.imatriculation、this.nb_chevaux或this.consomation，编译器将报错，因为这些属性在Vehicle类中被声明为private。super关键字在子类构造器中用于调用父类构造器，以初始化父类的状态，但这并不意味着子类获得了直接访问父类私有成员的权限。

解决方案一：使用protected访问修饰符

解决此问题的一种直接方法是将父类中需要被子类访问的私有属性的访问修饰符从private更改为protected。protected修饰符允许成员在声明它的类以及其子类中访问。

修改后的Vehicle类：

Java 接口排错助手

在调试 Java 后端 API 故障时使用此技能，尤其适用于以下任务：分析日志、跨 Controller、Service 和 Mapper 层追踪请求、定位异常根因、检查 SQL 执行或参数流转，以及生成简洁的诊断结论与修复方案。

下载

public abstract class Vehicle {
    protected String imatriculation; // 修改为 protected
    protected int nb_chevaux;        // 修改为 protected
    protected double consomation;    // 修改为 protected

    public Vehicle(String imatriculation, int nb_chevaux, double consomation) {
        this.imatriculation = imatriculation;
        this.nb_chevaux = nb_chevaux;
        this.consomation = consomation;
    }

    public abstract void setConsomation(int conso_input);

    // 注意：如果父类也有自己的toString需求，可以考虑在这里实现
    // @Override
    // public String toString() {
    //     return "Imatriculation: " + imatriculation + ", Chevaux: " + nb_chevaux + ", Consomation: " + consomation;
    // }
}

修改后的Car类：

public class Car extends Vehicle {

    public Car(String imatriculation, int nb_chevaux, double consomation) {
        super(imatriculation, nb_chevaux, consomation);
    }

    @Override
    public void setConsomation(int conso_input) {
        this.consomation = conso_input; // 现在可以访问了
    }

    @Override
    public String toString() {
        // 现在可以直接访问父类的protected属性
        return "Car: " + this.imatriculation + " " + this.nb_chevaux + " " + this.consomation;
    }
}

适用场景与注意事项： 当父类属性确实需要在子类中频繁直接访问或修改时，使用protected是一个合理的选择。然而，过度使用protected可能会削弱封装性，因为子类将对父类的内部实现产生依赖。在设计类层次结构时，应仔细权衡封装性和子类访问需求。

解决方案二：在父类中实现toString()并利用super.toString()

更符合面向对象设计原则的解决方案是让父类负责其自身私有数据的表示，即在父类中实现toString()方法。然后，子类在自己的toString()方法中调用super.toString()来获取父类的字符串表示，并在此基础上添加子类特有的信息。这种方法维护了良好的封装性，因为父类的私有属性仍然只由父类自己访问。

修改后的Vehicle类：

public abstract class Vehicle {
    private String imatriculation;
    private int nb_chevaux;
    private double consomation;

    public Vehicle(String imatriculation, int nb_chevaux, double consomation) {
        this.imatriculation = imatriculation;
        this.nb_chevaux = nb_chevaux;
        this.consomation = consomation;
    }

    public abstract void setConsomation(int conso_input);

    @Override
    public String toString() {
        // 父类可以访问自己的private属性
        return "Imatriculation: " + imatriculation + ", Chevaux: " + nb_chevaux + ", Consomation: " + consomation;
    }
}

修改后的Car类：

public class Car extends Vehicle {

    public Car(String imatriculation, int nb_chevaux, double consomation) {
        super(imatriculation, nb_chevaux, consomation);
    }

    @Override
    public void setConsomation(int conso_input) {
        // 如果需要修改consomation，父类需要提供setter方法，或者将consomation改为protected
        // 示例中，如果Vehicle没有提供setter，这里仍无法直接修改private consomation
        // 通常，抽象父类会提供public或protected的getter/setter方法
    }

    @Override
    public String toString() {
        // 调用父类的toString()方法获取父类信息的字符串表示
        return "Car [" + super.toString() + "]";
    }
}

适用场景与注意事项： 这是处理此类问题的推荐方法，因为它遵循了封装原则，使得每个类都只负责管理自己的数据。子类不需要知道父类内部是如何存储和表示其数据的，只需通过父类提供的公共接口（toString()方法）获取所需信息。这种设计模式使得代码更健壮、更易于维护和扩展。当父类有自己的逻辑来生成其状态的字符串表示时，此方法尤其有效。

总结与最佳实践

当子类需要获取父类私有属性的信息时，直接访问是不可行的。我们有两种主要策略：

改变访问修饰符为protected： 简单直接，但可能在一定程度上削弱封装性。适用于父子类之间存在紧密耦合，且子类确实需要直接操作父类内部状态的场景。
在父类中实现toString()，子类通过super.toString()调用： 这是更推荐的面向对象设计方法。它保持了父类的封装性，让父类负责管理其私有数据，子类通过公共接口获取信息。这种方式使得代码结构更清晰，更符合“高内聚、低耦合”的设计原则。

在大多数情况下，第二种方法是更优的选择，因为它更好地利用了面向对象的设计优势，避免了对父类内部实现的直接依赖，从而提高了代码的可维护性和可扩展性。