Contrôle des autorisations d'accès Java - vous amène à en savoir plus sur le mot-clé protégé (image)-javaDidacticiel-php.cn

Résumé :

Au sein d'une classe, ses membres (y compris les membres variables et méthodes membres ) sont accessibles par d'autres classes, en fonction du modificateur du membre et si une classe est accessible par d'autres classes dépend du modificateur de la classe ; Il existe quatre types de modificateurs d'autorisation d'accès aux membres de classe en Java : privé, aucun (par défaut, autorisations d'accès aux packages), protégé et public, parmi lesquels seules les autorisations d'accès aux packages et public peuvent modifier une classe (sauf les classes internes). En particulier, de nombreux livres présentant Java présentent la protection de manière générale, ce qui provoque souvent des malentendus. Par conséquent, cet article se concentre sur la révélation de la connotation et de l’utilisation du mot-clé protégé et introduit d’autres modificateurs.

Déclaration de copyright :

Auteur original de cet article : Rico le nerd
Adresse du blog de l'auteur : http://www.php.cn/

1. Package

Concernant l'utilisation des packages, il suffit de faire attention à une chose : Dans un projet, il ne peut pas y avoir deux noms de packages identiques. en d'autres termes, notre nom de package ne peut pas être répété avec d'autres noms de package dans le projet. Cela inclut non seulement le nom du package personnalisé mais également le nom du package de la bibliothèque de classes référencée par le projet . Regardez l'exemple suivant :

package java.lang;public class MyObject {
    public static void main(String[] args) throws CloneNotSupportedException {
        Object o = new Object();
        System.out.println(o.hashCode());
    }
}

Copier après la connexion

Le nom de package que nous donnons à notre programme est java.lang. En fait, nous savons que java.lang est le nom de package utilisé par le JDK.

Le programme peut être compilé normalement, mais lorsque nous exécutons le programme, il y aura un avertissement de conflit de package et une "java.lang.SecurityException : Nom de package interdit : java.lang" exception sera lancé, comme indiqué ci-dessous.

Contrôle des autorisations daccès Java - vous amène à en savoir plus sur le mot-clé protégé (image)

De plus, nous devons noter :

Si nous utilisons l'instruction Package dans le programme, alors elle doit être sauf dans le fichier Commentez la première phrase du code du programme en dehors de , sinon il ne sera pas compilé.

2. Présentation des droits d'accès Java

Au sein d'une classe, le fait que ses membres (y compris les variables membres et les méthodes membres) soient accessibles par d'autres classes dépend du modificateur pour ce membre. Il existe quatre types de modificateurs d'accès aux membres de classe en Java :

privé, aucun (par défaut, accès au package), protégé et public. Le contrôle des autorisations de est tel qu'indiqué dans le tableau suivant :

　membres, les deux doivent être distingués)

Contrôle des autorisations daccès Java - vous amène à en savoir plus sur le mot-clé protégé (image) ,

n'ont que deux droits d'accès modificateurs : public et "aucun" (c'est-à-dire les droits d'accès au package), mais pas privés et protégés (il y en a un). Dans un cas particulier, seules les classes internes peuvent être privées ou protégées. Pour plus d'informations sur les classes internes, veuillez consulter mon blog "Présentation de la classe interne Java"). Par conséquent, pour les classes non internes, nous ne pouvons leur donner qu'un accès package ou public . Si vous ne voulez pas que quelqu'un d'autre ait accès à la classe, vous pouvez spécifier tous les constructeurs comme privés, empêchant ainsi quiconque de créer des objets de la classe. À l'heure actuelle, les objets de cette classe ne peuvent être créés qu'au sein de ses membres statiques. Cette situation est un peu comme le modèle de cas unique, par exemple, comme l'exemple suivant : <🎜. >Parmi les quatre modificateurs mentionnés ci-dessus, sauf protégés, ils sont tous faciles à comprendre et à maîtriser. Nous les décrirons brièvement ici :

<🎜. >public :

 class Test {       // private Constructor!
       private Test() {}       // Allow creation via static method:
       public static Test getTest() {           return new Test();
       }
    }

Copier après la connexion

Les membres de classe modifiés par public sont directement accessibles par toutes les classes

;

private：被public修饰的类成员只能在定义它的类中被访问，其他类都访问不到。特别地，我们一般建议将成员变量设为private的，并为外界提供 getter/setter 去对成员变量进行访问，这种做法充分体现了Java面向对象的四大特性(封装，多态，继承，抽象)中的封装思想；

包访问权限：包访问权限就是Java中的默认的权限，具有包访问权限的类成员只能被同一包中的类访问。

　　由于 protected 关键字的真正内涵不太容易理解，我们将在下一节专门介绍 protected 关键字。

三. protected 关键字的真正内涵

　　很多的有关介绍Java语言的书籍 (包括《Java编程思想》)，都对protected介绍的比较的简单，基本都是一句话，就是:被protected修饰的成员对于本包和其子类可见。这种说法有点太过含糊，常常会对大家造成误解。对于protected的成员，要分子类和超类是否在同一个包中两种情况看待，现以 protected方法的调用为例进行说明，protected的成员变量类似。

　　实质上，protected方法的调用是否合法(编译是否通过)关键是要看被调用的protected方法从根源上看所在的类对应的包与调用代码所在的类对应的包是否相同，若相同，则合法；否则，不合法。当然，无论如何，子类是可以访问继承而来的属于它自己的受保护方法的。

　　我们可以看下面例子进行了解。

1). 第一种情形：子类与基类不在同一个包中

//示例一package p1;public class Father1 {
    protected void f() {}   
    // 父类Father1中的protected方法}package p1;
    public class Son1 extends Father {}package p11;
    public class Son11 extends Father{}package p1;
    public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK，protected方法f()来自于Father1类，与 Test1类 在同一包p1中
        son1.clone(); // Compile Error，protected方法clone()来自于Object类，与 Test1类不在同一包中

        Son11 son = new Son11();
        son11.f(); // Compile OK，虽然Son11类在包p11中，但protected方法f()来自于Father1类，与 Test1类在同一包p1中
        son11.clone(); // Compile Error，protected方法clone()来自于Object类，与 Test1类不在同一包中
    }
}

Copier après la connexion

　　在上面的示例中，类Father1、Son1 和 Test1 在同一个包p1下，类Son11在包p11下。但是我们知道，无论Son1类还是Son11类，它们的protected方法f()在根源上都来自于p1包中的类Father1，而由于Test1也在p1包中，因此f()方法对Test1类可见，编译通过。但由于Son1类和Son11类中的clone()方法在根源上均来自于java.lang包下的类Object，与 Test1类不在同一包中，因此clone()方法对Test1类不可见，编译不通过。

//示例二package p2;
class MyObject2 {protected Object clone() throws CloneNotSupportedException {       
return super.clone();
    }
}package p22;public class Test2 extends MyObject2 {
    public static void main(String args[]) {
       MyObject2 obj = new MyObject2();
       obj.clone(); // Compile Error，protected方法clone()来自于MyObject2类，与 Test2类 不在同一包p1中

       Test2 tobj = new Test2();
       tobj.clone();// Complie OK，虽然 protected方法clone()来自于MyObject2类，与 Test2类 不在同一包p1中，但Test2类作为MyObject2类的子类，是可以访问继承而来的属于它自己的受保护方法的。
    }
}

Copier après la connexion

　　在上面的示例中，类MyObject2 和类Test2 分别在包 p2 和 p22 下。因此，在类Test2中通过MyObject2的引用调用MyObject2的protected方法clone()时，由于类MyObject2 和类Test2 不在同一包中而编译不通过。但是我们知道，虽然类Test2 的protected方法clone()在根源上也来源于类MyObject2，但是Test2类作为MyObject2类的子类，是可以访问继承而来的属于它自己的受保护方法的。

//示例三package p3;
class MyObject3 extends Test3 {
}package p33;public class Test3 {
  public static void main(String args[]) {
    MyObject3 obj = new MyObject3();
    obj.clone(); // Compile OK，protected方法clone()来自于Test3类，而现在正是在Test3类中访问该方法
  }
}

Copier après la connexion

　　在上面的示例中，类MyObject3 和类Test3 分别在包 p3 和 p33 下。但是由于 MyObject3类的protected方法clone()在根源上来自于类Test3中，而现在正是在Test3类中访问该方法，因此编译通过，原理与示例一类似。

//示例四package p4;
class MyObject4 extends Test4 {  
protected Object clone() throws CloneNotSupportedException {    
return super.clone();
  }
}package p44;public class Test4 {
  public static void main(String args[]) {
    MyObject4 obj = new MyObject4();
    obj.clone(); // Compile Error，protected方法clone()来自于MyObject4类，而Test4类与MyObject4类不在同一个包中
  }
}

Copier après la connexion

　　该示例与示例三很类似，唯一不同的是类MyObject4 重写了从类Test4 中继承过来的protected方法clone()。这样，MyObject4 的 protected方法clone()在根源上来自于类本身而非Test4类。而类MyObject4 和类Test4 又不在同一包下，因此编译不通过。

2). 第二种情形：子类与基类在同一个包中

//示例五package p5;

class MyObject5 {    protected Object clone() throws CloneNotSupportedException {       return super.clone();
    }
}public class Test5 {
    public static void main(String[] args) throws CloneNotSupportedException {
       MyObject5 obj = new MyObject5();
       obj.clone(); // Compile OK，protected方法clone()来自于MyObject5类，而Test5类与MyObject5类又在同一个包中
    }
}

Copier après la connexion

　　该示例与示例四很类似，唯一不同的是类MyObject5 与类Test5在同一个包p5中。正因为二者在同一包中，因此编译通过。

//示例六package p6;

class MyObject6 extends Test6{}public class Test6 {
  public static void main(String[] args) {
    MyObject6 obj = new MyObject6();
    obj.clone();        // Compile OK
  }
}

Copier après la connexion

　　在本示例中，由于类MyObject中的protected方法clone()从根源上来自于Test6类，而现在正是在 Test6 中调用protected方法clone()，因此编译通过。

//示例七package p7;

class MyObject7 extends Test7 {    public static void main(String[] args) {
        Test7 test = new Test7();
        test.clone(); // Compile Error.
  }
}public class Test {}

Copier après la connexion

　　在本示例中，虽然类MyObject7与Test7类在同一个包p7中，但是由于类Test7 的protected方法clone()从根源上来自于 java.lang.Object类，而其又与MyObject7不在同一个包中，因此编译不通过。

四. 其他的修饰符

static：修饰变量和内部类(不能修饰常规类)，其中所修饰变量称为类变量或静态变量。静态变量是和类存在一起的,每个实例共享这个静态变量，在类加载时初始化。

final : Les variables déclarées comme finales doivent recevoir une valeur initiale au moment de la déclaration (sauf pour le cas final vide, bien sûr), et la variable modifiée ne peut pas modifier la valeur. Lors de la modification d'une classe, la classe ne peut pas dériver de sous-classes ; lors de la modification d'une méthode, la méthode ne peut pas être remplacée par des sous-classes. Si les lecteurs souhaitent avoir une compréhension plus approfondie de final, veuillez consulter mon article de blog "Héritage Java, polymorphisme et réutilisation de classes".

résumé : Modifier les classes et les méthodes. Lors de la modification d'une classe, la classe ne peut pas créer des objets lors de la modification d'une méthode, c'est une méthode abstraite. Tant qu'une classe a une méthode abstraite, la classe doit être définie comme abstraite, mais une classe abstraite ne doit pas nécessairement avoir une méthode abstraite.

5. Résumé

Au sein d'une classe, le fait que ses membres (y compris les variables membres et les méthodes membres) soient accessibles par d'autres classes dépend du modificateur du membre ; accessible par d'autres classes dépend du modificateur de la classe. Il existe quatre types de modificateurs d'autorisation d'accès aux membres de classe en Java : privé, aucun (par défaut, autorisations d'accès aux packages), protégé et public, parmi lesquels seules les autorisations d'accès aux packages et public peuvent modifier une classe (sauf les classes internes). En particulier, cet article se concentre sur la révélation de la connotation et de l'utilisation du mot-clé protégé et introduit d'autres modificateurs.

6. Description

Dans le processus de synthèse de ce chapitre, nous avons couvert de nombreux points de connaissances, dont certains que nous avons spécifiquement mentionnés dans d'autres articles de blog, nous avons donc n'a fait aucune mise à jour. Pour une explication plus détaillée, voici le lien correspondant :

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!