Java in a Nutshell. A Desktop Quick Reference. 9th Edition Benjamin J. Evans, Jason R. Clark, David Flanagan

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

• Foreword
• Preface
  • Changes in the Ninth Edition
  • Contents of This Book
  • Related Books
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly 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
      • What is a virtual machine?
      • What is bytecode?
      • Is javac a compiler?
      • Why is it called bytecode?
      • Is bytecode optimized?
      • Is bytecode really machine independent? What about things like endianness?
      • Is Java an interpreted language?
      • Can other languages run on the JVM?
  • Comparing Java to Other Languages
    • Java Compared to Python
    • Java Compared to JavaScript
    • 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
  • Javas Release Model
  • 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
      • String literals
    • Integer Types
    • Floating-Point Types
    • Primitive Type Conversions
  • Expressions and Operators
    • Operator Summary
      • Precedence
      • Associativity
      • Operator summary table
      • Operand number and type
      • Return type
      • Side effects
      • Order of evaluation
    • 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
    • Pattern Matching and Type Patterns
    • Special Operators
  • Statements
    • Expression Statements
    • Compound Statements
    • The Empty Statement
    • Labeled Statements
    • Local Variable Declaration Statements
    • The if/else Statement
      • The else if clause
    • The switch Statement
    • The switch Expression
    • The while Statement
    • The do Statement
    • The for Statement
    • The foreach Variant
      • What foreach cannot do
    • The break Statement
    • The continue Statement
    • The return Statement
    • The synchronized Statement
    • The throw Statement
    • The try/catch/finally Statement
      • try
      • catch
      • finally
    • The try-with-resources Statement
    • The assert Statement
      • Enabling assertions
  • Methods
    • Defining Methods
    • Method Modifiers
    • Checked and Unchecked Exceptions
      • Working with checked exceptions
    • Variable-Length Argument Lists
  • Introduction to Classes and Objects
    • Defining a Class
    • Creating an Object
    • Using an Object
    • Object Literals
      • String literals
      • Type literals
      • The null reference
    • Lambda Expressions
  • Arrays
    • Array Types
      • Array type widening conversions
    • Creating and Initializing Arrays
      • Array initializers
    • Using Arrays
      • Accessing array elements
      • Array bounds
      • Iterating arrays
      • Copying arrays
      • Array utilities
    • 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
      • Naming conflicts and shadowing
    • Importing Static Members
      • Static member imports and overloaded methods
  • Summary
• 3. Your First Java Programs
  • Introduction to JShell
  • Simple Standalone Java Programs
  • Java Source File Structure
  • The Source Code Compiler
  • Executing Full Java Programs
  • Summary
• 4. Object-Oriented Programming in Java
  • Overview of Classes and Records
    • Basic OO Definitions
    • Records
    • Interfaces
    • 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
    • The Default Constructor
    • Hiding Superclass Fields
    • Overriding Superclass Methods
      • Overriding is not hiding
      • Virtual method lookup
      • Invoking an overridden method
    • Sealed Classes
  • Data Hiding and Encapsulation
    • Access Control
      • Access to modules
      • Access to packages
      • Access to classes
      • Access to members
      • Access control and inheritance
      • Member access summary
    • Data Accessor Methods
  • Abstract Classes and Methods
  • Reference Type Conversions
  • Modifier Summary
  • Summary
• 5. The Java Type System
  • Interfaces
    • Defining an Interface
    • Extending Interfaces
    • Implementing an Interface
    • Records and Interfaces
    • Sealed Interfaces
    • Default Methods
      • Backward compatibility
      • Implementation of default methods
    • Marker Interfaces
  • Java Generics
    • Introduction to Generics
    • Generic Types and Type Parameters
    • Diamond Syntax
    • Type Erasure
    • Bounded Type Parameters
    • Introducing Covariance
    • Wildcards
      • Bounded wildcards
    • Generic Methods
    • Compile and Runtime Typing
    • Using and Designing Generic Types
  • Enums and Annotations
    • Enums
    • Annotations
  • Lambda Expressions
    • Lambda Expression Conversion
    • Method References
    • Lambdas and Functional Programming
    • Lexical Scoping and Local Variables
  • Nested Types
    • Static Member Types
      • Features of static member types
    • Nonstatic Member Classes
      • Features of member classes
      • Syntax for member classes
    • Local Classes
      • Features of local classes
      • Scope of a local class
    • Anonymous Classes
  • Describing the Java Type System
    • Type Inference
    • Nominal Typing
    • An Aside: Nondenotable Types
  • Summary
• 6. Introduction to Object-Oriented Design in Java
  • Java Values
    • Is Java Pass-by-Reference?
    • Constants
  • Important Common Methods
    • toString()
    • equals()
    • hashCode()
    • Comparable::compareTo()
    • clone()
  • Working with Fields and Object State
    • Field Inheritance
    • Accessors
    • Mutability and Immutability
  • Construction Patterns
    • Factory Methods
    • Builders
    • Constructor Prologues
    • Singleton
  • Instance Methods or Class Methods?
  • Exceptions and Exception Handling
  • Interfaces Versus Abstract Classes
    • Partial Implementations
    • Do Default Methods Change Javas Inheritance Model?
    • Delegation
  • Modern OOD in Java
    • OOD Using Lambdas
      • Lambdas versus nested classes
      • Lambdas versus method references
    • OOD Using Records
    • OOD Using Sealed Types
    • Pattern Matching
  • Safe Java Programming
  • Case Study: Circle-Ellipse Problem
  • 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
    • Formatting Multiline Doc Comments
    • Formatting Markdown Doc Comments
    • 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
    • Creating Collections
    • The Collection Interface
    • The List Interface
      • Iteration with foreach loops
      • Random access to lists
    • The Map Interface
    • The Set Interface
      • The Iterable and Iterator interfaces
    • Mutability and Immutability Revisited
  • Java Streams and Lambda Expressions
    • The Streams API
    • Functional Approaches
      • Filter
      • Map
      • forEach
      • Reduce
      • Stream gatherers
      • Lazy evaluation
      • Further filtering
      • Matching in streams
      • Flattening
      • Parallel streams
      • From streams to Collections
      • From streams to values
      • Streams utility default methods
    • Utility Methods
      • Special-case collections
    • Arrays and Helper Methods
  • Summary
• 9. Java and Memory
  • Basic Concepts of Automatic Memory Management
    • Introducing Mark-and-Sweep
    • Exactness and Limitations of Naive Mark-and-Sweep
  • Improving on Basic Garbage Collection
    • The Weak Generational Hypothesis
    • Evacuation
    • The HotSpot Heap
  • G1
  • Alternate Collectors
    • ParallelOld
    • Serial
    • Shenandoah
    • ZGC
  • Summary
• 10. Handling Common Data Formats
  • Text
    • Special Syntax for Strings
      • String literals
      • toString()
      • String concatenation
    • String Immutability
      • Hash codes and effective immutability
    • String Formatting
    • Regular Expressions
  • Numbers and Math
    • How Java Represents Integer Types
    • Java and Floating-Point Numbers
      • BigDecimal
    • Javas Standard Library of Mathematical Functions
  • Date and Time
    • Introducing the Java 8 Date and Time API
      • The parts of a timestamp
      • Example
    • Queries
    • Adjusters
    • Time Zones
    • Legacy Date and Time
  • Summary
• 11. File Handling and I/O
  • Path
  • Files
  • FileSystem
  • I/O Streams
  • Readers and Writers
  • Decorators
  • try-with-resources Revisited
  • Classic Java I/O
  • 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
• 12. Concurrency in Java
  • Basic Concepts of Java Concurrency
    • Thread Lifecycle
    • Visibility and Mutability
    • Concurrent Safety
    • Protecting State with Exclusion
    • Volatile State
  • Working with Threads
    • Useful Methods of Thread
      • getId()
      • getPriority() and setPriority()
      • setName() and getName()
      • getState()
      • isAlive()
      • start()
      • interrupt()
      • join()
      • setDaemon()
      • setUncaughtExceptionHandler()
    • Dangerous Methods of Thread
      • stop()
      • suspend(), resume(), countStackFrames(), and destroy()
    • Indefinite Waiting
    • Synchronization Checklist
  • Concurrent Data Structures
    • Atomic Counters
    • Concurrent Maps
    • Queues and BlockingQueues
  • Executors and Threadpools
  • Virtual Threads
  • Summary
• 13. 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
      • Bootstrap classloader
      • Platform classloader
      • Application classloader
      • Custom classloader
  • Reflection
    • When to Use Reflection
    • How to Use Reflection
      • Method objects
      • Creating instances with Reflection
      • Problems with Reflection
  • Method Handles
    • MethodType
    • Method Lookup
    • Invoking Method Handles
  • Summary
• 14. Java Platform Modules
  • Why Modules?
    • Modularizing the JDK
    • The Java SE Module Graph
    • Module Imports
  • Writing Your Own Modules
    • Basic Modules Syntax
    • Building a Simple Modular Application
    • The Module Path
    • Automatic Modules
    • Open Modules
    • Providing Services
  • Migrating to Modules
    • Multi-Release JARs
    • Converting to a Multi-Release JAR
    • Custom Runtime Images
  • Issues with Modules
    • Lack of Versioning
    • The Unsafe Class
    • Adoption Rates
  • Summary
• A. Future Java
  • Long-Term JDK Projects
  • Panama
  • Valhalla
  • Leyden and Cloud Native Java
  • Integrity By Default
• B. Platform Tools
  • Command-Line Tools
  • Introduction to Java Flight Recorder (JFR)
• Index

pokaż cały spis treści

ukryj recenzje