Core Java, Volume I: Fundamentals, 13th Edition (Early Release June, 2024)

✍ Scribed by Cay S. Horstmann

• Publisher: Addison-Wesley Professional
• Year: 2024
• Tongue: English
• Leaves: 755
• Edition: 13
• Category: Library

✦ Synopsis

The Classic Guide to the Java Programming Language--Fully Updated through Java 21
Whatever version of Java you are using, Core Java, Volume I: Fundamentals, Thirteenth Edition, will help you achieve a deep and practical understanding of the language and APIs. With hundreds of realistic examples, Java Champion Cay S. Horstmann demonstrates the most powerful and effective ways to get the job done.
Written for experienced programmers looking for in-depth coverage of the Java language and platform, this revised and updated edition continues to be the first choice for serious programmers. The carefully crafted sample programs demonstrate almost every language and library feature, as well as the newest capabilities introduced in Java 21. The examples are purposefully simple to focus on the major points, but, for the most part, they aren't fake and they don't cut corners. They should make good starting points for your own code.
This first of two volumes offers a detailed treatment of fundamental Java programming topics, including object-oriented programming, reflection and proxies, interfaces and inner classes, exception handling, generics, collections, lambda expressions, concurrency, annotations, and the Java platform module system.
Master foundational techniques, idioms, and best practices for writing superior Java code
Leverage the power of interfaces, lambda expressions, and inner classes
Take advantage of sealed class hierarchies and pattern matching for processing structured data
Harden programs through effective exception handling and debugging
Write safer, more reusable code with generic programming
Improve performance and efficiency with Java's standard collections
Explore simple programs with JShell and assemble complex programs with archives and modules
Fully utilize multicore processors with Java's powerful concurrency model

✦ Table of Contents

Table of Contents

About This eBook
Preface
    To the Reader
    A Tour of This Book
    Conventions
    Sample Code
Acknowledgments
1. An Introduction to Java
    1.1. Java as a Programming Platform
    1.2. The Java “White Paper” Buzzwords
    1.3. Java Applets and the Internet
    1.4. A Short History of Java
    1.5. Common Misconceptions about Java
2. The Java Programming Environment
    2.1. Installing the Java Development Kit
    2.2. Using the Command-Line Tools
    2.3. Using an Integrated Development Environment
    2.4. JShell
3. Fundamental Programming Structures in Java
    3.1. A Simple Java Program
    3.2. Comments
    3.3. Data Types
    3.4. Variables and Constants
    3.5. Operators
    3.6. Strings
    3.7. Input and Output
    3.8. Control Flow
    3.9. Big Numbers
    3.10. Arrays
4. Objects and Classes
    4.1. Introduction to Object-Oriented Programming
    4.2. Using Predefined Classes
    4.3. Defining Your Own Classes
    4.4. Static Fields and Methods
    4.5. Method Parameters
    4.6. Object Construction
    4.7. Records
    4.8. Packages
    4.9. JAR Files
    4.10. Documentation Comments
    4.11. Class Design Hints
5. Inheritance
    5.1. Classes, Superclasses, and Subclasses
    5.2. Object: The Cosmic Superclass
    5.3. Generic Array Lists
    5.4. Object Wrappers and Autoboxing
    5.5. Methods with a Variable Number of Arguments
    5.6. Abstract Classes
    5.7. Enumeration Classes
    5.8. Sealed Classes
    5.9. Pattern Matching
    5.10. Reflection
    5.11. Design Hints for Inheritance
6. Interfaces, Lambda Expressions, and Inner Classes
    6.1. Interfaces
    6.2. Lambda Expressions
    6.3. Inner Classes
    6.4. Service Loaders
    6.5. Proxies
7. Exceptions, Assertions, and Logging
    7.1. Dealing with Errors
    7.2. Catching Exceptions
    7.3. Tips for Using Exceptions
    7.4. Using Assertions
    7.5. Logging
    7.6. Debugging Tips
8. Generic Programming
    8.1. Why Generic Programming?
    8.2. Defining a Simple Generic Class
    8.3. Generic Methods
    8.4. Bounds for Type Variables
    8.5. Generic Code and the Virtual Machine
    8.6. Inheritance Rules for Generic Types
    8.7. Wildcard Types
    8.8. Restrictions and Limitations
    8.9. Reflection and Generics
9. Collections
    9.1. The Java Collections Framework
    9.2. Interfaces in the Collections Framework
    9.3. Concrete Collections
    9.4. Maps
    9.5. Copies and Views
    9.6. Algorithms
    9.7. Legacy Collections
10. Concurrency
    10.1. Running Threads
    10.2. Thread States
    10.3. Thread Properties
    10.4. Coordinating Tasks
    10.5. Synchronization
    10.6. Thread-Safe Collections
    10.7. Asynchronous Computations
    10.8. Processes
11. Annotations
    11.1. Using Annotations
    11.2. Defining Annotations
    11.3. Annotations in the Java API
    11.4. Processing Annotations at Runtime
    11.5. Source-Level Annotation Processing
    11.6. Bytecode Engineering
12. The Java Platform Module System
    12.1. The Module Concept
    12.2. Naming Modules
    12.3. The Modular “Hello, World!” Program
    12.4. Requiring Modules
    12.5. Exporting Packages
    12.6. Modular JARs
    12.7. Modules and Reflective Access
    12.8. Automatic Modules
    12.9. The Unnamed Module
    12.10. Command-Line Flags for Migration
    12.11. Transitive and Static Requirements
    12.12. Qualified Exporting and Opening
    12.13. Service Loading
    12.14. Tools for Working with Modules
Appendix