Effective java 3 издание

Java: эффективное программирование. 3 изд

Говоря о третьем издании книги «Эффективное программирование на Java», достаточно упомянуть его автора — Джошуа Блоха — и это будет наилучшей ее рекомендацией.

Книга представляет собой овеществленный опыт ее автора как программиста на Java. Новые возможности этого языка программирования, появившиеся в версиях, вышедших со времен предыдущего издания книги, по сути знаменуют появление совершенно новых концепций, так что для их эффективного использования недостаточно просто узнать об их существовании, и программировать на современном Java с использованием старых парадигм.

К программированию в полной мере относится фраза Евклида о том, что в геометрии нет царских путей. Но пройти путь изучения и освоения языка программирования вам может помочь проводник, показывающий наиболее интересные места и предупреждающий о ямах и ухабах. Таким проводником может послужить книга Джошуа Блоха. С ней вы не заблудитесь и не забредете в дебри, из которых будете долго и трудно выбираться с помощью отладчика.

При этом книга не просто научит вас использовать новые возможности языка — она научит использовать их эффективно. Но и это не все — книга не просто учит эффективному применению Java, но еще и рассказывает, почему ту или иную задачу следует решать именно так.

Эта книга заставляет вас не просто заучить правила — она заставляет думать.

И хотя эта книга в первую очередь предназначена для энтузиастов и профессионалов, она достойна места на полке любого программиста — как профессионала, так и зеленого новичка.

Язык программирования Java существенно изменился со времени предыдущего издания книги, опубликованного вскоре после выпуска Java 6. Этот классический труд тщательно обновлен, чтобы читатели могли в полной мере воспользоваться возможностями последних версий языка и его библиотек функций. В современном Java поддерживается несколько парадигм программирования. Поэтому программисты часто испытывают потребность в конкретных рекомендациях, которые и описаны в данной книге.

Если вам понравилась эта книга поделитесь ею с друзьями, тем самым вы помогаете нам развиваться и добавлять всё больше интересных и нужным вам книг!

Источник

Effective Java 3rd Edition – A Must-Read for Every Developer

The Persistence Hub is the place to be for every Java developer. It gives you access to all my premium video courses, 2 monthly Q&A calls, monthly coding challenges, a community of like-minded developers, and regular expert sessions.

Joshua Bloch finally updated his popular book Effective Java for Java 7, 8 and 9. The previous edition was one of the most popular books among professional Java developers, and I couldn’t wait to finally read the updated 3rd edition. I got this book 2 weeks ago, and it more than fulfilled my expectations. It is packed with best practices and detailed descriptions of the finer details of the Java language. Every developer should at least read the chapters about generics and lambdas.

Quick Review

Joshua Bloch does an amazing job explaining best practices and providing detailed insights into how and when to use the different Java features. Effective Java is a must-read for every professional Java developer. 5 out of 5 stars!

Who should read this book

Detailed Review

You can get a lot of books about Java, and several of them do a good job explaining the different language features. But as a professional developer, you know that this is just the first step. There is a huge difference between knowing a feature and understanding when and how to use it to build an efficient and maintainable application. If you read the previous editions of Joshua Bloch’s book Effective Java, you know that he did a great job explaining best practices and showing how to write readable and maintainable code. That doesn’t change with the 3rd edition which he updated to include the features and paradigms introduced in Java 7, 8 and 9. Especially the chapters about interface design, generics and lambdas are a must-read for every Java developer.

Detailed And Specific Advice In 90 Items

• Creating and destroying objects
• Methods common to all objects
• Classes and interfaces
• Generics
• Enums and annotations
• Lambdas and Streams
• Methods
• General programming
• Exceptions
• Concurrency
• Serialization

Источник

Effective Java, 3rd Edition

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Book description

Since this Jolt-award winning classic was last updated in 2008, the Java programming environment has changed dramatically. Java 7 and Java 8 introduced new features and functions including, forEach() method in Iterable interface, default and static methods in Interfaces, Functional Interfaces and Lambda Expressions, Java Stream API for Bulk Data Operations on Collections, Java Time API, Collection API improvements, Concurrency API improvements, and Java IO improvements.

In this new edition of Effective Java, Bloch explores new design patterns and language idioms that have been introduced since the second edition was released in 2008 shortly after Java SE6, including Lambda, streams, generics and collections, as well as selected Java 9 features.

As in previous editions, each chapter consists of several “items” 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.

• Updated techniques and best practices on classic topics, including objects, classes, libraries, methods, and serialization
• How to avoid the traps and pitfalls of commonly misunderstood subtleties of the language
• Focus on the language and its most fundamental libraries: java.lang, java.util, and, to a lesser extent, java.util.concurrent and java.io

Table of contents

1. Cover Page
2. About This E-Book
3. Title Page
4. Copyright Page
5. Dedication
6. Contents
7. Foreword
8. Preface
9. Acknowledgments
10. 1 Introduction
11. 2 Creating and Destroying Objects
    1. Item 1: Consider static factory methods instead of constructors
    2. Item 2: Consider a builder when faced with many constructor parameters
    3. Item 3: Enforce the singleton property with a private constructor or an enum type
    4. Item 4: Enforce noninstantiability with a private constructor
    5. Item 5: Prefer dependency injection to hardwiring resources
    6. Item 6: Avoid creating unnecessary objects
    7. Item 7: Eliminate obsolete object references
    8. Item 8: Avoid finalizers and cleaners
    9. Item 9: Prefer try-with-resources to try-finally
    1. Item 10: Obey the general contract when overriding equals
    2. Item 11: Always override hashCode when you override equals
    3. Item 12: Always override toString
    4. Item 13: Override clone judiciously
    5. Item 14: Consider implementing Comparable
    1. Item 15: Minimize the accessibility of classes and members
    2. Item 16: In public classes, use accessor methods, not public fields
    3. Item 17: Minimize mutability
    4. Item 18: Favor composition over inheritance
    5. Item 19: Design and document for inheritance or else prohibit it
    6. Item 20: Prefer interfaces to abstract classes
    7. Item 21: Design interfaces for posterity
    8. Item 22: Use interfaces only to define types
    9. Item 23: Prefer class hierarchies to tagged classes
    10. Item 24: Favor static member classes over nonstatic
    11. Item 25: Limit source files to a single top-level class
    1. Item 26: Don’t use raw types
    2. Item 27: Eliminate unchecked warnings
    3. Item 28: Prefer lists to arrays
    4. Item 29: Favor generic types
    5. Item 30: Favor generic methods
    6. Item 31: Use bounded wildcards to increase API flexibility
    7. Item 32: Combine generics and varargs judiciously
    8. Item 33: Consider typesafe heterogeneous containers
    1. Item 34: Use enums instead of int constants
    2. Item 35: Use instance fields instead of ordinals
    3. Item 36: Use EnumSet instead of bit fields
    4. Item 37: Use EnumMap instead of ordinal indexing
    5. Item 38: Emulate extensible enums with interfaces
    6. Item 39: Prefer annotations to naming patterns
    7. Item 40: Consistently use the Override annotation
    8. Item 41: Use marker interfaces to define types
    1. Item 42: Prefer lambdas to anonymous classes
    2. Item 43: Prefer method references to lambdas
    3. Item 44: Favor the use of standard functional interfaces
    4. Item 45: Use streams judiciously
    5. Item 46: Prefer side-effect-free functions in streams
    6. Item 47: Prefer Collection to Stream as a return type
    7. Item 48: Use caution when making streams parallel
    1. Item 49: Check parameters for validity
    2. Item 50: Make defensive copies when needed
    3. Item 51: Design method signatures carefully
    4. Item 52: Use overloading judiciously
    5. Item 53: Use varargs judiciously
    6. Item 54: Return empty collections or arrays, not nulls
    7. Item 55: Return optionals judiciously
    8. Item 56: Write doc comments for all exposed API elements
    1. Item 57: Minimize the scope of local variables
    2. Item 58: Prefer for-each loops to traditional for loops
    3. Item 59: Know and use the libraries
    4. Item 60: Avoid float and double if exact answers are required
    5. Item 61: Prefer primitive types to boxed primitives
    6. Item 62: Avoid strings where other types are more appropriate
    7. Item 63: Beware the performance of string concatenation
    8. Item 64: Refer to objects by their interfaces
    9. Item 65: Prefer interfaces to reflection
    10. Item 66: Use native methods judiciously
    11. Item 67: Optimize judiciously
    12. Item 68: Adhere to generally accepted naming conventions
    1. Item 69: Use exceptions only for exceptional conditions
    2. Item 70: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors
    3. Item 71: Avoid unnecessary use of checked exceptions
    4. Item 72: Favor the use of standard exceptions
    5. Item 73: Throw exceptions appropriate to the abstraction
    6. Item 74: Document all exceptions thrown by each method
    7. Item 75: Include failure-capture information in detail messages
    8. Item 76: Strive for failure atomicity
    9. Item 77: Don’t ignore exceptions
    1. Item 78: Synchronize access to shared mutable data
    2. Item 79: Avoid excessive synchronization
    3. Item 80: Prefer executors, tasks, and streams to threads
    4. Item 81: Prefer concurrency utilities to wait and notify
    5. Item 82: Document thread safety
    6. Item 83: Use lazy initialization judiciously
    7. Item 84: Don’t depend on the thread scheduler
    1. Item 85: Prefer alternatives to Java serialization
    2. Item 86: Implement Serializable with great caution
    3. Item 87: Consider using a custom serialized form
    4. Item 88: Write readObject methods defensively
    5. Item 89: For instance control, prefer enum types to readResolve
    6. Item 90: Consider serialization proxies instead of serialized instances

    Product information

    • Title: Effective Java, 3rd Edition
    • Author(s): Joshua Bloch
    • Release date: December 2017
    • Publisher(s): Addison-Wesley Professional
    • ISBN: 9780134686097

    You might also like

    Check it out now on O’Reilly

    Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

    Источник

    Effective Java, 3rd Edition

    

    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

    Resolve the captcha to access the links!

    Источник