Java修饰符

Java 语言提供了许多修饰符，主要分为以下两类：

• 访问修饰符

• Modificatori non di accesso

修饰符用于定义类、方法或变量，通常位于语句的最前面。我们通过以下示例进行说明：

public class ClassName {
　　　// ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
　　　// Corpo del metodo
}

Modificatori di controllo dell'accesso

In Java, è possibile utilizzare i modificatori di controllo di accesso per proteggere l'accesso a classi, variabili, metodi e costruttori. Java supporta 4 diversi livelli di permesso di accesso.

• default (cioè predefinito, non scrivere nulla): Visibile nello stesso pacchetto, senza utilizzare alcun modificatore. Utilizzato per: classi, interfacce, variabili, metodi.

• private : Visibile solo all'interno della stessa classe. Utilizzato per: variabili, metodi. Attenzione: non può essere utilizzato per le classi (classi esterne)

• public : Visibile per tutte le classi. Utilizzato per: classi, interfacce, variabili, metodi

• protected : Visibile per le classi nello stesso pacchetto e tutte le sottoclassi. Utilizzato per: variabili, metodi. Attenzione: non può essere utilizzato per le classi (classi esterne).

Possiamo spiegare i permessi di accesso con la seguente tabella:

Controllo dell'accesso

modificatore di accesso predefinito - senza utilizzare alcuna parola chiave

Le variabili e i metodi dichiarati con il modificatore di accesso predefinito sono visibili alle classi nello stesso pacchetto. Le variabili negli interfacce sono implicitamente dichiarate come public static final, mentre i metodi negli interfacce hanno per impostazione predefinita il permesso di accesso public.

Come esempio, la dichiarazione delle variabili e dei metodi può non utilizzare alcun modificatore.

package defaultPackage;
class Logger {
　　　　void message(){
　　　　　　　　System.out.println("This is a message");
　　　　}
}

In questo caso, la classe Logger ha il modificatore di accesso predefinito. E la classe è visibile a tutte le classi del pacchetto defaultPackage. Ma se proviamo a utilizzare la classe Logger in un altro pacchetto diverso da defaultPackage, riceveremo un errore di compilazione.

modificatore di accesso privato - private

Il modificatore di accesso privato è il livello di accesso più rigoroso, quindi viene dichiarato come private i metodi, le variabili e i costruttori possono essere acceduti solo dalla classe di appartenenza, e le classi e gli interfacce non possono essere dichiarate come private.

Le variabili dichiarate come tipo di accesso privato possono essere accedute solo tramite i metodi getter pubblici della classe.

L'uso del modificatore di accesso privato è principalmente utilizzato per nascondere i dettagli dell'implementazione delle classi e per proteggere i dati delle classi.

下面的类使用了私有访问修饰符：

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

Nell'esempio, la variabile format della classe Logger è una variabile privata, quindi altre classi non possono accedere direttamente e impostare il valore di questa variabile. Per permettere ad altre classi di operare su questa variabile, sono stati definiti due metodi public: getFormat() (che restituisce il valore di format) e setFormat(String) (che imposta il valore di format)

Access modifier pubblico - public

Le classi, i metodi, i costruttori e gli interfacce dichiarati come public possono essere acceduti da qualsiasi altra classe.

Se diversi classi public che si visitano a vicenda si trovano in pacchetti diversi, è necessario importare il pacchetto contenente le classi public. Poiché delle classi hanno l'ereditarietà, tutti i metodi e le variabili pubblici delle classi possono essere ereditati dai sottoclasse.

Le seguenti funzioni utilizzano il controllo di accesso pubblico:

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

Il metodo main() del programma Java deve essere definito come pubblico, altrimenti l'interprete Java non può eseguire la classe.

Access modifier protetto - protected

protected deve essere analizzato e spiegato da due punti di vista:

• Il sottoclasse e la superclasse sono nello stesso pacchetto：Le variabili, i metodi e i costruttori dichiarati come protected possono essere acceduti da qualsiasi altra classe nello stesso pacchetto;

• Il sottoclasse e la superclasse non sono nello stesso pacchetto：quindi nel sottoclasse, l'istanza del sottoclasse può accedere ai metodi protected ereditati dalla superclasse, ma non può accedere ai metodi protected dell'istanza della superclasse.

protected può修饰成员数据，costruttore，metodi membri，Non può修饰类（escluso i classi interne）.

Le variabili e i metodi membri dell'interfaccia non possono essere dichiarati come protected.

Il sottoclasse può accedere ai metodi e variabili dichiarati con l'access modifier protected, in modo da proteggere che le classi non correlate utilizzino questi metodi e variabili.

La superclasse utilizza l'access modifier protected, il sottoclasse sovrascrive il metodo openSpeaker() della superclasse.

class AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {
　　　　　　// Dettagli di implementazione
　　　}
}
　
class StreamingAudioPlayer extends AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {
　　　　　　// Dettagli di implementazione
　　　}
}

Se si dichiara il metodo openSpeaker() come private, allora nessun'altra classe oltre a AudioPlayer può accedere a tale metodo.

Se si dichiara openSpeaker() come public, tutte le classi possono accedere al metodo.

Se si desidera che il metodo sia visibile solo alle sottoclassi della classe in cui si trova, si deve dichiarare il metodo come protected.

Protected è il tipo di修饰词 di accesso Java più difficile da comprendere.

Controllo degli accessi e ereditarietà

Attenzione alle seguenti regole di ereditarietà dei metodi:

• I metodi dichiarati come public nel superclasse devono essere dichiarati come public anche nel sottoclasse.

• I metodi dichiarati come protected nel superclasse devono essere dichiarati come protected o public nel sottoclasse, non possono essere dichiarati come private.

• I metodi dichiarati come private nel superclasse non possono essere ereditati.

Modificatori non di accesso

Per implementare alcune altre funzioni, Java fornisce anche molti modificatori non di accesso.

Il modificatore static, utilizzato per修饰类方法和类变量。

Il modificatore final, utilizzato per修饰类、方法和变量，final修饰的类不能被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

Il modificatore abstract, utilizzato per creare classi astratte e metodi astratti.

I modificatori synchronized e volatile, principalmente utilizzati per la programmazione dei thread.

Modificatore static

• Variabili statiche:

  La parola chiave static viene utilizzata per dichiarare variabili statiche indipendenti dall'oggetto, indipendentemente dal numero di oggetti che un'istanza di classe crea, le variabili statiche hanno solo una copia. Le variabili statiche sono anche chiamate variabili di classe. Le variabili locali non possono essere dichiarate come variabili statiche.

• Metodi statici:

  La parola chiave static viene utilizzata per dichiarare metodi statici indipendenti dall'oggetto. I metodi statici non possono utilizzare variabili non statiche della classe. I metodi statici ricevono dati dal elenco dei parametri, poi calcolano questi dati.

L'accesso ai metodi e variabili di classe può essere fatto direttamente utilizzando classname.variablename e classname.methodname modo.

Come esempio dimostra, il modificador static viene utilizzato per creare metodi e variabili di classe.

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("Da " +
　　　　　　InstanceCounter.getCount() + " istanze");
　　　　　　for (int i = 0; i < 500; ++i){
　　　　　　　　　new InstanceCounter();
　　　　　　　　　　}
　　　　　　System.out.println("Creato " +
　　　　　　InstanceCounter.getCount() + " istanze");
　　　}
}

Esempio di esecuzione del risultato dell'editor come segue:

Da 0 istanze
Creare 500 istanze

Modificatore final

Variabile final：

Final significa "ultimo, definitivo", una volta assegnato, un variabile non può essere riassegnata. Le variabili modificate da final devono essere esplicitamente specificate un valore iniziale.

Il modificatore final viene utilizzato solitamente insieme al modificatore static per creare costanti di classe.

public class Test{
　　final int value = 10;
　　// Esempio di dichiarazione di costanti
　　public static final int BOXWIDTH = 6;
　　static final String TITLE = "Manager";
　
　　public void changeValue(){
　　　　　value = 12; // Genererà un errore
　　}
}

Metodo final

I metodi final nella classe padre possono essere ereditati dai figli, ma non possono essere sovrascritti dai figli.

Lo scopo principale della dichiarazione di un metodo final è prevenire la modifica del contenuto del metodo.

Come mostrato di seguito, utilizzare il modificatore final per dichiarare un metodo.

public class Test{
　　　　public final void changeName(){
　　　　　　　// Corpo del metodo
　　　　}
}

Classe final

Le classi final non possono essere ereditate, nessuna classe può ereditare qualsiasi caratteristica di una classe final.

public final class Test {
　　　// Corpo della classe
}

Modificatore abstract

Classe astratta：

Le classi astratte non possono essere utilizzate per creare oggetti, lo scopo unico della dichiarazione di una classe astratta è per espandere la classe in futuro.

Una classe non può essere修饰 simultaneously da abstract e final. Se una classe contiene un metodo astratto, allora la classe deve essere dichiarata come classe astratta, altrimenti verrà generato un errore di compilazione.

La classe astratta può contenere metodi astratti e non astratti.

abstract class Caravan{
　　　private double price;
　　　private String model;
　　　private String year;
　　　public abstract void goFast(); // metodo astratto
　　　public abstract void changeColor();
}

metodo astratto

Il metodo astratto è un metodo senza implementazione, la cui implementazione specifica viene fornita dalla sottoclasse.

Il metodo astratto non può essere dichiarato come final e static.

Ogni sottoclasse che eredita una classe astratta deve implementare tutti i metodi astratti del padre, a meno che la sottoclasse non sia anche astratta.

Se una classe contiene vari metodi astratti, allora la classe deve essere dichiarata come classe astratta. La classe astratta può non contenere metodi astratti.

La dichiarazione del metodo astratto termina con un punto e virgola, ad esempio:public abstract sample();.

public abstract class SuperClass{
　　　　void m(); // metodo astratto
}
　
class SubClass extends SuperClass{
　　　　　// Implementazione del metodo astratto
　　　　　　void m(){
　　　　　　　　　　......
　　　　　　}
}

modificatore synchronized

Il metodo dichiarato con la parola chiave synchronized può essere acceduto da un thread alla volta. Il modificatore synchronized può essere applicato a quattro modificatori di accesso.

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

modificatore transient

Quando un oggetto serializzato contiene variabili decorate con transient, il Java Virtual Machine (JVM) salta questa variabile specifica.

Questo modificatore è incluso nella definizione della frase variabile, utilizzato per preprocessare il tipo di dati di classe e variabile.

public transient int limit = 55; // non persistente
public int b; // persistente

modificatore volatile

Il membro variabile decorato con volatile viene letto nuovamente forzatamente dal memoria condivisa ogni volta che viene acceduto da un thread. E quando il membro variabile cambia, il thread è forzato a scrivere il valore cambiato indietro nella memoria condivisa. In questo modo, in qualsiasi momento, due thread diversi vedono sempre lo stesso valore di un membro variabile.

Un riferimento a un oggetto volatile potrebbe essere null.

public class MyRunnable implements Runnable
{
　　　　private volatile boolean active;
　　　　public void run()
　　　　{
　　　　　　　　active = true;
　　　　　　　　while (active) // Prima riga
　　　　　　　　{
　　　　　　　　　　　　// Codice
　　　　　　　　}
　　　　}
　　　　public void stop()
　　　　{
　　　　　　　　active = false; // Seconda riga
　　　　}
}

Di solito, in una thread che chiama il metodo run() (in un thread aperto da Runnable), in un altro thread si chiama il metodo stop(). Se Prima riga Se il valore di active nel buffer è utilizzato, allora in Seconda riga Quando il valore di active è false, il ciclo non si fermerà.

Ma nel codice sopra abbiamo usato il modificatore volatile per active, quindi il ciclo si fermerà.