book

Effective Java, 3rd Edition

Name: Effective Java, 3rd Edition
Author: Joshua Bloch
ISBN: 9780134686097

by Joshua Bloch

December 2017

Intermediate to advanced

416 pages

13h 31m

English

Addison-Wesley Professional

Read now

Unlock full access

Cover Page
About This E-Book
Title Page
Copyright Page
Dedication
Contents
Foreword
Preface
Acknowledgments
1 Introduction

2 Creating and Destroying Objects
Item 1: Consider static factory methods instead of constructorsItem 2: Consider a builder when faced with many constructor parametersItem 3: Enforce the singleton property with a private constructor or an enum typeItem 4: Enforce noninstantiability with a private constructorItem 5: Prefer dependency injection to hardwiring resourcesItem 6: Avoid creating unnecessary objectsItem 7: Eliminate obsolete object referencesItem 8: Avoid finalizers and cleanersItem 9: Prefer try-with-resources to try-finally
3 Methods Common to All Objects
Item 10: Obey the general contract when overriding equalsItem 11: Always override hashCode when you override equalsItem 12: Always override toStringItem 13: Override clone judiciouslyItem 14: Consider implementing Comparable
4 Classes and Interfaces
Item 15: Minimize the accessibility of classes and membersItem 16: In public classes, use accessor methods, not public fieldsItem 17: Minimize mutabilityItem 18: Favor composition over inheritanceItem 19: Design and document for inheritance or else prohibit itItem 20: Prefer interfaces to abstract classesItem 21: Design interfaces for posterityItem 22: Use interfaces only to define typesItem 23: Prefer class hierarchies to tagged classesItem 24: Favor static member classes over nonstaticItem 25: Limit source files to a single top-level class
5 Generics
Item 26: Don’t use raw typesItem 27: Eliminate unchecked warningsItem 28: Prefer lists to arraysItem 29: Favor generic typesItem 30: Favor generic methodsItem 31: Use bounded wildcards to increase API flexibilityItem 32: Combine generics and varargs judiciouslyItem 33: Consider typesafe heterogeneous containers
6 Enums and Annotations
Item 34: Use enums instead of int constantsItem 35: Use instance fields instead of ordinalsItem 36: Use EnumSet instead of bit fieldsItem 37: Use EnumMap instead of ordinal indexingItem 38: Emulate extensible enums with interfacesItem 39: Prefer annotations to naming patternsItem 40: Consistently use the Override annotationItem 41: Use marker interfaces to define types
7 Lambdas and Streams
Item 42: Prefer lambdas to anonymous classesItem 43: Prefer method references to lambdasItem 44: Favor the use of standard functional interfacesItem 45: Use streams judiciouslyItem 46: Prefer side-effect-free functions in streamsItem 47: Prefer Collection to Stream as a return typeItem 48: Use caution when making streams parallel
8 Methods
Item 49: Check parameters for validityItem 50: Make defensive copies when neededItem 51: Design method signatures carefullyItem 52: Use overloading judiciouslyItem 53: Use varargs judiciouslyItem 54: Return empty collections or arrays, not nullsItem 55: Return optionals judiciouslyItem 56: Write doc comments for all exposed API elements
9 General Programming
Item 57: Minimize the scope of local variablesItem 58: Prefer for-each loops to traditional for loopsItem 59: Know and use the librariesItem 60: Avoid float and double if exact answers are requiredItem 61: Prefer primitive types to boxed primitivesItem 62: Avoid strings where other types are more appropriateItem 63: Beware the performance of string concatenationItem 64: Refer to objects by their interfacesItem 65: Prefer interfaces to reflectionItem 66: Use native methods judiciouslyItem 67: Optimize judiciouslyItem 68: Adhere to generally accepted naming conventions
10 Exceptions
Item 69: Use exceptions only for exceptional conditionsItem 70: Use checked exceptions for recoverable conditions and runtime exceptions for programming errorsItem 71: Avoid unnecessary use of checked exceptionsItem 72: Favor the use of standard exceptionsItem 73: Throw exceptions appropriate to the abstractionItem 74: Document all exceptions thrown by each methodItem 75: Include failure-capture information in detail messagesItem 76: Strive for failure atomicityItem 77: Don’t ignore exceptions
11 Concurrency
Item 78: Synchronize access to shared mutable dataItem 79: Avoid excessive synchronizationItem 80: Prefer executors, tasks, and streams to threadsItem 81: Prefer concurrency utilities to wait and notifyItem 82: Document thread safetyItem 83: Use lazy initialization judiciouslyItem 84: Don’t depend on the thread scheduler
12 Serialization
Item 85: Prefer alternatives to Java serializationItem 86: Implement Serializable with great cautionItem 87: Consider using a custom serialized formItem 88: Write readObject methods defensivelyItem 89: For instance control, prefer enum types to readResolveItem 90: Consider serialization proxies instead of serialized instances
Items Corresponding to Second Edition
References
Index
Code Snippets

Content preview from Effective Java, 3rd Edition

Chapter 1. Introduction

THIS book is designed to help you make effective use of the Java programming language and its fundamental libraries: java.lang, java.util, and java.io, and subpackages such as java.util.concurrent and java.util.function. Other libraries are discussed from time to time.

This book consists of ninety items, each of which conveys one rule. The rules capture practices generally held to be beneficial by the best and most experienced programmers. The items are loosely grouped into eleven chapters, each covering one broad aspect of software design. The book is not intended to be read from cover to cover: each item stands on its own, more or less. The items are heavily cross-referenced so you can easily plot your own course through ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780134686097

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Effective Java, 3rd Edition

by Joshua Bloch

Chapter 1. Introduction

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.