Une explication des modificateurs d'accès de Java et de la portée des variables

Modificateurs d'accès Java (caractères de contrôle d'accès)
Java utilise des modificateurs pour contrôler les autorisations d'accès et d'autres fonctions des classes, propriétés et méthodes, généralement placés au début de l'instruction. Par exemple :

public class className {
  // body of class
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
  // body of method
}

Java a de nombreux modificateurs, qui sont divisés en modificateurs d'accès et modificateurs de non-accès. Cette section présente uniquement les modificateurs d'accès, les modificateurs de non-accès seront introduits plus tard.

Les modificateurs d'accès sont également appelés caractères de contrôle d'accès, qui font référence à des mots-clés pouvant contrôler les droits d'utilisation des classes, des variables membres et des méthodes.

Dans la programmation orientée objet, les caractères de contrôle d'accès sont un concept très important, qui peut être utilisé pour protéger l'accès aux classes, variables, méthodes et constructeurs.

Java prend en charge quatre droits d'accès différents :

public : public

Les classes, méthodes et structures déclarées comme publiques Les méthodes et interfaces peuvent être accessible par toute autre classe.

Si plusieurs classes publiques qui accèdent les unes aux autres sont distribuées dans des packages différents, vous devez importer le package où se trouve la classe publique correspondante. En raison de l'héritage de classe, toutes les méthodes et variables publiques d'une classe peuvent être héritées par ses sous-classes.

Les méthodes suivantes utilisent le contrôle d'accès public :

public static void main(String[] arguments) {
  // body of method
}

La méthode main() du programme Java doit être définie sur public, sinon l'interpréteur Java le fera ne pas pouvoir exécuter cette classe.
protected : protected

Les variables, méthodes et constructeurs déclarés comme protégés sont accessibles par n'importe quelle autre classe du même package, et sont également accessibles par les sous-classes de différents packages.

Le modificateur d'accès protégé ne peut pas modifier les classes et les interfaces. Les méthodes et les variables membres peuvent être déclarées comme protégées, mais les variables membres et les méthodes membres des interfaces ne peuvent pas être déclarées comme protégées.

Les sous-classes peuvent accéder aux méthodes et variables déclarées avec le modificateur protected, protégeant ainsi les classes non liées de l'utilisation de ces méthodes et variables.

La classe parent suivante utilise le modificateur d'accès protégé et la sous-classe remplace la méthode bark() de la classe parent.

public class Dog{
  protected void bark() {
    System.out.println("汪汪，不要过来");
  }
}
class Teddy extends Dog{ // 泰迪
  void bark() {
    System.out.println("汪汪，我好怕，不要跟着我");
  }
}

Si la méthode bark() est déclarée privée, les classes autres que Dog ne pourront pas accéder à cette méthode. Si bark() est déclaré public, toutes les classes peuvent accéder à cette méthode. Si nous voulons que la méthode soit visible uniquement par les sous-classes de sa classe, déclarez la méthode comme protégée.
private : private

Le modificateur d'accès privé est le niveau d'accès le plus restrictif, donc les méthodes, variables et constructeurs déclarés comme privés ne peuvent être accessibles que par la classe à laquelle ils appartiennent, et les classes et interfaces ne peuvent pas être déclaré comme privé.

Les variables déclarées comme types d'accès privés ne sont accessibles qu'aux classes externes via les méthodes publiques Getter/Setter de la classe.

L'utilisation d'un modificateur d'accès privé est principalement utilisée pour masquer les détails d'implémentation de la classe et protéger les données de la classe.

Les classes suivantes utilisent des modificateurs d'accès privés :

public class Dog{
  private String name;
  private int age;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
}

Dans l'exemple, les variables name et age de la classe Dog sont des variables privées, donc les autres classes ne peuvent pas Obtenez et définissez directement la valeur de cette variable. Afin de permettre à d'autres classes d'exploiter la variable, deux paires de méthodes publiques sont définies, getName()/setName() et getAge()/setAge(), qui sont utilisées pour obtenir et définir la valeur de la variable privée.

il s'agit d'un mot-clé en Java, qui sera abordé dans ce chapitre. Vous pouvez cliquer sur Java pour obtenir une explication détaillée de ce mot-clé.

Définissez des méthodes pour accéder aux variables privées dans une classe. Il est d'usage de les nommer ainsi : ajoutez "get" ou "set" devant le nom de la variable, et mettez en majuscule la première lettre de la variable. Par exemple, la méthode pour obtenir le nom de la variable privée est getName() et la méthode pour définir le nom est setName(). Ces méthodes sont souvent utilisées et portent des noms spécifiques, appelés méthodes Getter et Setter.
Par défaut : n'utilisez aucun mot-clé.

Les attributs et méthodes déclarés sans aucun modificateur sont visibles par les classes du même package. Les variables de l'interface sont implicitement déclarées comme public static final, et les droits d'accès des méthodes de l'interface sont publics par défaut.

Comme le montre l'exemple suivant, les classes, variables et méthodes sont définies sans aucun modificateur :

class Dog{
  String name;
  int age;
  
  void bark(){ // 汪汪叫
    System.out.println("汪汪，不要过来");
  }
  void hungry(){ // 饥饿
    System.out.println("主人，我饿了");
  }
}

Contrôle d'accès et héritage

S'il vous plaît Faites attention aux règles suivantes d'héritage de méthode (les lecteurs qui ne comprennent pas le concept d'héritage peuvent sauter ici, ou cliquer sur Aperçu de l'héritage et du polymorphisme Java) :
Les méthodes déclarées comme publiques dans la classe parent doivent également être publiques dans l'enfant classe.
Les méthodes déclarées comme protégées dans la classe parent sont soit déclarées comme protégées, soit publiques dans la sous-classe. Ne peut pas être déclaré privé.
Les méthodes déclarées avec les modificateurs par défaut dans la classe parent peuvent être déclarées privées dans la sous-classe.
Les méthodes déclarées comme privées dans la classe parent ne peuvent pas être héritées.
Comment utiliser les caractères de contrôle d'accès

Les caractères de contrôle d'accès nous permettent de contrôler facilement les autorisations du code :
Lorsque vous devez faire en sorte que la classe que vous avez écrite soit accessible à toutes les autres classes, vous peut ajouter la classe Le caractère de contrôle d'accès est déclaré public.
Lorsque vous devez rendre votre classe accessible uniquement aux classes de votre propre package, vous pouvez omettre le caractère de contrôle d'accès.
Lorsque vous devez contrôler les données des membres dans une classe, vous pouvez définir le contrôle d'accès aux données des membres dans la classe sur public, protégé ou omis.

Portée des variables Java
En Java, la portée des variables est divisée en quatre niveaux : niveau classe, niveau instance d'objet, niveau méthode et niveau bloc.

类级变量又称全局级变量或静态变量，需要使用static关键字修饰，你可以与 C/C++ 中的 static 变量对比学习。类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。

对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。

方法级变量就是在方法内部定义的变量，就是局部变量。

块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，比如 if、for 语句的块。块是指由大括号包围的代码，例如：

{
  int age = 3;
  String name = "www.weixueyuan.net";
  // 正确，在块内部可以访问 age 和 name 变量
  System.out.println( name + "已经" + age + "岁了");
}
// 错误，在块外部无法访问 age 和 name 变量
System.out.println( name + "已经" + age + "岁了");

说明：
方法内部除了能访问方法级的变量，还可以访问类级和实例级的变量。
块内部能够访问类级、实例级变量，如果块被包含在方法内部，它还可以访问方法级的变量。
方法级和块级的变量必须被显示地初始化，否则不能访问。

演示代码：

public class Demo{
public static String name = "微学苑"; // 类级变量
public int i; // 对象实例级变量
// 属性块，在类初始化属性时候运行
{
int j = 2;// 块级变量
}
public void test1() {
int j = 3; // 方法级变量
if(j == 3) {
int k = 5; // 块级变量
}
// 这里不能访问块级变量，块级变量只能在块内部访问
System.out.println("name=" + name + ", i=" + i + ", j=" + j);
}
public static void main(String[] args) {
// 不创建对象，直接通过类名访问类级变量
System.out.println(Demo.name);
 
// 创建对象并访问它的方法
Demo t = new Demo();
t.test1();
}
}

运行结果：

微学苑
name=微学苑, i=0, j=3

更多Une explication des modificateurs daccès de Java et de la portée des variables相关文章请关注PHP中文网！