Points à noter lors de l'utilisation de modificateurs d'accès pour les fonctions Java

Les modificateurs d'autorisation d'accès aux fonctions Java incluent : public, protégé, par défaut et privé. Les précautions suivantes doivent être suivies : les classes imbriquées ne peuvent accéder qu'aux membres privés des classes externes ; les fonctions des sous-classes héritent des autorisations d'accès de la classe parent, mais ne peuvent pas les réduire sous polymorphisme, lorsque les sous-classes remplacent les fonctions de la classe parent, les autorisations d'accès ne peuvent pas être appliquées ; plus restrictif. Le modificateur ;default rend la fonction visible uniquement dans le même package.

Modificateurs d'accès aux fonctions Java : Précautions d'utilisation

Avant-propos

Les modificateurs d'accès sont utilisés pour contrôler la visibilité des fonctions Java sur d'autres classes ou packages, ce qui est important pour assurer la sécurité du code L'encapsulation et la sécurité sont essentielles. Cet article présentera les précautions d'utilisation des modificateurs d'autorisation d'accès aux fonctions en Java et les illustrera à travers des cas pratiques.

Modificateurs d'accès

Les modificateurs d'accès aux fonctions couramment utilisés en Java incluent :

• public : Accessible n'importe où
• protected : Accessible dans le même package ou ses sous-classes
• default (package -private) : Uniquement accessible au sein du même package
• private : Uniquement accessible au sein de la classe dans laquelle ils sont définis

Notes

Obligatoire lors de l'utilisation de modificateurs d'accès Suivez ces notes :

• Classes imbriquées : Les fonctions définies dans une classe imbriquée ne peuvent accéder qu'aux membres privés de sa classe externe.
• Sous-classe : Les fonctions de la sous-classe héritent des droits d'accès de la classe parent, mais ne peuvent pas réduire les droits d'accès de la classe parent.
• Polymorphisme : Les sous-classes peuvent remplacer les fonctions de la classe parent, mais les autorisations d'accès des fonctions remplacées ne peuvent pas être plus restrictives que les autorisations d'accès des fonctions de la classe parent.
• Visibilité du package : Le modificateur par défaut peut également être appelé visibilité du package, ce qui signifie que la fonction n'est visible que dans les classes du même package.

Cas pratique

Démontre un exemple de code contenant deux classes illustrant l'utilisation de modificateurs d'accès :

// 外部类
public class OuterClass {
    private int privateField;  // 私有字段
    protected int protectedField;  // 受保护字段
    int defaultField;  // 默认字段
    public int publicField;  // 公共字段

    // 私有方法
    private void privateMethod() {
        System.out.println("私有方法");
    }
    // 受保护方法
    protected void protectedMethod() {
        System.out.println("受保护方法");
    }
    // 默认方法
    void defaultMethod() {
        System.out.println("默认方法");
    }
    // 公共方法
    public void publicMethod() {
        System.out.println("公共方法");
    }
}

// 内部类
class InnerClass {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();

        // 访问内部类中的公共字段
        System.out.println(outer.publicField);

        // 访问外部类中的默认字段（因为内部类和外部类在同一包中）
        System.out.println(outer.defaultField);

        // 无法访问外部类中的私有字段
        // System.out.println(outer.privateField);

        // 无法访问外部类中的受保护字段（因为内部类不是外部类的子类）
        // System.out.println(outer.protectedField);

        // 无法调用外部类中的私有方法
        // outer.privateMethod();

        // 可以调用外部类中的受保护方法
        outer.protectedMethod();

        // 可以调用外部类中的默认方法
        outer.defaultMethod();

        // 可以调用外部类中的公共方法
        outer.publicMethod();
    }
}

Dans cet exemple :

• OuterClass >privateField ne peut être accessible dans OuterClass. OuterClass 中的 privateField 只能在 OuterClass 中访问。
• OuterClass 中的 protectedField 可以在 OuterClass 及其子类中访问。
• OuterClass 中的 defaultField 可以在同一包中的任何类中访问。
• OuterClass 中的 publicField 可以从任何地方访问。
• InnerClass 可以访问 OuterClass
protectedField dans OuterClass est accessible dans OuterClass et ses sous-classes.

🎜defaultField dans OuterClass est accessible à partir de n'importe quelle classe du même package. 🎜🎜publicField dans OuterClass est accessible de n'importe où. 🎜🎜InnerClass peut accéder aux membres publics, protégés et par défaut de OuterClass, mais pas aux membres privés. 🎜🎜

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!