Pausa para café #121. O que é Classpath em Java e como instalá-lo? Imutabilidade em Java

O que é Classpath em Java e como instalá-lo?

Fonte: Medium Conhecer os fundamentos da programação e o fluxo de execução dos arquivos de programa nos ajuda a entender uma linguagem. Conhecer o parâmetro Classpath é um dos conceitos básicos que todo desenvolvedor Java deve conhecer. Hoje discutiremos o que é um caminho de classe ( Classpath ), como configurá-lo e como ele ajuda a JVM a executar arquivos de classe.

O que é caminho de classe?

Classpath é um dos parâmetros básicos em Java, mas muitas vezes é mal compreendido por iniciantes em programação. Para simplificar, um Classpath é simplesmente um conjunto de caminhos ao longo dos quais o compilador Java e a JVM devem encontrar as classes necessárias para compilar ou executar outras classes.

Como o Classpath ajuda a JVM na execução de arquivos de classe

Vamos começar com um exemplo. Vamos supor que temos um arquivo Main.java localizado na pasta /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");
    }
}

Digamos que estamos em /Users/vikram/Documents e queremos compilar esta classe:

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

Agora, para executar este arquivo de classe, precisamos informar à Java Virtual Machine onde procurar o arquivo .class usando classpath ou o sinalizador cp no comando 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

O primeiro parâmetro é a pasta raiz onde o pacote está escrito. O segundo parâmetro é o nome do pacote com o nome da classe. Quando um comando Java é executado, a Java Virtual Machine procura na pasta test-java/src e então carrega a classe principal para executá-lo.

Como definir a variável Classpath

A variável Classpath pode ser definida conforme mostrado abaixo em máquinas Linux:

export CLASSPATH="test-java/src"

O caminho de classe em uma máquina Windows pode ser adicionado/atualizado usando variáveis ​​de ambiente. Depois que a variável de ambiente for definida, o comando java pode ser executado conforme mostrado abaixo:

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

Isso é tudo que você precisa saber sobre Classpath . Obrigado por ler!

Imutabilidade em Java

Fonte: Medium Variáveis ​​em Java são de dois tipos: primitivas e de referência. Tudo em Java é passado por valor, mas no caso de tipos de referência, os dados de origem podem ser atualizados usando o endereço de memória passado. A palavra-chave final é utilizada para fazer com que a variável atue como uma constante, ou seja, evitar reatribuições. Isso funciona bem para primitivas que não possuem memória heap, enquanto para tipos de referência apenas a reatribuição é limitada e o estado interno pode ser alterado. Isso pode levar a muitos problemas de simultaneidade e condições de corrida. Assim, incluir características imutáveis ​​em um tipo regular em Java oferece muitos benefícios.

Benefícios da imutabilidade em Java

1. Segurança do fio

Os tipos imutáveis ​​são imunes às condições de corrida em um ambiente multithread porque o objeto permanecerá consistente após ser criado. Vários threads não podem alterar seu estado interno, portanto a sincronização não é necessária.

2. Tipo fundamental

String na Java Standard Library é um bom exemplo de classe base. Esta é uma classe muito simples e imutável que pode ser usada para construir domínios de lógica de negócios sobre ela. Da mesma forma, um tipo imutável pode atuar como um excelente tipo base para construção.

Características

1. Campos Privado e Final

Os campos que contêm o estado de um objeto são private e final . A visibilidade privada impede o acesso direto ao campo, enquanto a visibilidade final garante que o campo seja atribuído apenas uma vez.

2. Sem métodos modificadores

O campo privado não pode ser acessado fora da classe. Normalmente, métodos de acesso (getters) e métodos modificadores (setters), respectivamente, são fornecidos para leitura e gravação em campos. Para garantir a consistência, modificadores não são permitidos.

3. Aula final

Permitir a herança de classe pode quebrar a imutabilidade. Uma subclasse que estende uma classe imutável pode afetar o estado de um objeto. Portanto, a aula é final .

4. Cópias defensivas

Durante a criação do objeto, em vez de atribuir argumentos do construtor diretamente aos campos privados, a criação de uma cópia profunda (ou cópia imutável) dos argumentos fornecerá modificação externa. Se um dos argumentos for um tipo de referência, ele poderá ser facilmente manipulado pelo chamador. A criação de cópias protetoras permite evitar essa manipulação. Da mesma forma, para acessadores (getters), em vez de referenciar diretamente um campo interno, uma cópia dele pode ser compartilhada livremente.

Implementação

Funcionário

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

• Nem todos os campos possuem cópias protetoras no construtor. Isso ocorre porque id é primitivo e os campos name e joinDate são tipos imutáveis. Eles não podem ser alterados pelo chamador e permanecerão inalterados, enquanto o campo de conquistas requer uma cópia do argumento feita usando o método List.copyOf . Isso ocorre porque copyOf retorna um List imutável .

• Da mesma forma, os métodos acessadores retornam campos diretamente, em vez de cópias defensivas, porque todos os tipos de campos são imutáveis ​​(incluindo realizações ) e, portanto, não podem ser modificados fora da classe.

Melhorias

Antes do Java 16

A implementação do Employee pode ser melhorada com bibliotecas como Lombok . Isso reduz a verbosidade do código e ajuda a torná-lo mais limpo. A biblioteca vem com anotações para encurtar o código padrão. @Value (anotação) pode ser usado para criar getters e um construtor para todos os argumentos. Isso também cria uma classe final e campos privados e finais . Como observação, ele também gera os métodos toString , equals e hashCode . A implementação Employee pode ser reescrita usando @Value conforme mostrado abaixo:

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 e posterior

A versão Java 16 introduziu uma nova função Record . Estas (conforme afirmado pelo JEP) são classes que atuam como portadores transparentes de dados imutáveis ​​​​e podem ser consideradas tuplas nominais. A classe Employee pode ser reimplementada como registro Employee conforme mostrado abaixo.

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

Imperfeições

O único problema com a imutabilidade é a memória adicional e o processamento que mesmo uma pequena modificação requer. Cada vez que você precisa criar um novo objeto, o que pode ser muito caro. Para contornar essa desvantagem, você pode implementar mecanismos como armazenar em cache e salvar resultados.