Pourquoi Java interdit-il d'appeler la méthode Superclass d'une superclasse (super.super.method()) ?

Appeler la méthode Super de Super en Java : pourquoi est-ce interdit ?

Malgré la facilité avec laquelle on peut contourner certains scénarios en accédant au méthode parent utilisant directement super.super.method(), Java interdit une telle invocation. Cet article explore les raisons de cette restriction et examine si des mécanismes analogues existent dans d'autres langages.

Violation d'encapsulation

La principale raison pour laquelle Java interdit super.super.method() est de maintenir l'encapsulation. Ce principe empêche le contournement du comportement d'une classe parent en accédant directement à sa superclasse. Bien que contourner le comportement de sa propre classe puisse parfois être nécessaire, par exemple à partir de la même méthode, il ne devrait pas être possible pour les sous-classes de contourner le comportement de leurs parents.

Exemple : Maintenir les invariants de classe

Considérez une hiérarchie de classes : Items, RedItems et BigRedItems. Items représente une collection d'éléments, RedItems une collection d'éléments rouges et BigRedItems une collection de gros éléments rouges. Pour maintenir l'intégrité de chaque classe :

public class Items {
    public void add(Item item) { ... }
}

public class RedItems extends Items {
    @Override
    public void add(Item item) {
        if (!item.isRed()) {
            throw new NotRedItemException();
        }
        super.add(item);
    }
}

public class BigRedItems extends RedItems {
    @Override
    public void add(Item item) {
        if (!item.isBig()) {
            throw new NotBigItemException();
        }
        super.add(item);
    }
}

Cela garantit que RedItems ne contient que des éléments rouges et que BigRedItems ne contient que de gros éléments rouges.

Rupture du contrat d'encapsulation

Si super.super.add() était autorisé :

public class NaughtyItems extends RedItems {
    @Override
    public void add(Item item) {
        // Add any item to NaughtyItems, ignoring the rule in RedItems
        super.super.add(item);
    }
}

NaughtyItems pourrait contourner l'invariant dans RedItems, ajoutant des éléments sans discernement, rendant l'encapsulation de RedItems dénuée de sens.

Conclusion

Le L'interdiction de super.super.method() en Java est une protection importante qui empêche la violation de l'encapsulation, en maintenant l'intégrité et cohérence des hiérarchies de classes. Même si cela peut empêcher certains scénarios pratiques, cela garantit la robustesse et la fiabilité des bases de code Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!