Effective Java 3rd edition Chinese English bilingual

Efetivo-Java-3ª edição-Chinês-Inglês-bilíngue

Esta é uma referência de aprendizado de chinês e inglês para cada capítulo de Effective Java (3ª edição). Espero que seja útil para melhorar a tecnologia Java. Sugestões e modificações são bem-vindas por meio de edição ou relações públicas.

Conteúdo

• Capítulo 2. Criando e Destruindo Objetos
  • Capítulo 2 Introdução
  • Item 1: Considere métodos estáticos de fábrica em vez de construtores (considere métodos estáticos de fábrica em vez de construtores)
  • Item 2: Considere um construtor quando confrontado com muitos parâmetros de construtor
  • Item 3: Aplique a propriedade singleton com um construtor privado ou um tipo enum (use um construtor privado ou um tipo enum para implementar uma propriedade singleton)
  • Item 4: Aplicar a não-instanciabilidade com um construtor privado (use um construtor privado para implementar a não-instanciabilidade)
  • Item 5: Prefira injeção de dependência a recursos de conexão física (a injeção de dependência é melhor do que recursos de conexão física)
  • Item 6: Evite criar objetos desnecessários
  • Item 7: Elimine referências de objetos obsoletos (exclua referências de objetos obsoletos)
  • Item 8: Evite finalizadores e limpadores (evite usar finalizadores e limpadores)
  • Item 9: Prefira tentar com recursos a tentar finalmente (usar tentar com recursos é melhor do que tentar finalmente)
• Capítulo 3. Métodos comuns a todos os objetos (métodos comuns de objetos)
  • Capítulo 3 Introdução
  • Item 10: Obedeça ao contrato geral ao substituir o método igual (a convenção que deve ser seguida ao substituir o método igual)
  • Item 11: Sempre substitua hashCode ao substituir equals (ao substituir o método equals, sempre substitua o método hashCode)
  • Item 12: Sempre substitua toString (sempre substitua o método toString)
  • Item 13: Substituir o clone criteriosamente (substituir o método de clonagem com sabedoria)
  • Item 14: Considere implementar Comparable (Considere implementar a interface Comparable)
• Capítulo 4. Classes e Interfaces
  • Capítulo 4 Introdução
  • Item 15: Minimizar a acessibilidade de classes e membros (minimizar a acessibilidade de classes e membros)
  • Item 16: Em classes públicas use métodos acessadores e não campos públicos (em classes públicas, use métodos acessadores, não campos públicos)
  • Item 17: Minimizar a mutabilidade (reduzir a variabilidade)
  • Item 18: Favorecer a composição em vez da herança
  • Item 19: Desenho e documento para herança ou então proibi-la (a herança deve ser bem desenhada e documentada, caso contrário seu uso é proibido)
  • Item 20: Prefira interfaces a classes abstratas (Interfaces são melhores que classes abstratas)
  • Item 21: Projetar interfaces para a posteridade
  • Item 22: Use interfaces apenas para definir tipos (as interfaces são usadas apenas para definir tipos)
  • Item 23: Prefira hierarquias de classes a classes marcadas (hierarquias de classes são melhores que classes marcadas)
  • Item 24: Favorecer classes de membros estáticos em vez de não estáticos (classes de membros estáticos são melhores que classes de membros não estáticos)
  • Item 25: Limitar os arquivos de origem a uma única classe de nível superior (os arquivos de origem são limitados a uma única classe de nível superior)
• Capítulo 5. Genéricos
  • Capítulo 5 Introdução
  • Item 26: Não use tipos brutos (Não use tipos brutos)
  • Item 27: Eliminar avisos não verificados (eliminar avisos não verificados)
  • Item 28: Prefira listas a arrays (lista é melhor que array)
  • Item 29: Dê preferência a tipos genéricos (prefira usar tipos genéricos)
  • Item 30: Favorecer métodos genéricos (preferir usar métodos genéricos)
  • Item 31: Use curingas limitados para aumentar a flexibilidade da API (use curingas limitados para aumentar a flexibilidade da API)
  • Item 32: Combine genéricos e varargs criteriosamente
  • Item 33: Considere contêineres heterogêneos typesafe (Considere contêineres heterogêneos typesafe)
• Capítulo 6. Enums e Anotações (enumerações e anotações)
  • Capítulo 6 Introdução
  • Item 34: Use enums em vez de constantes int (use tipos de enumeração em vez de constantes int)
  • Item 35: Use campos de instância em vez de ordinais
  • Item 36: Use EnumSet em vez de campos de bits (use EnumSet em vez de campos de bits)
  • Item 37: Use EnumMap em vez de indexação ordinal (use EnumMap para substituir a indexação ordinal)
  • Item 38: Emular enumerações extensíveis com interfaces (use interfaces para simular enumerações extensíveis)
  • Item 39: Prefira anotações a padrões de nomenclatura (anotações são melhores que padrões de nomenclatura)
  • Item 40: Use consistentemente a anotação Override (insista em usar a anotação @Override)
  • Item 41: Use interfaces de marcadores para definir tipos
• Capítulo 7. Lambdas e Streams (expressões e streams λ)
  • Capítulo 7 Introdução
  • Item 42: Prefira lambdas a classes anônimas (expressões λ são melhores que classes anônimas)
  • Item 43: Prefira referências de métodos a lambdas (referências de métodos são melhores que expressões lambda)
  • Item 44: Favorecer o uso de interfaces funcionais padrão
  • Item 45: Use fluxos criteriosamente
  • Item 46: Prefira funções livres de efeitos colaterais em streams (use funções livres de efeitos colaterais em streams)
  • Item 47: Prefira Collection a Stream como tipo de retorno (Prefira Collection em vez de stream como tipo de retorno)
  • Item 48: Tenha cuidado ao fazer fluxos paralelos
• Capítulo 8. Métodos
  • Capítulo 8 Introdução
  • Item 49: Verifique a validade dos parâmetros
  • Item 50: Faça cópias defensivas quando necessário
  • Item 51: Projetar assinaturas de métodos com cuidado (projetar assinaturas de métodos com cuidado)
  • Item 52: Use a sobrecarga criteriosamente
  • Item 53: Use varargs criteriosamente
  • Item 54: Retornar coleções ou matrizes vazias, não nulas (retornar coleções ou matrizes vazias, não nulas)
  • Item 55: Devolver opcionais criteriosamente
  • Item 56: Escreva comentários de documentos para todos os elementos de API expostos
• Capítulo 9. Programação Geral
  • Capítulo 9 Introdução
  • Item 57: Minimizar o escopo das variáveis ​​locais (minimizar o escopo das variáveis ​​locais)
  • Item 58: Prefira os loops for-each aos loops for tradicionais (o loop for-each é melhor que o loop for tradicional)
  • Item 59: Conhecer e utilizar as bibliotecas
  • Item 60: Evite float e double se forem necessárias respostas exatas (os tipos float e double devem ser evitados se forem necessárias respostas exatas)
  • Item 61: Prefira tipos primitivos a primitivos em caixa (tipos de dados básicos são melhores que classes wrapper)
  • Item 62: Evite strings onde outros tipos forem mais apropriados (evite usar strings quando outros tipos forem mais apropriados)
  • Item 63: Cuidado com o desempenho da concatenação de strings (cuidado com problemas de desempenho causados ​​pela concatenação de strings)
  • Item 64: Consulte objetos por suas interfaces
  • Item 65: Prefira interfaces à reflexão (Interface é melhor que reflexão)
  • Item 66: Use métodos nativos criteriosamente
  • Item 67: Otimizar criteriosamente
  • Item 68: Siga as convenções de nomenclatura geralmente aceitas
• Capítulo 10. Exceções
  • Capítulo 10 Introdução
  • Item 69: Use exceções apenas para condições excepcionais
  • Item 70: Use exceções verificadas para condições recuperáveis ​​e exceções de tempo de execução para erros de programação (use exceções verificadas para condições recuperáveis ​​e exceções de tempo de execução para erros de programação)
  • Item 71: Evite o uso desnecessário de exceções verificadas (Evite o uso desnecessário de exceções verificadas)
  • Item 72: Favorecer o uso de exceções padrão (incentivar a reutilização de exceções padrão)
  • Item 73: Lançar exceções apropriadas à abstração (lançar exceções que podem ser explicadas pela abstração)
  • Item 74: Documente todas as exceções lançadas por cada método (registre todas as exceções lançadas por cada método)
  • Item 75: Incluir informações de captura de falha em mensagens detalhadas (mensagens detalhadas de exceção devem incluir informações de falha de captura)
  • Item 76: Esforce-se pela atomicidade da falha (tente o seu melhor para garantir a atomicidade da falha)
  • Item 77: Não ignore exceções
• Capítulo 11. Simultaneidade
  • Capítulo 11 Introdução
  • Item 78: Sincronizar o acesso a dados mutáveis ​​compartilhados
  • Item 79: Evite sincronização excessiva
  • Item 80: Prefira executores, tarefas e fluxos a threads (Executores, tarefas e fluxos são melhores do que usar threads diretamente)
  • Item 81: Prefira utilitários de simultaneidade para esperar e notificar (utilitários de simultaneidade são melhores do que esperar e notificar)
  • Item 82: Segurança do thread do documento (o documento deve conter atributos de segurança do thread)
  • Item 83: Use a inicialização lenta criteriosamente
  • Item 84: Não dependa do agendador de threads (Não confie no agendador de threads)
• Capítulo 12. Serialização
  • Capítulo 12 Introdução
  • Item 85: Prefira alternativas à serialização Java (prefira alternativas à serialização Java)
  • Item 86: Implemente Serializable com muito cuidado
  • Item 87: Considere usar um formulário serializado personalizado (Considere usar um formulário serializado personalizado)
  • Item 88: Escrever métodos readObject defensivamente (escrever métodos readObject defensivamente)
  • Item 89: Para controle de instância, prefira tipos enum a readResolve (para controle de instância, tipos enum são melhores que readResolve)
  • Item 90: Considere proxies de serialização em vez de instâncias serializadas (Considere proxies de serialização em vez de instâncias serializadas)