O Guia Definitivo das Melhores Práticas com Java ― Atualizado para o Java 7, 8 e 9 Desde a publicação anterior de Java Efetivo, após o lançamento da versão 6, o Java mudou radicalmente. Este clássico vencedor do prêmio Jolt foi todo atualizado para aproveitar ao máximo os recursos mais recentes da plataforma e de suas bibliotecas. A diversidade de paradigmas no Java moderno demanda recomendações específicas quanto às melhores práticas, e este livro as disponibiliza.Como nas edições anteriores, cada capítulo de Java Efetivo, Terceira Edição é composto de inúmeros “itens” apresentados como ensaios independentes e curtos quetrazem recomendações específicas, informações sobre as sutilezas da plataforma e exemplos de códigos atualizados.As descrições e explicações completas de cada item esclarecem o que fazer, o que não fazer e o porquê.Esta edição aborda os recursos e as bibliotecas do Java 7, 8 e 9, como as construções de programação funcional, adicionadas às raízes da programação orientada a objetos.Adicionou-se muitos itens novos também, incluindo um capítulo dedicado aos lambdas e às streams. A NOVA EDIÇÃO INCLUI• Interfaces funcionais, expressões lambdas,referências para método e streams• Métodos estáticos e padrões para interfaces• Inferência de tipo, incluindo o operador <> para os tipos genéricos• Anotação @SafeVarargs• Instruções try-with-resources• Recursos das bibliotecas novas, como a interface Optional , a java.time e a facilidade dos métodos de fabricação para as coleções Este livro foi elaborado para ajudá-lo a utilizar de modo efetivo a linguagem e as bibliotecas de programação Java: java.lang, java.util e java.io, e os subpacotesJava, tais como, o java.util.concurrent e o java.util.function. Outras bibliotecas são discutidas eventualmente.Esta obra é composta de 90 Itens, e cada um deles aborda o conhecimento de uma regra. Geralmente, as regras descrevem as práticas consideradas produtivaspelos melhores e mais experientes programadores. Os Itens são agrupados em 11 capítulos, cada qual abrange um aspecto amplo da arquitetura de software. A finalidade da obra não é ser lida do princípio ao fim: cada Item é mais ou menos independente. Os Itens estão amplamente correlacionados; desse modo, você pode facilmente trilhar o próprio caminho através das páginas.Introduziram-se muitos recursos à plataforma desde a publicação da última edição deste livro. A maioria dos Itens desta obra usa de alguma forma essas funcionalidades. A tabela a seguir lhe mostra onde encontrar as principais funcionalidades elencadas: Funcionalidade Itens VersãoLambdas Itens 42–44 Java 8Streams Itens 45–48 Java 8Opcionais Item 55 Java 8Métodos padrões nas interfaces Item 21 Java 8try-with-resources Item 9 Java 7@SafeVarargs Item 32 Java 7Modules Item 15 Java 9.

lgli/Java Efetivo-Joshua Bloch(2019).pdf

lgrsnf/Java Efetivo-Joshua Bloch(2019).pdf

zlib/Computers/Programming/Joshua Bloch/Java Efetivo (Terceira Edição)_5999322.pdf

Effective Java Programming Language Guide

Java. Эффективное программирование

Effective JavaTM

Джошуа Блох; [перевод с английского и редакция И. В. Красикова]

Bloch, Joshua

Блох, Джошуа

Globe Fearon Educational Publishing

Addison-Wesley Professional

Диалектика; Диалектика

Longman Publishing

Addison Wesley

Cengage Gale

3-е изд., Москва, Санкт-Петербург, Russia, 2022

Pearson Education (US), Boston, MA, 2017

United States, United States of America

3rd Edition, December 27, 2017

Third edition, Boston, 2018

Third Edition, PS, 2017

3rd ed, Boston, 2018

Brazil, Brazil

Jan 06, 2018

{"edition":"3","isbns":["0134685997","8550813281","9780134685991","9788550813288"],"publisher":"Alta Books"}

Предм. указ.: с. 453-457
Библиогр.: с. 449-452
Пер.: Bloch, Joshua (1961- ) Effective Java 3th ed. Boston [etc.] : Addison-Wesley, cop. 2018 978-0-13-468599-1

РГБ

Russian State Library [rgb] MARC:
=001 011124931
=005 20220609100811.0
=008 181224s2022\\\\ru\||||\\\\\\\0||\|\rus|d
=017 \\ $a КН-П-22-041862 $b RuMoRKP
=017 \\ $a КН-П-18-097759 $b RuMoRKP
=020 \\ $a 978-5-6041394-4-8 $c 500 экз.
=040 \\ $a RuMoRGB $b rus $e rcr
=041 1\ $a rus $h eng
=044 \\ $a ru
=084 \\ $a З973.2-018.19Java,0 $2 rubbk
=100 1\ $a Блох, Джошуа $d 1961-
=245 00 $a Java. Эффективное программирование $c Джошуа Блох ; [перевод с английского и редакция И. В. Красикова]
=250 \\ $a 3-е изд.
=260 \\ $a Москва $b Диалектика ; $c 2022 $a Санкт-Петербург $b Диалектика
=300 \\ $a 457 с. $c 24 см
=336 \\ $a текст (text) $b txt $2 rdacontent
=337 \\ $a неопосредованный (unmediated) $b n $2 rdamedia
=338 \\ $a том (volume) $b nc $2 rdacarrier
=500 \\ $a Предм. указ.: с. 453-457
=504 \\ $a Библиогр.: с. 449-452
=534 \\ $p Пер.: $a Bloch, Joshua (1961- ) $t Effective Java $b 3th ed. $c Boston [etc.] : Addison-Wesley, cop. 2018 $z 978-0-13-468599-1
=650 \7 $a Вычислительная техника -- Вычислительные машины электронные цифровые -- Программирование -- Языки программирования -- Java $2 rubbk
=852 \\ $a РГБ $b FB $j 2 22-35/207 $x 90

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

Since this Jolt-award winning classic was last updated in 2008 (shortly after Java 6 was released), Java has changed dramatically. The principal enhancement in Java 8 was the addition of functional programming constructs to Java's object-oriented roots. Java 7, 8, and 9 also introduced language features, such as the try-with-resources statement, the diamond operator for generic types, default and static methods in interfaces, the @SafeVarargs annotation, and modules. New library features include pervasive use of functional interfaces and streams, the java.time package for manipulating dates and times, and numerous minor enhancements such as convenience factory methods for collections.
In this new edition of Effective Java , Bloch updates the work to take advantage of these new language and library features, and provides specific best practices for their use. Java's increased support for multiple paradigms increases the need for best-practices advice, and this book delivers.
As in previous editions, each chapter consists of several "items," each presented in the form of a short, standalone essay that provides specific advice, insight into Java platform subtleties, and updated code examples. The comprehensive descriptions and explanations for each item illuminate what to do, what not to do, and why. Coverage includes:
Updated techniques and best practices on classic topics, including objects, classes, methods, libraries, and generics How to avoid the traps and pitfalls of commonly misunderstood subtleties of the platform Focus on the language and its most fundamental libraries, such as java.lang and java.util

The Definitive Guide to Java Platform Best Practices--Updated for Java 7, 8, and 9 Java has changed dramatically since the previous edition of Effective Java was published shortly after the release of Java 6. This Jolt award-winning classic has now been thoroughly updated to take full advantage of the latest language and library features. The support in modern Java for multiple paradigms increases the need for specific best-practices advice, and this book delivers. As in previous editions, each chapter of Effective Java, Third Edition, consists of several "items," each presented in the form of a short, stand-alone essay that provides specific advice, insight into Java platform subtleties, and updated code examples. The comprehensive descriptions and explanations for each item illuminate what to do, what not to do, and why. The third edition covers language and library features added in Java 7, 8, and 9, including the functional programming constructs that were added to its object-oriented roots. Many new items have been added, including a chapter devoted to lambdas and streams. New coverage includes Functional interfaces, lambda expressions, method references, and streams Default and static methods in interfaces Type inference, including the diamond operator for generic types The @SafeVarargs annotation The try-with-resources statement New library features such as the Optional interface, java.time, and the convenience factory methods for collections Register your product at informit.com/register for convenient access to the web edition eBook, updates, and/or corrections as they become available

Introduction -- Creating And Destroying Objects -- Methods Common To All Objects -- Classes And Interfaces -- Generics -- Enums And Annotations -- Methods -- General Programming -- Exceptions -- Concurrency -- Serialization. Joshua Bloch. Updated For Java 9--cover. Includes Bibliographical References And Index.

2022-04-11