Java in a Nutshell: A Desktop Quick Reference

Foreword
Preface
Changes in the Eighth Edition
Contents of This Book
Related Books
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments
I. Introducing Java
1. Introduction to the Java Environment
The Language, the JVM, and the Ecosystem
What Is the Java Language?
What Is the JVM?
What Is the Java Ecosystem?
The Lifecycle of a Java Program
Frequently Asked Questions
Comparing Java to Other Languages
Java Compared to JavaScript
Java Compared to Python
Java Compared to C
Java Compared to C++
Answering Some Criticisms of Java
Overly Verbose
Slow to Change
Performance Problems
Insecure
Too Corporate
A Brief History of Java and the JVM
Summary
2. Java Syntax from the Ground Up
Java Programs from the Top Down
Lexical Structure
The Unicode Character Set
Case Sensitivity and Whitespace
Comments
Reserved Words
Identifiers
Literals
Punctuation
Primitive Data Types
The boolean Type
The char Type
Integer Types
Floating-Point Types
Primitive Type Conversions
Expressions and Operators
Operator Summary
Arithmetic Operators
String Concatenation Operator
Increment and Decrement Operators
Comparison Operators
Boolean Operators
Bitwise and Shift Operators
Assignment Operators
The Conditional Operator
The instanceof Operator
Special Operators
Statements
Expression Statements
Compound Statements
The Empty Statement
Labeled Statements
Local Variable Declaration Statements
The if/else Statement
The switch Statement
The switch Expression
The while Statement
The do Statement
The for Statement
The foreach Statement
The break Statement
The continue Statement
The return Statement
The synchronized Statement
The throw Statement
The try/catch/finally Statement
The try-with-resources Statement
The assert Statement
Methods
Defining Methods
Method Modifiers
Checked and Unchecked Exceptions
Variable-Length Argument Lists
Introduction to Classes and Objects
Defining a Class
Creating an Object
Using an Object
Object Literals
Lambda Expressions
Arrays
Array Types
Creating and Initializing Arrays
Using Arrays
Multidimensional Arrays
Reference Types
Reference Versus Primitive Types
Manipulating Objects and Reference Copies
Comparing Objects
Boxing and Unboxing Conversions
Packages and the Java Namespace
Package Declaration
Globally Unique Package Names
Importing Types
Importing Static Members
Java Source File Structure
Defining and Running Java Programs
Summary
3. Object-Oriented Programming in Java
Overview of Classes and Records
Basic OO Definitions
Records
Other Reference Types
Class Definition Syntax
Fields and Methods
Field Declaration Syntax
Class Fields
Class Methods
Instance Fields
Instance Methods
How the this Reference Works
Creating and Initializing Objects
Defining a Constructor
Defining Multiple Constructors
Invoking One Constructor from Another
Field Defaults and Initializers
Record Constructors
Subclasses and Inheritance
Extending a Class
Superclasses, Object, and the Class Hierarchy
Subclass Constructors
Constructor Chaining and the Default Constructor
Hiding Superclass Fields
Overriding Superclass Methods
Sealed Classes
Data Hiding and Encapsulation
Access Control
Data Accessor Methods
Abstract Classes and Methods
Reference Type Conversions
Modifier Summary
Summary
4. The Java Type System
Interfaces
Defining an Interface
Extending Interfaces
Implementing an Interface
Records and Interfaces
Sealed Interfaces
Default Methods
Marker Interfaces
Java Generics
Introduction to Generics
Generic Types and Type Parameters
Diamond Syntax
Type Erasure
Bounded Type Parameters
Introducing Covariance
Wildcards
Generic Methods
Compile and Runtime Typing
Using and Designing Generic Types
Enums and Annotations
Enums
Annotations
Defining Custom Annotations
Type Annotations
Lambda Expressions
Lambda Expression Conversion
Method References
Functional Programming
Lexical Scoping and Local Variables
Nested Types
Static Member Types
Nonstatic Member Classes
Local Classes
Anonymous Classes
Describing the Java Type System
Nominal Typing
Nondenotable Types and var
Summary
5. Introduction to Object-Oriented Design in Java
Java Values
Important Common Methods
toString()
equals()
hashCode()
Comparable::compareTo()
clone()
Constants
Working with Fields
Field Inheritance and Accessors
Singleton
Factory Methods
Builders
Interfaces Versus Abstract Classes
Do Default Methods Change Java’s Inheritance Model?
OOD Using Lambdas
Lambdas Versus Nested Classes
Lambdas Versus Method References
OOD Using Sealed Types
OOD Using Records
Instance Methods or Class Methods?
A word about System.out.println()
Composition Versus Inheritance
Exceptions and Exception Handling
Safe Java Programming
6. Java’s Approach to Memory and Concurrency
Basic Concepts of Java Memory Management
Memory Leaks in Java
Introducing Mark-and-Sweep
How the JVM Optimizes Garbage Collection
Evacuation
Compaction
The HotSpot Heap
G1
ParallelOld
Serial
Shenandoah
ZGC
Finalization
Finalization Details
Java’s Support for Concurrency
Thread Lifecycle
Visibility and Mutability
Exclusion and Protecting State
volatile
Useful Methods of Thread
Deprecated Methods of Thread
Working with Threads
Summary
II. Working with the Java Platform
7. Programming and Documentation Conventions
Naming and Capitalization Conventions
Practical Naming
Java Documentation Comments
Structure of a Doc Comment
Doc-Comment Tags
Inline Doc-Comment Tags
Cross-References in Doc Comments
Doc Comments for Packages
Doclets
Conventions for Portable Programs
Summary
8. Working with Java Collections
Introduction to Collections API
The Collection Interface
The Set Interface
The List Interface
The Map Interface
The Queue and BlockingQueue Interfaces
Adding Elements to Queues
Removing Elements from Queues
Utility Methods
Arrays and Helper Methods
Java Streams and Lambda Expressions
Functional Approaches
The Streams API
Summary
9. Handling Common Data Formats
Text
Special Syntax for Strings
String Immutability
String Formatting
Regular Expressions
Numbers and Math
How Java Represents Integer Types
Java and Floating-Point Numbers
Java’s Standard Library of Mathematical Functions
Date and Time
Introducing the Java 8 Date and Time API
Queries
Adjusters
Timezones
Legacy Date and Time
Summary
10. File Handling and I/O
Classic Java I/O
Files
I/O Streams
Readers and Writers
try-with-resources Revisited
Problems with Classic I/O
Modern Java I/O
Files
Path
NIO Channels and Buffers
ByteBuffer
Mapped Byte Buffers
Async I/O
Future-Based Style
Callback-Based Style
Watch Services and Directory Searching
Networking
HTTP
TCP
IP
Summary
11. Classloading, Reflection, and Method Handles
Class Files, Class Objects, and Metadata
Examples of Class Objects
Class Objects and Metadata
Phases of Classloading
Loading
Verification
Preparation and Resolution
Initialization
Secure Programming and Classloading
Applied Classloading
Classloader Hierarchy
Reflection
When to Use Reflection
How to Use Reflection
Dynamic Proxies
Method Handles
MethodType
Method Lookup
Invoking Method Handles
12. Java Platform Modules
Why Modules?
Modularizing the JDK
Writing Your Own Modules
Basic Modules Syntax
Building a Simple Modular Application
The Module Path
Automatic Modules
Open Modules
Providing Services
Multi-Release JARs
Converting to a Multi-Release JAR
Migrating to Modules
Custom Runtime Images
Issues with Modules
Unsafe and Related Problems
Lack of Versioning
Slow Adoption Rates
Summary
13. Platform Tools
Command-Line Tools
Introduction to JShell
Introduction to Java Flight Recorder (JFR)
Summary
Appendix. Beyond Java 17
Long-Term JDK Projects
Amber
Java 18
Panama
Java 19
Loom
Future Java
Valhalla
Cloud-Native Java
Index
About the Authors