Lezione di Java 21 – Altri modificatori di accesso

Indice Lezione PrecedenteLezione Successiva


Esistono molti altri modificatori in Java, andiamo ad esaminarli:

  • final, in generale questo tipo di modificatore indica che una caratteristica final non può essere modificata. Ad es. una classe posta final indica che non può essere estesa, un metodo final non può essere sovrapposto, un attributo final è una costante.
    Final non può essere applicato ai costruttori, non avrebbe senso dato che non sono ereditati e quindi non sovrapponibili.
  • abstract, è l’opposto di final. Se una caratteristica final non deve essere modificata, una caratteristica abstract esiste solo per obbligare qualcuno a definirla. Può essere applicato solo a classi e metodi, non ad attributi. Se marchiamo una classe abstrac significa che avremo dei metodi abstract che devono essere definiti dalle sottoclassi.
  • static, si applica ad attributi, metodi ed anche a blocchi di codice esterni ai metodi. Quando una caratteristica è marcata static questa appartiene alla classe e non alle singole istanze, viene creata quando la classe è caricata in memoria, quindi esiste anche se non esiste nessuna istanza (basti pensare al metodo main, è marcato static, altrimenti non potrebbe essere utilizzato come primo metodo dato che non ci sono oggetti creati).
    L’accesso ad un attributo static può avvenire anche partendo dal nome della classe, oltre che da un riferimento alla classe.
    I metodi static non posso accedere a caratteristiche non static dato che le caratteristiche non static potrebbe ancora non esistere. Non possono essere sovrapposti, nè possono sovrapporre, metodi non-static. Quando c’è una sovrapposizione tra metodi static si parla di ombreggiamento.
    I blocchi static servono a contenere pezzi di codice che devono essere eseguiti prima di tutti i metodi e attributi marcati static:

    public class EsempioStatic {
      static int num = 1;

      static {
        System.out.println("i: " + i++);
      }

      public static void main( String [] args) {
        System.out.println("i: " + i++);
      }

      static {
        System.out.println("i: " + i++);
      }
    }

    avremo come output:

    i: 1
    i: 2
    i: 3

Altri modificatori sono:

  • native, si applica solo a metodi. Indica che il corpo del metodo si trova all’esterno della JVM, in una libreria di codice dipendente dalla architettura fisica.
  • transient, si applica solo ad attributi. Indica che quell’attributo contiene informazioni sensibili e nel caso in cui l’oggetto in cui è contenuto venisse salvato il valore di quell’attributo non dovrà essere considerato.
  • synchronized, si applica solo a metodi o a blocchi anonimi. Controlla l’accesso al codice in programmi multi-thread.
  • volatile, si applica solo ad attributi. Avverte il compilatore che quell’attributo può essere modificato in modo asincrono, in architetture multiprocessore.

Ti piace l’articolo?
Diventa fan su Facebook
Indice Lezione PrecedenteLezione Successiva
Pubblicato in Guide, Guide, Java, Programmazione Taggato con: , , , ,

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

*