book

Core Java, Vol. I: Fundamentals, 14th Edition

Name: Core Java, Vol. I: Fundamentals, 14th Edition
Author: Cay S. Horstmann
ISBN: 9780135558553

by Cay S. Horstmann

November 2025

Intermediate to advanced

736 pages

21h 29m

English

Pearson

Read now

Unlock full access

Preface
To the Reader A Tour of This Book Conventions Sample Code
Acknowledgments
1. An Introduction to Java
1.1. Java as a Programming Platform1.2. The Java “White Paper” Buzzwords1.2.1. Simple1.2.2. Object-Oriented1.2.3. Distributed1.2.4. Robust1.2.5. Secure1.2.6. Architecture-Neutral1.2.7. Portable1.2.8. Interpreted1.2.9. High-Performance1.2.10. Multithreaded1.2.11. Dynamic1.3. Java Applets and the Internet1.4. A Short History of Java1.5. Common Misconceptions about Java
2. The Java Programming Environment
2.1. Installing the Java Development Kit2.1.1. Downloading the JDK2.1.2. Setting Up the JDK2.1.3. Source Files and Documentation2.2. Using the Command-Line Tools2.3. Using an Integrated Development Environment2.4. JShell
3. Fundamental Programming Structures in Java
3.1. A Simple Java Program3.2. Comments3.3. Data Types3.3.1. Integer Types3.3.2. Floating-Point Types3.3.3. The char Type3.3.4. Unicode and the char Type3.3.5. The boolean Type3.4. Variables and Constants3.4.1. Declaring Variables3.4.2. Initializing Variables3.4.3. Constants3.4.4. Enumerated Types3.5. Operators3.5.1. Arithmetic Operators3.5.2. Mathematical Functions and Constants3.5.3. Conversions between Numeric Types3.5.4. Casts3.5.5. Assignment3.5.6. Increment and Decrement Operators3.5.7. Relational and boolean Operators3.5.8. The Conditional Operator3.5.9. Switch Expressions3.5.10. Bitwise Operators3.5.11. Parentheses and Operator Hierarchy3.6. Strings3.6.1. Concatenation3.6.2. Static and Instance Methods3.6.3. Indexes and Substrings3.6.4. Strings Are Immutable3.6.5. Testing Strings for Equality3.6.6. Empty and Null Strings3.6.7. The String API3.6.8. Reading the Online API Documentation3.6.9. Building Strings3.6.10. Text Blocks3.7. Input and Output3.7.1. Reading Input3.7.2. Formatting Output3.8. Control Flow3.8.1. Block Scope3.8.2. Conditional Statements3.8.3. Loops3.8.4. Determinate Loops3.8.5. Multiple Selections with switch3.8.6. Statements That Break Control Flow3.9. Big Numbers3.10. Arrays3.10.1. Declaring Arrays3.10.2. Accessing Array Elements3.10.3. The “for each” Loop3.10.4. Array Copying3.10.5. Command-Line Arguments3.10.6. Array Sorting3.10.7. Multidimensional Arrays3.10.8. Ragged Arrays
4. Objects and Classes
4.1. Introduction to Object-Oriented Programming4.1.1. Classes4.1.2. Objects4.1.3. Identifying Classes4.1.4. Relationships between Classes4.2. Using Predefined Classes4.2.1. Objects and Object Variables4.2.2. The LocalDate Class of the Java Library4.2.3. Mutator and Accessor Methods4.3. Defining Your Own Classes4.3.1. An Employee Class4.3.2. Dissecting the Employee Class4.3.3. First Steps with Constructors4.3.4. Declaring Local Variables with var4.3.5. Working with null References4.3.6. Implicit and Explicit Parameters4.3.7. Benefits of Encapsulation4.3.8. Class-Based Access Privileges4.3.9. Private Methods4.3.10. Final Instance Fields4.4. Static Fields and Methods4.4.1. Static Fields4.4.2. Static Constants4.4.3. Static Methods4.4.4. Factory Methods4.4.5. The main Method4.5. Method Parameters4.6. Object Construction4.6.1. Overloading4.6.2. Default Field Initialization4.6.3. The Constructor with No Arguments4.6.4. Explicit Field Initialization4.6.5. Parameter Names4.6.6. Calling Another Constructor4.6.7. Initialization Blocks4.6.8. Static Initialization4.7. Records4.7.1. The Record Concept4.7.2. Constructors: Canonical, Compact, and Custom4.8. Packages4.8.1. Encapsulation4.8.2. Package Names4.8.3. Class Importation4.8.4. Module Imports4.8.5. Static Imports4.8.6. Addition of a Class into a Package4.8.7. Compiling with Packages4.8.8. Package Access4.8.9. The Class Path4.8.10. Setting the Class Path4.9. JAR Files4.9.1. Creating JAR files4.9.2. The Manifest4.9.3. Executable JAR Files4.9.4. Multi-Release JAR Files4.9.5. A Note about Command-Line Options4.10. Documentation Comments4.10.1. Comment Insertion4.10.2. Class Comments4.10.3. Method Comments4.10.4. Field Comments4.10.5. Package Comments4.10.6. HTML Markup4.10.7. Links4.10.8. General Comments4.10.9. Code Snippets4.10.10. Comment Extraction4.11. Class Design Hints
5. Inheritance
5.1. Classes, Superclasses, and Subclasses5.1.1. Defining Subclasses5.1.2. Overriding Methods5.1.3. Subclass Constructors5.1.4. Inheritance Hierarchies5.1.5. Polymorphism5.1.6. Understanding Method Calls5.1.7. Preventing Inheritance: Final Classes and Methods5.1.8. Casting5.1.9. Pattern Matching for instanceof5.1.10. Protected Access5.2. Object: The Cosmic Superclass5.2.1. Variables of Type Object5.2.2. The equals Method5.2.3. Equality Testing and Inheritance5.2.4. The hashCode Method5.2.5. The toString Method5.3. Generic Array Lists5.3.1. Declaring Array Lists5.3.2. Accessing Array List Elements5.3.3. Compatibility between Typed and Raw Array Lists5.4. Object Wrappers and Autoboxing5.5. Methods with a Variable Number of Arguments5.6. Abstract Classes5.7. Enumeration Classes5.8. Sealed Classes5.9. Pattern Matching5.9.1. Null Handling5.9.2. Guards5.9.3. Exhaustiveness5.9.4. Dominance5.9.5. Patterns and Constants5.9.6. Variable Scope and Fallthrough5.10. Reflection5.10.1. The Class Class5.10.2. A Primer on Declaring Exceptions5.10.3. Resources5.10.4. Using Reflection to Analyze the Capabilities of Classes5.10.5. Using Reflection to Analyze Objects at Runtime5.10.6. Using Reflection to Write Generic Array Code5.10.7. Invoking Arbitrary Methods and Constructors5.11. Design Hints for Inheritance
6. Interfaces, Lambda Expressions, and Inner Classes
6.1. Interfaces6.1.1. The Interface Concept6.1.2. Properties of Interfaces6.1.3. Interfaces and Abstract Classes6.1.4. Static and Private Methods6.1.5. Default Methods6.1.6. Resolving Default Method Conflicts6.1.7. Interfaces and Callbacks6.1.8. The Comparator Interface6.1.9. Object Cloning6.2. Lambda Expressions6.2.1. Why Lambdas?6.2.2. The Syntax of Lambda Expressions6.2.3. Functional Interfaces6.2.4. Function Types6.2.5. Method References6.2.6. Constructor References6.2.7. Variable Scope6.2.8. Lambda Expressions and this6.2.9. Processing Lambda Expressions6.2.10. Creating Comparators6.3. Inner Classes6.3.1. Use of an Inner Class to Access Object State6.3.2. Special Syntax Rules for Inner Classes6.3.3. Are Inner Classes Useful? Actually Necessary? Secure?6.3.4. Local Inner Classes6.3.5. Accessing Variables from Outer Methods6.3.6. Anonymous Inner Classes6.3.7. Static Classes6.3.8. Nested Records6.4. Service Loaders6.5. Proxies6.5.1. When to Use Proxies6.5.2. Creating Proxy Objects6.5.3. Properties of Proxy Classes
7. Exceptions, Assertions, and Logging
7.1. Dealing with Errors7.1.1. The Classification of Exceptions7.1.2. Declaring Checked Exceptions7.1.3. How to Throw an Exception7.1.4. Creating Exception Classes7.2. Catching Exceptions7.2.1. Catching an Exception7.2.2. Catching Multiple Exceptions7.2.3. Rethrowing and Chaining Exceptions7.2.4. The finally Clause7.2.5. The try-with-Resources Statement7.2.6. Analyzing Stack Trace Elements7.3. Tips for Using Exceptions7.4. Using Assertions7.4.1. The Assertion Concept7.4.2. Assertion Enabling and Disabling7.4.3. Using Assertions for Parameter Checking7.4.4. Using Assertions for Documenting Assumptions7.5. Logging7.5.1. Should You Use the Java Logging Framework?7.5.2. Logging 1017.5.3. The Platform Logging API7.5.4. Logging Configuration7.5.5. Log Handlers7.5.6. Filters and Formatters7.5.7. A Logging Recipe7.6. Debugging Tips
8. Generic Programming
8.1. Type Parameters8.1.1. The Advantage of Generic Programming8.1.2. Who Wants to Be a Generic Programmer?8.1.3. Defining a Simple Generic Class8.1.4. Generic Methods8.1.5. Bounds for Type Variables8.1.6. Generic Exceptions8.2. Generic Code and the Virtual Machine8.2.1. Type Erasure8.2.2. Translating Generic Expressions8.2.3. Translating Generic Methods8.2.4. Calling Legacy Code8.3. Inheritance Rules for Generic Types8.4. Wildcard Types8.4.1. The Wildcard Concept8.4.2. Supertype Bounds for Wildcards8.4.3. Unbounded Wildcards8.4.4. Wildcard Capture8.5. Restrictions and Limitations8.5.1. Type Parameters Cannot Be Instantiated with Primitive Types8.5.2. Casts Only Work with Raw Types8.5.3. You Cannot Create Arrays of Parameterized Types 8.5.4. Varargs Warnings8.5.5. Generic Varargs Do Not Spread Primitive Arrays8.5.6. You Cannot Instantiate Type Variables8.5.7. You Cannot Construct a Generic Array8.5.8. Type Variables Are Not Valid in Static Contexts of Generic Classes8.5.9. You Can Defeat Checked Exception Checking8.5.10. Beware of Clashes after Erasure8.5.11. Type Inference in Generic Record Patterns is Limited8.6. Reflection and Generics8.6.1. The Generic Class Class8.6.2. Using Class<T> Parameters for Type Matching8.6.3. Generic Type Information in the Virtual Machine8.6.4. Type Literals

9. Collections
9.1. The Java Collections Framework9.1.1. Separating Collection Interfaces and Implementation9.1.2. The Collection Interface9.1.3. Iterators9.1.4. Generic Utility Methods9.2. Interfaces in the Collections Framework9.3. Concrete Collections9.3.1. Linked Lists9.3.2. Array Lists9.3.3. Hash Sets9.3.4. Tree Sets9.3.5. Queues and Deques9.3.6. Priority Queues9.4. Maps9.4.1. Basic Map Operations9.4.2. Updating Map Entries9.4.3. Map Views9.4.4. Weak Hash Maps9.4.5. Linked Hash Sets and Maps9.4.6. Enumeration Sets and Maps9.4.7. Identity Hash Maps9.5. Copies and Views9.5.1. Small Collections9.5.2. Unmodifiable Copies and Views9.5.3. Subranges9.5.4. Sets From Boolean-Valued Maps9.5.5. Reversed Views9.5.6. Checked Views9.5.7. Synchronized Views9.5.8. A Note on Optional Operations9.6. Algorithms9.6.1. Why Generic Algorithms?9.6.2. Sorting and Shuffling9.6.3. Binary Search9.6.4. Simple Algorithms9.6.5. Bulk Operations9.6.6. Converting between Collections and Arrays9.6.7. Writing Your Own Algorithms9.7. Legacy Collections9.7.1. The Hashtable Class9.7.2. Enumerations9.7.3. Property Maps9.7.4. System Properties9.7.5. Stacks9.7.6. Bit Sets
10. Concurrency
10.1. Running Threads10.2. Thread States10.2.1. New Threads10.2.2. Runnable Threads10.2.3. Blocked and Waiting Threads10.2.4. Terminated Threads10.3. Thread Properties10.3.1. Virtual Threads10.3.2. Thread Interruption10.3.3. Daemon Threads10.3.4. Thread Names and Ids10.3.5. Handlers for Uncaught Exceptions10.3.6. Thread Priorities10.3.7. Thread Factories and Builders10.4. Coordinating Tasks10.4.1. Callables and Futures10.4.2. Executor Services10.4.3. Invoking a Group of Tasks10.4.4. Thread-Local Variables10.4.5. Scoped Values10.4.6. The Fork-Join Framework10.5. Synchronization10.5.1. An Example of a Race Condition10.5.2. The Race Condition Explained10.5.3. Lock Objects10.5.4. Condition Objects10.5.5. Deadlocks10.5.6. The synchronized Keyword10.5.7. Synchronized Blocks10.5.8. The Monitor Concept10.5.9. Volatile Fields10.5.10. Final Fields10.5.11. Atomics10.5.12. On-Demand Initialization10.5.13. Safe Publication10.5.14. Sharing with Thread-Local Variables10.6. Thread-Safe Collections10.6.1. Blocking Queues10.6.2. Efficient Maps, Sets, and Queues10.6.3. Atomic Update of Map Entries10.6.4. Bulk Operations on Concurrent Hash Maps10.6.5. Concurrent Set Views10.6.6. Copy on Write Arrays10.6.7. Parallel Array Algorithms10.6.8. Older Thread-Safe Collections10.7. Asynchronous Computations10.7.1. Completable Futures10.7.2. Composing Completable Futures10.7.3. Long-Running Tasks in User Interface Callbacks10.8. Processes10.8.1. Building a Process10.8.2. Running a Process10.8.3. Process Handles
11. Annotations
11.1. Using Annotations11.1.1. Annotation Elements11.1.2. Multiple and Repeated Annotations11.1.3. Annotating Declarations11.1.4. Annotating Type Uses11.1.5. Receiver Parameters11.2. Defining Annotations11.3. Annotations in the Java API11.3.1. Annotations for Compilation11.3.2. Meta-Annotations11.4. Processing Annotations at Runtime11.5. Source-Level Annotation Processing11.5.1. Annotation Processors11.5.2. The Language Model API11.5.3. Using Annotations to Generate Source Code11.6. Bytecode Engineering11.6.1. Modifying Class Files11.6.2. Modifying Bytecodes at Load Time
12. The Java Platform Module System
12.1. The Module Concept12.2. Naming Modules12.3. The Modular “Hello, World!” Program12.4. Requiring Modules12.5. Exporting Packages12.6. Modular JARs12.7. Modules and Reflective Access12.8. Automatic Modules12.9. The Unnamed Module12.10. Command-Line Flags for Migration12.11. Transitive and Static Requirements12.12. Importing Modules12.13. Qualified Exporting and Opening12.14. Service Loading12.15. Tools for Working with Modules
Appendix
Index

Content preview from Core Java, Vol. I: Fundamentals, 14th Edition

Chapter 8 ▪ Generic Programming

Generic classes and methods have type parameters. This allows them to describe precisely how the types should be used in the implementation. Prior to generic classes, programmers had to use the Object class for writing code that works with multiple types. This was both cumbersome and unsafe.

With the introduction of generics, Java has an expressive type system that allows designers to describe in detail how types of variables and methods should vary. In straightforward situations, you will find it simple to implement generic code. In more advanced cases, it can get quite complex—for implementors. The goal is to provide classes and methods that other programmers can use without surprises.

The introduction of generics ...

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

Core Java, Volume I: Fundamentals, 13th Edition

Publisher Resources

ISBN: 9780135558553

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Core Java, Vol. I: Fundamentals, 14th Edition

by Cay S. Horstmann

Chapter 8 ▪ Generic Programming

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.