Olá!

Agora vamos falar sobre classes imutáveis ​​em Java e mostrar como tornar a classe imutável.

A classe é chamada imutável se for impossível alterar seu estado e conteúdo após a inicialização (criação).

Os benefícios de tais classes são:

  • segurança: você, como desenvolvedor, pode ter certeza de que ninguém é capaz de mudar seu estado;
  • thread-safety: o mesmo mencionado acima também é real para o ambiente multithread;
  • armazenável em cache: as instâncias podem ser armazenadas em cache facilmente pelo cache da VM ou pela implementação customizada, pois temos 100% de certeza de que seus valores não serão alterados;
  • hashable: tais classes podem ser seguramente colocadas dentro das coleções de hash (como HashMap, HashSetetc) – é claro, se os métodos equals()& hashCode()são substituídos de maneira apropriada.

Então, vamos tentar implementar a classe imutável pegando o mutável e mudando sua implementação para o imutável passo a passo.

Considere, temos a seguinte classe POJO típica Hobbit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import java.util.List;
 
public class Hobbit {
    private String name;
    private Address address;
    private List<String> stuff;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public void setAddress(Address address) {
        this.address = address;
    }
 
    public List<String> getStuff() {
        return stuff;
    }
 
    public void setStuff(List<String> stuff) {
        this.stuff = stuff;
    }
}

Hobbitclasse tem um campo addressdo tipo Address:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Address {
    private String country;
    private String city;
 
    public Address(String country, String city) {
        this.country = country;
        this.city = city;
    }
 
    public String getCountry() {
        return country;
    }
 
    public void setCountry(String country) {
        this.country = country;
    }
 
    public String getCity() {
        return city;
    }
 
    public void setCity(String city) {
        this.city = city;
    }
}

Address A classe não será alterada neste artigo, portanto, em caso de dúvidas, consulte o código incorporado acima.

A primeira questão a ser notada são setters, que permitem alterar o valor de cada campo de classe. Então, vamos remover esses métodos:

1. removendo setters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Hobbit {
    private String name;
    private Address address;
    private List<String> stuff;
 
    // getters:
    public String getName() {
        return name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public List<String> getStuff() {
        return stuff;
    }
}

Parece melhor, mas agora o usuário de nossa classe não tem chances de definir os valores para campos de classe. Então, vamos fornecer o construtor apropriado:

2. adicionando todos os construtores args

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Hobbit {
    private String name;
    private Address address;
    private List<String> stuff;
 
    // all args constructor:
    public Hobbit(String name, Address address, List<String> stuff) {
        this.name = name;
        this.address = address;
        this.stuff = stuff;
    }
 
    // getters:
    public String getName() {
        return name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public List<String> getStuff() {
        return stuff;
    }
}

Nós terminamos agora? Ainda não, restam vários problemas. Primeiro de tudo, nossa imutabilidade poderia ser hackeada usando um dos princípios da OOP – herança. Deixe-me demonstrar isso com um exemplo simples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import java.util.List;
 
public class Gandalf extends Hobbit {
    private String hackedName;
 
    public Gandalf(String name, Address address, List<String> stuff) {
        super(name, address, stuff);
        hackedName = name;
    }
 
    public void hackTheImmutability(String newNameValue) {
        hackedName = newNameValue;
        System.out.println("Immutability has been hacked!");
    }
 
    @Override
    public String getName() {
        return hackedName;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import java.util.Collections;
 
public class Hack {
    public static void main(String[] args) {
        Gandalf gandalf = new Gandalf("Frodo Baggins", new Address("Hobitton", "Shire"), Collections.emptyList());
        Hobbit hobbit = (Hobbit) gandalf;
 
        System.out.println(hobbit.getName());
 
        System.out.println();
        gandalf.hackTheImmutability("Mr. Underhill");
        System.out.println();
 
        System.out.println(hobbit.getName());
    }
}

Se executarmos a Hackturma, obteremos a seguinte saída:

Frodo Bolseiro
Imutabilidade foi hackeada!
Mr. Underhill

Para corrigir esse problema, precisamos:

3. classe de marcação como final para protegê-la de ser estendida

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public final class Hobbit {
    private String name;
    private Address address;
    private List<String> stuff;
 
    // all args constructor:
    public Hobbit(String name, Address address, List<String> stuff) {
        this.name = name;
        this.address = address;
        this.stuff = stuff;
    }
 
    // getters:
    public String getName() {
        return name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public List<String> getStuff() {
        return stuff;
    }
}

Agora, se executarmos a Hackaula mais uma vez, a saída estará correta:

Frodo Bolseiro
Imutabilidade foi hackeada!
Frodo Bolseiro

Há mais uma questão interessante: como sabemos, em Java quando passamos o valor de um objeto, estamos passando a referência a ele. Assim, o estado dos objetos poderia ser alterado pelos efeitos colaterais. Vamos voltar ao código para ver isso:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.util.List;
import java.util.ArrayList;
 
public class Hack {
    public static void main(String[] args) {
        Address address = new Address("Hobitton", "Shire");
        List<String> stuff = new ArrayList<>();
        stuff.add("Sword");
        stuff.add("Ring of Power");
 
        Hobbit hobbit = new Hobbit("Frodo Baggins", address, stuff);
 
        System.out.println("Hobbit country: " + hobbit.getAddress().getCountry());
        System.out.println("Hobbit city: " + hobbit.getAddress().getCity());
        System.out.println("Hobbit stuff: " + hobbit.getStuff());
 
        address.setCountry("Isengard");
        address.setCity("Saruman tower");
        stuff.remove("Ring of Power");
        stuff.remove("Sword"); 
 
        System.out.println();
        System.out.println("Immutability has been hacked!");
        System.out.println();
 
        System.out.println("Hobbit country: " + hobbit.getAddress().getCountry());
        System.out.println("Hobbit city: " + hobbit.getAddress().getCity());
        System.out.println("Hobbit stuff: " + hobbit.getStuff());
    }
}

A saída deste código é:

Hobbit country: Hobitton 
Hobbit city: Shire 
Hobbit stuff: [Espada, Anel do Poder]  
Imutabilidade foi hackeada!  
Hobbit country: Isengard 
Cidade de Hobbit: Saruman tower 
Hobbit stuff: []

Esse problema pode ser corrigido por:

4. inicializando todos os campos mutáveis ​​não-primitivos via construtor executando uma cópia profunda

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import java.util.List;
import java.util.ArrayList;
 
public final class Hobbit {
    private String name;
    private Address address;
    private List<String> stuff;
 
    // all args constructor:
    public Hobbit(String name, Address address, List<String> stuff) {
        this.name = name;
        this.address = new Address(address.getCountry(), address.getCity());
        this.stuff = new ArrayList<>(stuff);
    }
 
    // getters:
    public String getName() {
        return name;
    }
 
    public Address getAddress() {
        return address;
    }
 
    public List<String> getStuff() {
        return stuff;
    }
}

Agora a saída da Hackclasse é mais previsível:

Hobbit country: Hobitton 
Hobbit city: Shire 
Hobbit stuff: [Espada, Anel do Poder]
Imutabilidade foi hackeada!
Hobbit country: Hobitton 
Hobbit city: Shire 
Hobbit stuff: [Espada, Anel do Poder]

Mas o mesmo problema de efeito colateral poderia ser produzido através de métodos getter:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import java.util.ArrayList;
import java.util.List;
 
public class Hack {
    public static void main(String[] args) {
        Address address = new Address("Hobitton", "Shire");
 
        List<String> stuff = new ArrayList<>();
        stuff.add("Sword");
        stuff.add("Ring of Power");
 
        Hobbit hobbit = new Hobbit("Frodo Baggins", address, stuff);
 
        System.out.println("Hobbit country: " + hobbit.getAddress().getCountry());
        System.out.println("Hobbit city: " + hobbit.getAddress().getCity());
        System.out.println("Hobbit stuff: " + hobbit.getStuff());
 
        Address hobbitAddress = hobbit.getAddress();
        hobbitAddress.setCountry("Isengard");
        hobbitAddress.setCity("Saruman tower");
 
        List<String> hobbitStuff = hobbit.getStuff();
        hobbitStuff.remove("Ring of Power");
        hobbitStuff.remove("Sword");
 
        System.out.println();
        System.out.println("Immutability has been hacked!");
        System.out.println();
 
        System.out.println("Hobbit country: " + hobbit.getAddress().getCountry());
        System.out.println("Hobbit city: " + hobbit.getAddress().getCity());
        System.out.println("Hobbit stuff: " + hobbit.getStuff());
    }
}

Saída:

Hobbit country: Hobitton 
Hobbit city: Shire 
Hobbit stuff: [Espada, Anel do Poder]  
Imutabilidade foi hackeada!  
Hobbit country: Isengard 
Cidade de Hobbit: Saruman tower 
Hobbit stuff: []

Então, vai com outro passo a ser feito:

5. executando clonagem do objeto mutável não-primitivo retornado em métodos getter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import java.util.ArrayList;
import java.util.List;
 
public final class Hobbit {
    private String name;
    private Address address;
    private List<String> stuff;
 
    // all args constructor:
    public Hobbit(String name, Address address, List<String> stuff) {
        this.name = name;
        this.address = new Address(address.getCountry(), address.getCity());
        this.stuff = new ArrayList<>(stuff);
    }
 
    // getters:
    public String getName() {
        return name;
    }
 
    public Address getAddress() {
        return new Address(address.getCountry(), address.getCity());
    }
 
    public List<String> getStuff() {
        return new ArrayList<>(stuff);
    }
}

Agora a Hacksaída é:

Hobbit country: Hobitton 
Hobbit city: Shire 
Hobbit stuff: [Espada, Anel do Poder]
Imutabilidade foi hackeada!
Hobbit country: Hobitton 
Hobbit city: Shire 
Hobbit stuff: [Espada, Anel do Poder]

Há mais uma etapa opcional a ser executada, mas se todos os outros pré-requisitos forem atendidos, isso não é necessário. De qualquer forma, vamos mencionar isso:

6. marcando todos os campos de classe como final (opcional)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import java.util.ArrayList;
import java.util.List;
 
public final class Hobbit {
    private final String name;
    private final Address address;
    private final List<String> stuff;
 
    // all args constructor:
    public Hobbit(String name, Address address, List<String> stuff) {
        this.name = name;
        this.address = new Address(address.getCountry(), address.getCity());
        this.stuff = new ArrayList<>(stuff);
    }
 
    // getters:
    public String getName() {
        return name;
    }
 
    public Address getAddress() {
        return new Address(address.getCountry(), address.getCity());
    }
 
    public List<String> getStuff() {
        return new ArrayList<>(stuff);
    }
}

E é isso, estamos prontos – nossa Hobbitclasse é imutável agora.

Vamos resumir os passos:

  1. remover setters;
  2. adicionando todo o construtor args;
  3. marcando a classe de modo finala protegê-la de ser estendida;
  4. inicializar todos os campos mutáveis ​​não primitivos via construtor executando uma cópia profunda;
  5. executando clonagem do objeto mutável não-primitivo retornado nos métodos getter;
  6. marcando todos os campos de classe como final(etapa opcional).

Claro, existem outras maneiras de tornar a classe imutável (por exemplo, usando o padrão Builder), mas está fora do escopo da história atual.