Sumário

Sumário
Apresentação ................................................................................. xi
Prefácio ........................................................................................xiii
Agradecimentos .......................................................................... xvii
1 Introdução ............................................................................1
2 Criar e Destruir Objetos ....................................................5
Item 1: Considere os métodos static factory em vez dos construtores .............. 5
Item 2: Cogite o uso de um builder quando se deparar com muitos
parâmetros no construtor ..................................................................... 10
Item 3: Implemente a propriedade de um singleton com um construtor
privado ou um tipo enum ......................................................................18
Item 4: Implemente a não instanciação através de construtores privados ...... 20
Item 5: Dê preferência à injeção de dependência para integrar recursos ........ 21
Item 6: Evite a criação de objetos desnecessários ........................................... 24
Item 7: Elimine referências obsoletas de objetos ............................................. 28
Item 8: Evite o uso dos finalizadores e dos cleaners ........................................31
Item 9: Prefira o uso do try-with-resources ao try-finally .......................... 37
3 Métodos Comuns para Todos os Objetos .........................41
Item 10: Obedeça ao contrato geral ao sobrescrever o equals .........................41
Item 11: Sobrescreva sempre o método hashCode ao sobrescrever
o método equals ................................................................................. 54
Item 12: Sobrescreva sempre o toString ........................................................ 60
Item 13: Sobrescreva o clone de modo sensato ............................................... 63
Item 14: Pense na possibilidade de implementar a Comparable ...................... 72
4 Classes e Interfaces ............................................................79
Item 15: Reduza ao mínimo a acessibilidade das classes e de
seus membros ..................................................................................... 79
viii JAVA EFETIVO
Item 16: Use os métodos getters em classes públicas e não os
campos públicos ................................................................................. 84
Item 17: Reduza a mutabilidade das classes ao mínimo ................................. 86
Item 18: Prefira a composição à herança ......................................................... 94
Item 19: Projete e documente as classes para a herança ou a iniba ............... 100
Item 20: Prefira as interfaces em vez das classes abstratas .......................... 106
Item 21: Projete as interfaces para a posteridade ...........................................112
Item 22: Use as interfaces somente para definir tipos ...................................114
Item 23: Dê preferência às hierarquias de classes em vez das
classes tagged ...................................................................................116
Item 24: Prefira as classes membro estáticas às não estáticas .......................119
Item 25: Limite os arquivos fonte a uma única classe de nível superior ....... 123
5 Genéricos ..........................................................................125
Item 26: Não use tipos brutos ........................................................................ 125
Item 27: Elimine as advertências não verificadas ..........................................131
Item 28: Prefira as listas aos arrays ............................................................... 134
Item 29: Priorize os tipos genéricos ...............................................................138
Item 30: Priorize os métodos genéricos ..........................................................143
Item 31: Use os wildcards limitados para aumentar a flexibilidade
da API ...............................................................................................147
Item 32: Seja criterioso ao combinar os genéricos com os varargs ............... 154
Item 33: Pense na possibilidade de usar contêineres
heterogêneos typesafe .......................................................................160
6 Enums e Anotações ..........................................................167
Item 34: Use enums em vez de constantes int ...............................................167
Item 35: Use os campos de instância em vez dos valores ordinais ................178
Item 36: Use a classe EnumSet em vez dos campos de bits ............................179
Item 37: Use EnumMap em vez da indexação ordinal ......................................181
Item 38: Emule enums extensíveis por meio de interfaces .............................186
Item 39: Prefira as anotações aos padrões de nomenclatura ......................... 190
Item 40: Use a anotação Override com frequência ....................................... 199
Item 41: Use as interfaces marcadoras para definir tipos ............................. 201
7 Lambdas e Streams ..........................................................205
Item 42: Prefira os lambdas às classes anônimas .......................................... 205
Item 43: Dê preferência às referências para métodos em vez
dos lambdas ..................................................................................... 209
Item 44: Prefira o uso das interfaces funcionais padrão ................................211
Item 45: Seja criterioso ao utilizar as streams ................................................216
Item 46: Dê preferência às funções sem efeitos colaterais nas streams ........ 224
Item 47: Dê preferência à Collection como um tipo de retorno em vez
da Stream ......................................................................................... 230
Item 48: Tenha cuidado ao fazer streams paralelas ....................................... 236
8 Métodos .............................................................................241
Item 49: Verifique a validade dos parâmetros ................................................241
Item 50: Faça cópias defensivas quando necessário ...................................... 245
Item 51: Projete as assinaturas de método com cuidado ............................... 249
Item 52: Utilize a sobrecarga com critério .................................................... 252
Item 53: Use os varargs com sabedoria ......................................................... 259
Item 54: Retorne coleções ou arrays vazios, em vez de nulos ...................... 262
Item 55: Seja criterioso ao retornar opcionais ............................................... 264
Item 56: Escreva comentários de documentação para todos os
elementos da API exposta ............................................................... 269
9 Programação Geral ..........................................................279
Item 57: Minimize o escopo das variáveis locais .......................................... 279
Item 58: Dê preferência aos loops for-each em vez dos
tradicionais loops for ...................................................................... 282
Item 59: Conheça e utilize as bibliotecas ...................................................... 285
Item 60: Evite o float e o double caso sejam necessárias
respostas exatas ............................................................................... 289
Item 61: Dê preferência aos tipos primitivos em vez dos tipos
primitivos empacotados ....................................................................291
Item 62: Evite as strings onde outros tipos forem mais adequados .............. 295
Item 63: Cuidado com o desempenho da concatenação de strings ............... 298
Item 64: Referencie os objetos através das interfaces deles .......................... 299
Item 65: Dê preferência às interfaces em vez da reflexão ..............................301
Item 66: Utilize os métodos nativos com sabedoria ...................................... 305
Item 67: Seja criterioso ao otimizar ............................................................... 306
Item 68: Adote as convenções de nomenclatura geralmente aceitas ..............310
10 Exceções ............................................................................315
Item 69: Utilize as exceções somente em circunstâncias excepcionais .........315
Item 70: Utilize as exceções verificadas para condições recuperáveis
e exceções de runtime para erros de programação ..........................318
Item 71: Evite o uso desnecessário das exceções verificadas ....................... 320
Item 72: Priorize o uso das exceções padrões ............................................... 323
Item 73: Lance exceções adequadas para a abstração ................................... 325
Item 74: Documente todas as exceções lançadas por cada método ................. 327
Item 75: Inclua as informações a respeito das capturas de falhas
nos detalhes da mensagem ............................................................... 329
Item 76: Empenhe-se para obter a atomicidade de falha ................................331
Item 77: Não ignore as exceções .....................................................................333
11 Concorrência ....................................................................335
Item 78: Sincronize o acesso aos dados mutáveis compartilhados ......................335
Item 79: Evite a sincronização excessiva ....................................................... 340
Item 80: Dê preferência aos executores, às tarefas e às streams em
vez das threads ................................................................................ 347
Item 81: Prefira os utilitários de concorrência ao wait e ao notify ............. 349
Item 82: Documente a thread safety ...............................................................355
Item 83: Utilize a inicialização preguiçosa com parcimônia .........................358
Item 84: Não dependa do agendador de threads .............................................361
12 Serialização .......................................................................365
Item 85: Prefira alternativas à serialização Java ........................................... 365
Item 86: Tenha cautela ao implementar a Serializable ............................... 369
Item 87: Pense na possibilidade de usar uma forma serializada
customizada ..................................................................................... 373
Item 88: Escreva métodos readObject defensivamente ................................ 380
Item 89: Dê preferência aos tipos enum em vez do readResolve
para controle de instância ................................................................ 385
Item 90: Pense em usar proxies de serialização em vez de
instâncias serializadas ..................................................................... 390
13 Itens Correspondentes aos Itens da Segunda Edição ....395
14 Referências ........................................................................399
15 Índice .................................................................................405