Java Language
Modificatori di non accesso

introduzione

finale

final in Java può riferirsi a variabili, metodi e classi. Ci sono tre semplici regole:

• la variabile finale non può essere riassegnata
• il metodo finale non può essere annullato
• la lezione finale non può essere estesa

usi

Buona pratica di programmazione

Alcuni sviluppatori considerano buona pratica contrassegnare una variabile finale quando è possibile. Se hai una variabile che non dovrebbe essere cambiata, dovresti contrassegnarla come definitiva.

Un uso importante della parola chiave final se per i parametri del metodo. Se si desidera sottolineare che un metodo non modifica i parametri di input, contrassegnare le proprietà come finali.

public int sumup(final List<Integer> ints);

Questo sottolinea che il metodo di sumup non cambierà gli ints .

Accesso alla classe interna

Se la tua classe interiore anonima vuole accedere a una variabile, la variabile dovrebbe essere contrassegnata come final

  public IPrintName printName(){
    String name;
    return new IPrintName(){
        @Override
        public void printName(){
            System.out.println(name);
        }
    };
}

Questa classe non si compila, come il name della variabile, non è definitiva.

variabile final static

Anche se il codice sottostante è completamente legale quando la variabile final foo non è static , in caso di static non verrà compilata:

class TestFinal {
    private final static List foo;

    public Test() {
        foo = new ArrayList();
    }
}

Il motivo è, ripetiamolo, la variabile finale non può essere riassegnata . Poiché foo è statico, è condiviso tra tutte le istanze della classe TestFinal . Quando viene creata una nuova istanza di una classe TestFinal , viene richiamato il suo costruttore e quindi viene riassegnato che il compilatore non consente. Un modo corretto per inizializzare la variabile foo in questo caso è:

class TestFinal {
    private static final List foo = new ArrayList();
    //..
}

o usando un inizializzatore statico:

class TestFinal {
    private static final List foo;
    static {
        foo = new ArrayList();
    }
    //..
}

final metodi final sono utili quando la classe base implementa alcune funzionalità importanti che la classe derivata non dovrebbe modificare. Sono anche più veloci dei metodi non definitivi, perché non vi è alcun concetto di tavolo virtuale coinvolto.

Tutte le classi wrapper in Java sono definitive, come Integer , Long etc. I creatori di queste classi non volevano che chiunque potesse estendere Integer nella propria classe e modificare il comportamento di base della classe Integer. Uno dei requisiti per rendere immutabile una classe è che le sottoclassi non possano sovrascrivere i metodi. Il modo più semplice per farlo è dichiarare la classe come final .

volatile

Il modificatore volatile viene utilizzato nella programmazione multi-thread. Se dichiari un campo come volatile , è un segnale ai thread che devono leggere il valore più recente, non uno memorizzato localmente. Inoltre, volatile letture e le scritture volatile sono garantite per essere atomiche (l'accesso a un non volatile long o double non è atomico), evitando così determinati errori di lettura / scrittura tra più thread.

public class MyRunnable implements Runnable
{
    private volatile boolean active;
 
    public void run(){ // run is called in one thread 
        active = true;
        while (active){
            // some code here
        }
    }
    
    public void stop(){ // stop() is called from another thread
        active = false;
    }
}

statico

La parola chiave static viene utilizzata su una classe, un metodo o un campo per farli funzionare indipendentemente da qualsiasi istanza della classe.

• I campi statici sono comuni a tutte le istanze di una classe. Non hanno bisogno di un'istanza per accedervi.
• I metodi statici possono essere eseguiti senza un'istanza della classe in cui si trovano. Tuttavia, possono accedere solo ai campi statici di quella classe.
• Le classi statiche possono essere dichiarate all'interno di altre classi. Non hanno bisogno di un'istanza della classe in cui sono istanziati.

public class TestStatic
{
    static int staticVariable;

    static {
        // This block of code is run when the class first loads
        staticVariable = 11;
    }

    int nonStaticVariable = 5;

    static void doSomething() {
        // We can access static variables from static methods
        staticVariable = 10;
    }

    void add() {
        // We can access both static and non-static variables from non-static methods
        nonStaticVariable += staticVariable;
    }

    static class StaticInnerClass {
        int number;
        public StaticInnerClass(int _number) {
            number = _number;
        }

        void doSomething() {
            // We can access number and staticVariable, but not nonStaticVariable
            number += staticVariable;
        }

        int getNumber() {
            return number;
        }
    }
}


// Static fields and methods
TestStatic object1 = new TestStatic();

System.out.println(object1.staticVariable); // 11
System.out.println(TestStatic.staticVariable); // 11

TestStatic.doSomething();

TestStatic object2 = new TestStatic();

System.out.println(object1.staticVariable); // 10
System.out.println(object2.staticVariable); // 10
System.out.println(TestStatic.staticVariable); // 10

object1.add();

System.out.println(object1.nonStaticVariable); // 15
System.out.println(object2.nonStaticVariable); // 10

// Static inner classes
StaticInnerClass object3 = new TestStatic.StaticInnerClass(100);
StaticInnerClass object4 = new TestStatic.StaticInnerClass(200);

System.out.println(object3.getNumber()); // 100
System.out.println(object4.getNumber()); // 200

object3.doSomething();

System.out.println(object3.getNumber()); // 110
System.out.println(object4.getNumber()); // 200

astratto

L'astrazione è un processo che nasconde i dettagli dell'implementazione e mostra solo funzionalità all'utente. Una classe astratta non può mai essere istanziata. Se una classe viene dichiarata come astratta, l'unico scopo è quello di estendere la classe.

abstract class Car
{
    abstract void tagLine();
}
 
class Honda extends Car
{
    void tagLine()
    {
        System.out.println("Start Something Special");
    }
}
 
class Toyota extends Car
{
    void tagLine()
    {
        System.out.println("Drive Your Dreams");
    }
}

sincronizzato

Il modificatore sincronizzato viene utilizzato per controllare l'accesso di un particolare metodo o di un blocco da più thread. Solo un thread può entrare in un metodo o un blocco dichiarato come sincronizzato. la parola chiave sincronizzata funziona sul blocco intrinseco di un oggetto, nel caso di un metodo sincronizzato il blocco degli oggetti correnti e il metodo statico utilizza l'oggetto classe. Qualsiasi thread che tenta di eseguire un blocco sincronizzato deve prima acquisire il blocco oggetto.

class Shared
{
    int i;
 
    synchronized void SharedMethod()
    {
        Thread t = Thread.currentThread();
 
        for(int i = 0; i <= 1000; i++)
        {
            System.out.println(t.getName()+" : "+i);
        }
    }

    void SharedMethod2()
    {
        synchronized (this)
        {
            System.out.println("Thais access to currect object is synchronize "+this);
        }
    }
}
 
public class ThreadsInJava
{
    public static void main(String[] args)
    {
        final Shared s1 = new Shared();
 
        Thread t1 = new Thread("Thread - 1")
        {
            @Override
            public void run()
            {
                s1.SharedMethod();
            }
        };
 
        Thread t2 = new Thread("Thread - 2")
        {
            @Override
            public void run()
            {
                s1.SharedMethod();
            }
        };
 
        t1.start();
 
        t2.start();
    }
}

transitorio

Una variabile dichiarata come transitoria non verrà serializzata durante la serializzazione dell'oggetto.

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

strictf

// strictfp keyword can be applied on methods, classes and interfaces.

strictfp class A{}

strictfp interface M{}

class A{  
    strictfp void m(){}
}