Pause café #121. Qu’est-ce que Classpath en Java et comment l’installer ? Immuabilité en Java

Qu’est-ce que Classpath en Java et comment l’installer ?

Source : Medium Connaître les bases de la programmation et le flux d'exécution des fichiers programme nous aide à comprendre un langage. Connaître le paramètre Classpath est l'un des concepts de base que tout développeur Java devrait connaître. Aujourd'hui, nous allons discuter de ce qu'est un chemin de classe ( Classpath ), comment le définir et comment il aide la JVM à exécuter les fichiers de classe.

Qu’est-ce que Classpath ?

Classpath est l'un des paramètres de base de Java, mais il est souvent mal compris par les nouveaux arrivants en programmation. Pour simplifier, un Classpath est simplement un ensemble de chemins le long desquels le compilateur Java et la JVM doivent trouver les classes nécessaires pour compiler ou exécuter d'autres classes.

Comment Classpath aide JVM à exécuter des fichiers de classe

Commençons par un exemple. Supposons que nous ayons un fichier Main.java qui se trouve dans le dossier /Users/vikram/Documents/test-java/src/com/programming/v1/Main.java .

package com.programming.v1;

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello classpath");
    }
}

Disons que nous sommes dans /Users/vikram/Documents et que nous souhaitons compiler cette classe :

javac test-java/src/com/programming/v1/Main.java

Maintenant, pour exécuter ce fichier de classe, nous devons indiquer à la machine virtuelle Java où rechercher le fichier .class en utilisant classpath ou l'indicateur cp dans la commande java .

vg@lp1 Documents % java -cp "test-java/src" com.programming.v1.Main
Hello classpath
vg@lp1 Documents % java -classpath "test-java/src" com.programming.v1.Main
Hello classpath

Le premier paramètre est le dossier racine dans lequel le package est écrit. Le deuxième paramètre est le nom du package avec le nom de la classe. Lorsqu'une commande Java est exécutée, la machine virtuelle Java recherche dans le dossier test-java/src puis charge la classe principale pour l'exécuter.

Comment définir la variable Classpath

La variable Classpath peut être définie comme indiqué ci-dessous sur les machines Linux :

export CLASSPATH="test-java/src"

Le chemin de classe sur une machine Windows peut être ajouté/mis à jour à l'aide de variables d'environnement. Une fois la variable d'environnement définie, la commande java peut être exécutée comme indiqué ci-dessous :

vg@lp1 Documents % java com.programming.v1.Main
Hello classpath

C'est tout ce qu'il y a à savoir sur Classpath . Merci pour la lecture!

Immuabilité en Java

Source : Medium Les variables en Java sont de deux types : primitives et références. En Java, tout est transmis par valeur, mais dans le cas de types référence, les données source peuvent être mises à jour en utilisant l'adresse mémoire transmise. Le mot-clé final est utilisé pour que la variable agisse comme une constante, c'est-à-dire pour éviter toute réaffectation. Cela fonctionne bien pour les primitives qui n'ont pas de mémoire tas, alors que pour les types référence, seule la réaffectation est limitée et l'état interne peut être modifié. Cela peut entraîner de nombreux problèmes de concurrence et conditions de concurrence. Ainsi, inclure des caractéristiques immuables dans un type régulier en Java offre de nombreux avantages.

Avantages de l'immuabilité en Java

1. Sécurité du fil

Les types immuables sont insensibles aux conditions de concurrence dans un environnement multithread, car l'objet restera cohérent après sa création. Plusieurs threads ne peuvent pas modifier leur état interne, la synchronisation n'est donc pas requise.

2. Type fondamental

La chaîne de la bibliothèque standard Java est un bon exemple de classe de base. Il s'agit d'une classe très simple et immuable qui peut être utilisée pour créer des domaines de logique métier par-dessus. De même, un type immuable peut constituer un excellent type de base sur lequel construire.

Caractéristiques

1. Champs privés et finaux

Les champs qui contiennent l'état d'un objet sont private et final . La visibilité privée empêche l'accès direct au champ, tandis que la visibilité finale garantit que le champ n'est attribué qu'une seule fois.

2. Aucune méthode de modification

Le champ privé n'est pas accessible en dehors de la classe. En règle générale, des méthodes d'accès (getters) et des méthodes de modification (setters), respectivement, sont fournies pour lire et écrire dans les champs. Pour garantir la cohérence, les modificateurs ne sont pas autorisés.

3. Cours final

Autoriser l'héritage de classe peut briser l'immuabilité. Une sous-classe étendant une classe immuable peut affecter l'état d'un objet. Le cours est donc définitif .

4. Copies défensives

Lors de la création d'un objet, au lieu d'attribuer des arguments du constructeur directement aux champs privés, la création d'une copie complète (ou d'une copie immuable) des arguments fournira une modification externe. Si l'un des arguments est un type référence, il peut être facilement manipulé du côté de l'appelant. Créer des copies de protection permet d'éviter cette manipulation. De même, pour les accesseurs (getters), au lieu de référencer directement un champ interne, une copie de celui-ci peut être librement partagée.

Mise en œuvre

Employé

import java.time.LocalDate;
import java.util.List;

import static java.util.List.copyOf;

public final class Employee {

    private final long id;
    private final String name;
    private final LocalDate joinDate;
    private final List<String> achievements;

    public Employee(long id,
                    String name,
                    LocalDate joinDate,
                    List<String> achievements) {
        this.id = id;
        this.name = name;
        this.joinDate = joinDate;
        this.achievements = copyOf(achievements);
    }

    public long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public LocalDate getJoinDate() {
        return joinDate;
    }

    public List<String> getAchievements() {
        return achievements;
    }
}

• Tous les champs n'ont pas de copies de protection dans le constructeur. En effet, id est primitif et les champs name et joinDate sont des types immuables. Ils ne peuvent pas être modifiés par l'appelant et resteront inchangés, tandis que le champ des réalisations nécessite une copie de l'argument effectué à l'aide de la méthode List.copyOf . En effet, copyOf renvoie une List immuable .

• De même, les méthodes d'accès renvoient les champs directement plutôt que des copies défensives car tous les types de champs sont immuables (y compris les réalisations ) et ne peuvent donc pas être modifiés en dehors de la classe.

Améliorations

Avant Java 16

L' implémentation d'Employee peut être améliorée avec des bibliothèques telles que Lombok . Cela réduit la verbosité du code et lui donne un aspect plus propre. La bibliothèque est livrée avec des annotations pour raccourcir le code standard. @Value (annotation) peut être utilisée pour créer des getters et un constructeur pour tous les arguments. Cela crée également une classe finale et des champs privés et finaux . Pour information, il génère également les méthodes toString , equals et hashCode . L' implémentation Employee peut être réécrite à l'aide de @Value comme indiqué ci-dessous :

import lombok.Value;

import java.time.LocalDate;
import java.util.List;

import static java.util.List.copyOf;

@Value
public class Employee {

    long id;
    String name;
    LocalDate joinDate;
    List<String> achievements;

    public Employee(long id,
                    String name,
                    LocalDate joinDate,
                    List<String> achievements) {
        this.id = id;
        this.name = name;
        this.joinDate = joinDate;
        this.achievements = copyOf(achievements);
    }
}

Java 16 et versions ultérieures

La version Java 16 a introduit une nouvelle fonctionnalité d'enregistrement . Ce sont (comme indiqué par JEP) des classes qui agissent comme des supports transparents de données immuables et peuvent être considérées comme des tuples nominaux. La classe Employee peut être réimplémentée en tant qu'employé d'enregistrement , comme indiqué ci-dessous.

import java.time.LocalDate;
import java.util.List;

import static java.util.List.copyOf;

public record Employee(long id,
                       String name,
                       LocalDate joinDate,
                       List<String> achievements) {

    public Employee(long id,
                    String name,
                    LocalDate joinDate,
                    List<String> achievements) {
        this.id = id;
        this.name = name;
        this.joinDate = joinDate;
        this.achievements = copyOf(achievements);
    }
}

Défauts

Le seul problème de l'immuabilité est la mémoire et le traitement supplémentaires que nécessite même une petite modification. A chaque fois, il faut créer un nouvel objet, ce qui peut coûter très cher. Pour contourner cet inconvénient, vous pouvez mettre en œuvre des mécanismes tels que la mise en cache et la sauvegarde des résultats.