Guide sur le mot clé statique en Java

1. introduction

Dans cet article, nous allons explorer en détail le mot-cléstatic du langage Java. Nous verrons comment appliquer le mot-cléstatic aux variables, méthodes, blocs, classes imbriquées et quelle différence cela fait.

2. L'anatomie du mot-cléstatic

Dans le langage de programmation Java,the keyword static indicates that the particular member belongs to a type itself, rather than to an instance of that type.

Cela signifie qu'une seule instance de ce membre statique est créée et est partagée par toutes les instances de la classe.

Le mot clé peut être appliqué aux variables, méthodes, blocs et classes imbriquées.

3. Les champsstatic (ou variables de classe)

En Java,if a field is declared static, then exactly a single copy of that field is created and shared among all instances of that class. Peu importe le nombre de fois que nous initialisons une classe; il n'y aura toujours qu'une seule copie du champstatic lui appartenant. La valeur de ce champstatic sera partagée entre tous les objets de l'un ou l'autre de n'importe quelle classe différente.

Du point de vue de la mémoire,static variables go in a particular pool in JVM memory called Metaspace (avant Java 8, ce pool s'appelait Permanent Generation ou PermGen, qui a été complètement supprimé et remplacé par Metaspace).

3.1. Exemple du champstatic

Supposons que nous ayons une classeCar avec plusieurs attributs (variables d'instance). Chaque fois que de nouveaux objets sont initialisés à partir de ce planCar, chaque nouvel objet aura sa copie distincte de ces variables d'instance.

Cependant, supposons que nous recherchions une variable contenant le décompte du nombre d'objetsCar initialisés et partagés entre toutes les instances afin qu'ils puissent y accéder et l'incrémenter lors de leur initialisation.

C’est là que les variablesstatic entrent en jeu:

public class Car {
    private String name;
    private String engine;

    public static int numberOfCars;

    public Car(String name, String engine) {
        this.name = name;
        this.engine = engine;
        numberOfCars++;
    }

    // getters and setters
}

Maintenant, pour chaque objet de cette classe qui est initialisé, la même copie de la variablenumberOfCars est incrémentée. Donc, pour ce cas, les assertions suivantes seront vraies:

@Test
public void whenNumberOfCarObjectsInitialized_thenStaticCounterIncreases() {
    new Car("Jaguar", "V8");
    new Car("Bugatti", "W16");

    assertEquals(2, Car.numberOfCars);
}

3.2. Raisons impérieuses d'utiliser les champsstatic

Quand la valeur de variable est indépendante des objets
Lorsque la valeur est supposée être partagée entre tous les objets

3.3. Points clés à retenir

Étant donné que les variablesstatic appartiennent à une classe, elles sont accessibles directement en utilisant le nom de la classe et n'ont pas besoin de référence d'objet
Les variablesstatic ne peuvent être déclarées qu'au niveau de la classe
Les champsstatic sont accessibles sans initialisation d'objet
Bien que nous puissions accéder aux champsstatic en utilisant une référence d'objet (commeford.numberOfCars_) , we should refrain from using it as in this case it becomes difficult to figure whether it’s an instance variable or a class variable; instead, we should always refer to _static_ variables using class name (for example, in this case, _Car.numberOfCars)

4. Les méthodesstatic (ou méthodes de classe)

Semblables aux champsstatic, les méthodesstatic appartiennent également à une classe au lieu de l'objet, et peuvent donc être appelées sans créer l'objet de la classe dans laquelle elles résident. Ils sont destinés à être utilisés sans créer d'objets de la classe.

4.1. Exemple de méthodestatic

Les méthodesstatic sont généralement utilisées pour effectuer une opération qui ne dépend pas de la création de l'instance.

S'il y a un code censé être partagé entre toutes les instances de cette classe, écrivez ce code dans une méthodestatic:

public static void setNumberOfCars(int numberOfCars) {
    Car.numberOfCars = numberOfCars;
}

Les méthodesstatic sont également largement utilisées pour créer des classes utilitaires ou d'assistance afin qu'elles puissent être obtenues sans créer un nouvel objet de ces classes.

Jetez simplement un œil aux classes utilitairesCollections ouMath de JDK,StringUtils d'Apache ouCollectionUtils du framework Spring et notez que toutes les méthodes sontstatic.

4.2. Raisons impérieuses d'utiliser les méthodesstatic

Pour accéder / manipuler des variables statiques et d'autres méthodes statiques qui ne dépendent pas d'objets
Les méthodesstatic sont largement utilisées dans les classes utilitaires et auxiliaires

4.3. Points clés à retenir

Les méthodesstatic en Java sont résolues au moment de la compilation. Puisque le remplacement de méthode fait partie du polymorphisme d'exécution,so static methods can’t be overridden
les méthodes abstraites ne peuvent pas être statiques
Les méthodesstatic ne peuvent pas utiliser les mots clésthis ousuper
Les combinaisons suivantes d'instance, de méthodes de classe et de variables sont valides:
1. Les méthodes d'instance peuvent accéder directement aux méthodes d'instance et aux variables d'instance
2. Les méthodes d'instance peuvent également accéder directement aux variablesstatic et aux méthodesstatic
3. Les méthodesstatic peuvent accéder à toutes les variablesstatic et aux autres méthodesstatic
4. static methods cannot access instance variables and instance methods directly; ils ont besoin d'une référence d'objet pour le faire

5. Un blocstatic

Un blocstatic est utilisé pour initialiser les variablesstatic. Bien que les variablesstatic puissent être initialisées directement lors de la déclaration, il y a des situations où nous sommes obligés de faire le traitement multiligne.

Dans de tels cas, les blocsstatic sont utiles.

Si les variablesstatic nécessitent une logique multi-instructions supplémentaire lors de l'initialisation, alors un blocstatic peut être utilisé.

5.1. Exemple de blocstatic

Supposons que nous voulions initialiser un objet de la liste avec des valeurs prédéfinies.

Cela devient facile avec les blocsstatic:

public class StaticBlockDemo {
    public static List ranks = new LinkedList<>();

    static {
        ranks.add("Lieutenant");
        ranks.add("Captain");
        ranks.add("Major");
    }

    static {
        ranks.add("Colonel");
        ranks.add("General");
    }
}

Dans cet exemple, il ne serait pas possible d’initialiser l’objetList avec toutes les valeurs initiales avec la déclaration; et c’est pourquoi nous avons utilisé le blocstatic ici.

5.2. Raisons impérieuses d'utiliser les blocsstatic

Si l'initialisation des variablesstatic nécessite une logique supplémentaire à l'exception de l'affectation
Si l'initialisation des variables statiques est sujette aux erreurs et nécessite la gestion des exceptions

5.3. Points clés à retenir

Une classe peut avoir plusieurs blocsstatic
Les champsstatic et les blocsstatic sont résolus et exécutés dans le même ordre qu'ils sont présents dans la classe

6. Classe Astatic

Le langage de programmation Java nous permet de créer une classe dans une classe. Il fournit un moyen convaincant de regrouper des éléments qui ne seront utilisés qu’à un seul endroit, ce qui permet de garder notre code plus organisé et plus lisible.

L'architecture de classe imbriquée est divisée en deux:

les classes imbriquées déclaréesstatic sont appeléesstatic nested classes alors que,
les classes imbriquées qui ne sont pas -static sont appeléesinner classes

La principale différence entre ces deux éléments est que les classes internes ont accès à tous les membres de la classe englobante (y compris private), tandis que les classes imbriquéesstaticont uniquement accès aux membres statiques de la classe externe.

En fait,static nested classes behaved exactly like any other top-level class but enclosed in the only class which will access it, to provide better packaging convenience.

6.1. Exemple de classestatic

L'approche la plus largement utilisée pour créer des objets singleton consiste à utiliser la classe imbriquéestatic, car elle ne nécessite aucune synchronisation et est facile à apprendre et à implémenter:

public class Singleton  {
    private Singleton() {}

    private static class SingletonHolder {
        public static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

6.2. Raisons convaincantes d'utiliser une classe internestatic

Le regroupement de classes qui ne seront utilisées qu'à un seul endroit augmente l'encapsulation
Le code est rapproché de l'endroit qui ne sera utilisé que pour l'utiliser; cela augmente la lisibilité et le code est plus maintenable
Si la classe imbriquée ne nécessite aucun accès à ses membres d'instance de classe englobants, il est préférable de la déclarer commestatic car de cette façon, elle ne sera pas couplée à la classe externe et sera donc plus optimale car elle ne nécessitera aucun tas ni mémoire de pile

6.3. Points clés à retenir

static nested classes do not have access to any instance members of the enclosing outer class; il ne peut y accéder que par la référence d’un objet
Les classes imbriquées statiques peuvent accéder à tous les membres statiques de la classe englobante, y compris les membres privés.
La spécification de programmation Java ne nous permet pas de déclarer la classe de premier niveau commestatic; seules les classes au sein des classes (classes imbriquées) peuvent être constituées destatic

7. Conclusion

Dans cet article, nous avons vu le mot cléstatic en action. Nous avons également lu les raisons et les avantages de l'utilisation de champs statiques, de méthodes statiques, de blocs statiques et de classes internes statiques.

Comme toujours, nous pouvons trouver le code completover on GitHub.

TOC

Guide sur le mot clé statique en Java