Java Language
Modificateurs de non-accès

Introduction

final

final en Java peut faire référence à des variables, des méthodes et des classes. Il y a trois règles simples:

• la variable finale ne peut pas être réaffectée
• la méthode finale ne peut pas être remplacée
• la classe finale ne peut pas être prolongée

Coutumes

Bonne pratique de programmation

Certains développeurs considèrent comme une bonne pratique de marquer une variable finale lorsque vous le pouvez. Si vous avez une variable qui ne devrait pas être changée, vous devriez la marquer finale.

Une utilisation importante du mot-clé final pour les paramètres de méthode. Si vous voulez souligner qu'une méthode ne modifie pas ses paramètres d'entrée, marquez les propriétés comme étant finales.

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

Cela souligne que la méthode sumup ne va pas changer les ints .

Accès en classe interne

Si votre classe interne anonyme veut accéder à une variable, la variable doit être marquée comme final

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

Cette classe ne compile pas, comme la variable name , n'est pas définitif.

variable final static

Même si le code ci-dessous est totalement légal lorsque la variable final foo n'est pas static , en cas de static elle ne compilera pas:

class TestFinal {
    private final static List foo;

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

La raison en est, répétons-le encore, la variable finale ne peut pas être réaffectée . foo étant statique, il est partagé entre toutes les instances de la classe TestFinal . Lorsqu'une nouvelle instance d'une classe TestFinal est créée, son constructeur est appelé et, par conséquent, foo est réaffecté, ce que le compilateur ne permet pas. Une manière correcte d’initialiser la variable foo dans ce cas est soit:

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

ou en utilisant un initialiseur statique:

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

final méthodes final sont utiles lorsque la classe de base implémente des fonctionnalités importantes que la classe dérivée n'est pas censée modifier. Ils sont également plus rapides que les méthodes non finales, car aucun concept de table virtuelle n’est impliqué.

Toutes les classes de wrapper de Java sont finales, telles que Integer , Long etc. Les créateurs de ces classes ne voulaient pas que quiconque, par exemple, étend Integer dans sa propre classe et modifie le comportement de base de la classe Integer. L'une des exigences pour rendre une classe immuable est que les sous-classes ne peuvent pas remplacer les méthodes. La manière la plus simple de le faire est de déclarer la classe comme final .

volatil

Le modificateur volatile est utilisé dans la programmation multi-thread. Si vous déclarez un champ comme volatile cela signifie aux threads qu'ils doivent lire la valeur la plus récente, et non celle mise en cache localement. De plus, volatile lectures et écritures volatile sont garanties atomiques (l'accès à un long ou double non volatile n'est pas atomique), évitant ainsi certaines erreurs de lecture / écriture entre plusieurs threads.

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;
    }
}

statique

Le mot-clé static est utilisé sur une classe, une méthode ou un champ pour les faire fonctionner indépendamment de toute instance de la classe.

• Les champs statiques sont communs à toutes les instances d'une classe. Ils n'ont pas besoin d'instance pour y accéder.
• Les méthodes statiques peuvent être exécutées sans instance de la classe dans laquelle elles se trouvent. Cependant, elles ne peuvent accéder qu'aux champs statiques de cette classe.
• Les classes statiques peuvent être déclarées à l'intérieur d'autres classes. Ils n'ont pas besoin d'une instance de la classe dans laquelle ils sont instanciés.

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

abstrait

Abstraction est un processus consistant à masquer les détails de la mise en œuvre et à ne montrer que les fonctionnalités à l'utilisateur. Une classe abstraite ne peut jamais être instanciée. Si une classe est déclarée comme abstraite, le seul but est que la classe soit étendue.

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");
    }
}

synchronisé

Le modificateur synchronisé est utilisé pour contrôler l'accès d'une méthode particulière ou d'un bloc par plusieurs threads. Un seul thread peut entrer dans une méthode ou un bloc déclaré synchronisé. Le mot-clé synchronisé fonctionne sur le verrouillage intrinsèque d'un objet, dans le cas d'une méthode synchronisée, le verrouillage des objets en cours et la méthode statique utilisent un objet de classe. Tout thread essayant d'exécuter un bloc synchronisé doit d'abord acquérir le verrou d'objet.

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();
    }
}

transitoire

Une variable déclarée comme transitoire ne sera pas sérialisée lors de la sérialisation des objets.

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

strictfp

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

strictfp class A{}

strictfp interface M{}

class A{  
    strictfp void m(){}
}