Return to Learning Java
See Learning Java Table of Contents
Preface Who Should Read This Book
New Developments New in This Edition (Java 11, 12, 13, 14)
Using This Book
Online Resources
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Acknowledgments
1. A Modern Language Enter Java Java’s Origins
Growing Up
A Virtual Machine
Java Compared with Other Languages
Safety of Design Simplify, Simplify, Simplify…
Type Safety and Method Binding
Incremental Development
Dynamic Memory Management
Error Handling
Threads
Scalability
Safety of Implementation The Verifier
Class Loaders
Security Managers
Application and User-Level Security
A Java Road Map The Past: Java 1.0–Java 11
The Present: Java 14
The Future
Availability
2. A First Application Java Tools and Environment Installing the JDK
Installing OpenJDK on Linux
Installing OpenJDK on macOS
Installing OpenJDK on Windows
Configuring IntelliJ IDEA and Creating a Project
Running the Project
Grabbing the Learning Java Examples
HelloJava Classes
The main() Method
Classes and Objects
Variables and Class Types
HelloComponent
Inheritance
The JComponent Class
Relationships and Finger-Pointing
Package and Imports
The paintComponent() Method
HelloJava2: The Sequel Instance Variables
Constructors
Events
The repaint() Method
Interfaces
Goodbye and Hello Again
3. Tools of the Trade JDK Environment
The Java VM
Running Java Applications System Properties
The Classpath javap
Modules
The Java Compiler
Trying Java
JAR Files File Compression
The jar Utility
The pack200 Utility
Building Up
4. The Java Language Text Encoding
Comments Javadoc Comments
Variables and Constants
Types Primitive Types
Reference Types
Inferring Types
Passing References
A Word About Strings
Statements and Expressions Statements
Expressions
Arrays Array Types
Array Creation and Initialization
Using Arrays
Anonymous Arrays
Multidimensional Arrays
Types and Classes and Arrays, Oh My!
5. Objects in Java Classes Declaring and Instantiating Classes
Accessing Fields and Methods
Static Members
Methods Local Variables
Shadowing
Static Methods
Initializing Local Variables
Argument Passing and References
Wrappers for Primitive Types
Method Overloading
Object Creation Constructors
Working with Overloaded Constructors
Object Destruction Garbage Collection
Packages Importing Classes
Custom Packages
Member Visibility and Access
Compiling with Packages
Advanced Class Design Subclassing and Inheritance
Interfaces
Inner Classes
Anonymous Inner Classes
Organizing Content and Planning for Failure
6. Error Handling and Logging Exceptions Exceptions and Error Classes
Exception Handling
Bubbling Up
Stack Traces
Checked and Unchecked Exceptions
Throwing Exceptions
try Creep
The finally Clause
try with Resources
Performance Issues
Assertions Enabling and Disabling Assertions
Using Assertions
The Logging API Overview
Logging Levels
A Simple Example
Logging Setup Properties
The Logger
Performance
Real-World Exceptions
7. Collections and Generics Collections The Collection Interface
Collection Types
The Map Interface
Type Limitations Containers: Building a Better Mousetrap
Can Containers Be Fixed?
Enter Generics Talking About Types
“There Is No Spoon” Erasure
Raw Types
Parameterized Type Relationships Why Isn’t a List<Date> a List<Object>?
Casts Converting Between Collections and Arrays
Iterator
A Closer Look: The sort() Method
Application: Trees on the Field
Conclusion
8. Text and Core Utilities Strings Constructing Strings
Strings from Things
Comparing Strings
Searching
String Method Summary
Things from Strings Parsing Primitive Numbers
Tokenizing Text
Regular Expressions Regex Notation
The java.util.regex API
Math Utilities The java.lang.Math Class
Big/Precise Numbers
Dates and Times Local Dates and Times
Comparing and Manipulating Dates and Times
Time Zones
Parsing and Formatting Dates and Times
Parsing Errors
Timestamps
Other Useful Utilities
9. Threads Introducing Threads The Thread Class and the Runnable Interface
Controlling Threads
Death of a Thread
Synchronization Serializing Access to Methods
Accessing Class and Instance Variables from Multiple Threads
Scheduling and Priority Thread State
Time-Slicing
Priorities
Yielding
Thread Performance The Cost of Synchronization
Thread Resource Consumption
Concurrency Utilities
10. Desktop Applications Buttons and Sliders and Text Fields, Oh My! Component Hierarchies
Model View Controller Architecture
Labels and Buttons
Text Components
Other Components
Containers and Layouts Frames and Windows
JPanel
Layout Managers
Events Mouse Events
Action Events
Change Events
Other Events
Modals and Pop Ups Message Dialogs
Confirmation Dialogs
Input Dialogs
Threading Considerations SwingUtilities and Component Updates
Timers
Next Steps Menus
Preferences
Custom Components and Java2D
JavaFX
User Interface and User Experience
11. Networking and I/O Streams Basic I/O
Character Streams
Stream Wrappers
The java.io.File Class
File Streams
RandomAccessFile
The NIO File API FileSystem and Path
NIO File Operations
The NIO Package Asynchronous I/O
Performance
Mapped and Locked Files
Channels
Buffers
Character Encoders and Decoders
FileChannel
Network Programming
Sockets Clients and Servers
The DateAtHost Client
A Distributed Game
More to Explore
12. Programming for the Web Uniform Resource Locators
The URL Class Stream Data
Getting the Content as an Object
Managing Connections
Handlers in Practice
Useful Handler Frameworks
Talking to Web Applications Using the GET Method
Using the POST Method
The HttpURLConnection
SSL and Secure Web Communications
Java Web Applications The Servlet Life Cycle
Servlets
The HelloClient Servlet
The Servlet Response
Servlet Parameters
The ShowParameters Servlet
User Session Management
The ShowSession Servlet
Servlet Containers Configuration with web.xml and Annotations
URL Pattern Mappings
Deploying HelloClient
The World Wide Web Is, Well, Wide
13. Expanding Java Java Releases JCP and JSRs
Lambda Expressions Retrofitting Your Code
Expanding Java Beyond the Core
Final Wrap-Up and Next Steps
A. Code Examples and IntelliJ IDEA Grabbing the Main Code Examples
Installing IntelliJ IDEA Installing on Linux
Installing on a macOS
Installing on Windows
Importing the Examples
Running the Examples
Grabbing the Web Code Examples
Working with Servlets