On Java 8 9780981872520

2,757 652 7MB

English Pages [1778] Year 2021

On Java 8
9780981872520

Author / Uploaded
Bruce Eckel

Table of contents :
Table of Contents
Copyright
Foreword to the Leanpub Edition
Updates
January 2021 Update
March 2021 Update
Preface
Goals
Language Design Errors
Tested Examples
Popularity
Android Programmers
This is Only an eBook
Colophon
Thanks
Dedication
Introduction
Prerequisites
JDK HTML Documentation
Thinking in C
Source Code
Coding Standards
Bug Reports
What About User Interfaces?
What is an Object?
The Progress of Abstraction
An Object Has an Interface
Objects Provide Services
The Hidden Implementation
Reusing the Implementation
Inheritance
Interchangeable Objects with Polymorphism
The Singly-Rooted Hierarchy
Collections
Object Creation & Lifetime
Exception Handling: Dealing with Errors
Summary
Installing Java and the Book Examples
Editors
The Shell
Installing Java
Verify Your Installation
Installing and Running the Book Examples
Objects Everywhere
You Manipulate Objects with References
You Must Create All the Objects
Comments
You Never Need to Destroy an Object
Creating New Data Types: class
Methods, Arguments, and Return Values
Writing a Java Program
Your First Java Program
Coding Style
Summary
Operators
Using Java Operators
Precedence
Assignment
Mathematical Operators
Auto Increment and Decrement
Relational Operators
Logical Operators
Literals
Bitwise Operators
Shift Operators
Ternary if-else Operator
String Operator + and +=
Common Pitfalls When Using Operators
Casting Operators
Java Has No ``sizeof''
A Compendium of Operators
Summary
Control Flow
true and false
if-else
Iteration Statements
For-in Syntax
return
break and continue
The Infamous ``Goto''
switch
Switching on Strings
Summary
Housekeeping
Guaranteed Initialization with the Constructor
Method Overloading
Zero-Argument Constructors
The this Keyword
Cleanup: Finalization and Garbage Collection
Member Initialization
Constructor Initialization
Array Initialization
Enumerated Types
Summary
Implementation Hiding
package: the Library Unit
Java Access Specifiers
Interface and Implementation
Class Access
Summary
Reuse
Composition Syntax
Inheritance Syntax
Delegation
Combining Composition and Inheritance
Choosing Composition vs. Inheritance
protected
Upcasting
The final Keyword
Initialization and Class Loading
Summary
Polymorphism
Upcasting Revisited
The Twist
Constructors and Polymorphism
Covariant Return Types
Designing with Inheritance
Summary
Interfaces
Abstract Classes and Methods
Defining Interfaces
Abstract Classes vs. Interfaces
Complete Decoupling
Combining Multiple Interfaces
Extending an Interface with Inheritance
Adapting to an Interface
Fields in Interfaces
Nesting Interfaces
Interfaces and Factories
Summary
Inner Classes
Creating Inner Classes
The Link to the Outer Class
Using .this and .new
Inner Classes and Upcasting
Inner Classes in Methods and Scopes
Anonymous Inner Classes
Nested Classes
Why Inner Classes?
Inheriting from Inner Classes
Can Inner Classes Be Overridden?
Local Inner Classes
Inner-Class Identifiers
Summary
Collections
Generics and Type-Safe Collections
Basic Concepts
Adding Groups of Elements
Printing Collections
List
Iterators
LinkedList
Stack
Set
Map
Queue
Collection vs. Iterator
for-in and Iterators
Summary
Functional Programming
Old vs. New
Lambda Expressions
Method References
Functional Interfaces
Higher-Order Functions
Closures
Function Composition
Currying and Partial Evaluation
Pure Functional Programming
Summary
Streams
Java 8 Stream Support
Stream Creation
Intermediate Operations
Optional
Terminal Operations
Summary
Exceptions
Concepts
Basic Exceptions
Catching an Exception
Creating Your Own Exceptions
The Exception Specification
Catching Any Exception
Standard Java Exceptions
Performing Cleanup with finally
Exception Restrictions
Constructors
Try-With-Resources
Exception Matching
Alternative Approaches
Exception Guidelines
Summary
Validating Your Code
Testing
Preconditions
Test-Driven Development
Logging
Debugging
Benchmarking
Profiling and Optimizing
Style Checking
Static Error Analysis
Code Reviews
Pair Programming
Refactoring
Continuous Integration
Summary
Files
File and Directory Paths
Directories
File Systems
Watching a Path
Finding Files
Reading & Writing Files
Summary
Strings
Immutable Strings
Overloading + vs. StringBuilder
Unintended Recursion
Operations on Strings
Formatting Output
Regular Expressions
Scanning Input
StringTokenizer
Summary
Reflection
The Need for Reflection
The Class Object
Checking Before a Cast
Registered Factories
Instanceof vs. Class Equivalence
Runtime Class Information
Dynamic Proxies
Using Optional
Interfaces and Type Information
Summary
Generics
Comparison with C++
Simple Generics
Generic Interfaces
Generic Methods
Building Complex Models
The Mystery of Erasure
Compensating for Erasure
Bounds
Wildcards
Issues
Self-Bounded Types
Dynamic Type Safety
Exceptions
Mixins
Latent Typing
Compensating for the Lack of (Direct) Latent Typing
Assisted Latent Typing in Java 8
Summary: Is Casting Really So Bad?
Arrays
Why Arrays are Special
Arrays are First-Class Objects
Returning an Array
Multidimensional Arrays
Arrays and Generics
Arrays.fill()
Arrays.setAll()
Incremental Generators
Random Generators
Generics and Primitive Arrays
Modifying Existing Array Elements
An Aside On Parallelism
Arrays Utilities
Copying an Array
Comparing Arrays
Streams and Arrays
Sorting Arrays
Searching with Arrays.binarySearch()
Accumulating with parallelPrefix()
Summary
Enumerations
Basic enum Features
Adding Methods to an enum
enums in switch Statements
The Mystery of values()
Implements, not Inherits
Random Selection
Using Interfaces for Organization
Using EnumSet Instead of Flags
Using EnumMap
Constant-Specific Methods
Multiple Dispatching
Summary
Annotations
Basic Syntax
Writing Annotation Processors
Using javac to Process Annotations
Annotation-Based Unit Testing
Summary
Concurrent Programming
The Terminology Problem
Concurrency Superpowers
Concurrency is for Speed
The Four Maxims of Java Concurrency
The Brutal Truth
The Rest of the Chapter
Parallel Streams
Creating and Running Tasks
Terminating Long-Running Tasks
CompletableFutures
Deadlock
Constructors are not Thread-Safe
Effort, Complexity, Cost
Summary
Patterns
The Pattern Concept
Singleton
Classifying Patterns
Template Method
Fronting for an Implementation
Factories: Encapsulating Object Creation
Function Objects
Changing the Interface
Interpreter: Run-Time Flexibility
Callbacks
Multiple Dispatching
Pattern Refactoring
Summary
Appendix: Supplements
On Java 8 Example Code
Thinking in C: Foundations for Java
Hands-On Java eSeminar
Appendix: Programming Guidelines
Design
Implementation
Appendix: Javadoc
Syntax
Embedded HTML
Some Example Tags
Documentation Example
Appendix: Passing and Returning Objects
Passing References
Making Local Copies
Controlling Cloneability
Immutable Classes
Summary
Appendix: I/O Streams
Types of InputStream
Types of OutputStream
Adding Attributes and Useful Interfaces
Readers & Writers
Off By Itself: RandomAccessFile
Typical Uses of I/O Streams
Summary
Appendix: Standard I/O
Reading from Standard Input
Changing System.out to a PrintWriter
Redirecting Standard I/O
Process Control
Appendix: New I/O
ByteBuffers
Converting Data
Fetching Primitives
View Buffers
Data Manipulation with Buffers
Memory-Mapped Files
File Locking
Appendix: Understanding equals() and hashCode()
A Canonical equals()
Hashing and Hash Codes
Tuning a HashMap
Appendix: Collection Topics
Sample Data
List Behavior
Set Behavior
Using Functional Operations with any Map
Selecting Parts of a Map
Filling Collections
Custom Collection and Map using Flyweight
Collection Functionality
Optional Operations
Sets and Storage Order
Queues
Understanding Maps
Utilities
Holding References
Java 1.0/1.1 Collections
Summary
Appendix: Low-Level Concurrency
What is a Thread?
Catching Exceptions
Sharing Resources
The volatile Keyword
Atomicity
Critical Sections
Library Components
Summary
Appendix: Data Compression
Simple Compression with GZIP
Multifile Storage with Zip
Java Archives (Jars)
Appendix: Object Serialization
Finding the Class
Controlling Serialization
Using Persistence
Appendix: Benefits and Costs of Static Type Checking
Foreword to the 2021 Edition
Foreword to the Original Edition
Static Type Checking vs. Testing
How to Argue about Typing
The Cost of Productivity
Static vs. Dynamic
Appendix: The Positive Legacy of C++ and Java
Appendix: Becoming a Programmer
How I Got Started in Programming
A Career in Computing
The Mythical 5%
Writing Software Is Like … Writing
Programming as Typing
Do What You Love