Modificateurs Java

Le langage Java propose de nombreux modificateurs, qui sont principalement répartis dans les deux catégories suivantes :

Modificateurs d'accès

Modificateurs de non-accès

Les modificateurs sont utilisés pour définir des classes, des méthodes ou des variables, et sont généralement placés au début de l'instruction. Nous utilisons l'exemple suivant pour illustrer?:

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

Modificateur de contr?le d'accès

En Java, les modificateurs de contr?le d'accès peuvent être utilisés pour protéger l'accès aux classes, variables, méthodes et constructeurs. Java prend en charge 4 droits d'accès différents.

La valeur par défaut, également appelée valeur par défaut, est visible dans le même package et n'utilise aucun modificateur.

Privé, spécifié avec le modificateur private, visible au sein de la même classe.

Partagé, spécifié avec le modificateur public, visible par toutes les classes.

Protégé, spécifié avec le modificateur protected, visible par les classes et toutes les sous-classes du même package.

Modificateur d'accès par défaut - n'utilisez aucun mot-clé

Les variables et méthodes déclarées à l'aide du modificateur d'accès par défaut 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.

Exemple?:

Comme le montre l'exemple suivant, les variables et les méthodes peuvent être déclarées sans aucun modificateur.

String version = "1.5.1";
boolean processOrder() {
   return true;
}

Modificateur d'accès privé-privé

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

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

L'utilisation du 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 le modificateur d'accès privé?:

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

Dans l'exemple, la variable de format dans la classe Logger est une variable privée, donc les autres classes ne peuvent pas directement obtenir et définir la valeur de la variable. Afin de permettre à d'autres classes d'exploiter cette variable, deux méthodes publiques sont définies?: getFormat() (renvoie la valeur du format) et setFormat(String) (définit la valeur du format)

Modificateur d'accès public-public

Les classes, méthodes, constructeurs et interfaces déclarés publics sont accessibles par n'importe quelle 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 fonctions suivantes utilisent le contr?le d'accès public?:

public static void main(String[] arguments) {
   // ...
}

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

Accès protégé modifier-protected

Les variables, méthodes et constructeurs déclarés comme protégés sont accessibles par toute autre classe du même package, ou par les classes d'accès aux 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 par 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 surcharge la méthode openSpeaker() de la classe parent.

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 實(shí)現(xiàn)細(xì)節(jié)
   }
}

class StreamingAudioPlayer {
   boolean openSpeaker(Speaker sp) {
      // 實(shí)現(xiàn)細(xì)節(jié)
   }
}

如果把openSpeaker()方法聲明為private，那么除了AudioPlayer之外的類將不能訪問該方法。如果把openSpeaker()聲明為public，那么所有的類都能夠訪問該方法。如果我們只想讓該方法對其所在類的子類可見，則將該方法聲明為protected。

訪問控制和繼承

請注意以下方法繼承的規(guī)則：

父類中聲明為public的方法在子類中也必須為public。

父類中聲明為protected的方法在子類中要么聲明為protected，要么聲明為public。不能聲明為private。

父類中默認(rèn)修飾符聲明的方法，能夠在子類中聲明為private。

父類中聲明為private的方法，不能夠被繼承。

非訪問修飾符

為了實(shí)現(xiàn)一些其他的功能，Java也提供了許多非訪問修飾符。

static修飾符，用來創(chuàng)建類方法和類變量。

Final修飾符，用來修飾類、方法和變量，final修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變量為常量，是不可修改的。

Abstract修飾符，用來創(chuàng)建抽象類和抽象方法。

Synchronized和volatile修飾符，主要用于線程的編程。

Static修飾符

靜態(tài)變量：

Static關(guān)鍵字用來聲明獨(dú)立于對象的靜態(tài)變量，無論一個(gè)類實(shí)例化多少對象，它的靜態(tài)變量只有一份拷貝。 靜態(tài)變量也被成為類變量。局部變量能被聲明為static變量。

靜態(tài)方法：

Static關(guān)鍵字用來聲明獨(dú)立于對象的靜態(tài)方法。靜態(tài)方法不能使用類的非靜態(tài)變量。靜態(tài)方法從參數(shù)列表得到數(shù)據(jù)，然后計(jì)算這些數(shù)據(jù)。

對類變量和方法的訪問可以直接使用classname.variablename和classname.methodname的方式訪問。

如下例所示，static修飾符用來創(chuàng)建類方法和類變量。

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

以上實(shí)例運(yùn)行編輯結(jié)果如下:

Started with 0 instances
Created 500 instances

Final修飾符

Final變量：

Final變量能被顯式地初始化并且只能初始化一次。被聲明為final的對象的引用不能指向不同的對象。但是final對象里的數(shù)據(jù)可以被改變。也就是說final對象的引用不能改變，但是里面的值可以改變。

Final修飾符通常和static修飾符一起使用來創(chuàng)建類常量。

實(shí)例:

public class Test{
  final int value = 10;
  // 下面是聲明常量的實(shí)例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //將輸出一個(gè)錯(cuò)誤
  }
}

Final方法

類中的Final方法可以被子類繼承，但是不能被子類修改。

聲明final方法的主要目的是防止該方法的內(nèi)容被修改。

如下所示，使用final修飾符聲明方法。

public class Test{
    public final void changeName(){
       // 方法體
    }
}

Final類

Final類不能被繼承，沒有類能夠繼承final類的任何特性。

實(shí)例：

public final class Test {
   // 類體
}

Abstract修飾符

抽象類：

抽象類不能用來實(shí)例化對象，聲明抽象類的唯一目的是為了將來對該類進(jìn)行擴(kuò)充。

一個(gè)類不能同時(shí)被abstract和final修飾。如果一個(gè)類包含抽象方法，那么該類一定要聲明為抽象類，否則將出現(xiàn)編譯錯(cuò)誤。

抽象類可以包含抽象方法和非抽象方法。

實(shí)例：

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法

抽象方法是一種沒有任何實(shí)現(xiàn)的方法，該方法的的具體實(shí)現(xiàn)由子類提供。抽象方法不能被聲明成final和strict。

任何繼承抽象類的子類必須實(shí)現(xiàn)父類的所有抽象方法，除非該子類也是抽象類。

如果一個(gè)類包含若干個(gè)抽象方法，那么該類必須聲明為抽象類。抽象類可以不包含抽象方法。

抽象方法的聲明以分號(hào)結(jié)尾，例如：public abstract sample();

實(shí)例：

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //實(shí)現(xiàn)抽象方法
      void m(){
          .........
      }
}

Synchronized修飾符

Synchronized關(guān)鍵字聲明的方法同一時(shí)間只能被一個(gè)線程訪問。Synchronized修飾符可以應(yīng)用于四個(gè)訪問修飾符。

實(shí)例：

public synchronized void showDetails(){
.......
}

Transient修飾符

序列化的對象包含被transient修飾的實(shí)例變量時(shí)，java虛擬機(jī)(JVM)跳過該特定的變量。

該修飾符包含在定義變量的語句中，用來預(yù)處理類和變量的數(shù)據(jù)類型。

實(shí)例：

public transient int limit = 55;   // will not persist
public int b; // will persist

volatile修飾符

Volatile修飾的成員變量在每次被線程訪問時(shí)，都強(qiáng)迫從共享內(nèi)存中重讀該成員變量的值。而且，當(dāng)成員變量發(fā)生變化時(shí)，強(qiáng)迫線程將變化值回寫到共享內(nèi)存。這樣在任何時(shí)刻，兩個(gè)不同的線程總是看到某個(gè)成員變量的同一個(gè)值。一個(gè)volatile對象引用可能是null。

實(shí)例：

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // line 1
        {
            // 代碼
        }
    }
    public void stop()
    {
        active = false; // line 2
    }
}

一般地，在一個(gè)線程中調(diào)用run()方法，在另一個(gè)線程中調(diào)用stop()方法。如果line 1中的active位于緩沖區(qū)的值被使用，那么當(dāng)把line 2中的active設(shè)置成false時(shí)，循環(huán)也不會(huì)停止。