Java in a nutshell
This updated edition of Java in a Nutshell not only helps experienced Java programmers get the most out of Java versions 9 through 11, it’s also a learning path for new developers. Chock full of examples that demonstrate how to take complete advantage of modern Java APIs and development best practic...
Otros Autores: | , |
---|---|
Formato: | Libro electrónico |
Idioma: | Inglés |
Publicado: |
Sebastpol, California :
O'Reilly
[2019]
|
Edición: | Seventh edition |
Materias: | |
Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630531806719 |
Tabla de Contenidos:
- Cover
- Copyright
- Table of Contents
- Foreword
- Preface
- Changes in the Seventh Edition
- Contents of This Book
- Related Books
- Examples Online
- Conventions Used in This Book
- Request for Comments
- O'Reilly Safari
- Acknowledgments
- Part I. Introducing Java
- Chapter 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?
- A Brief History of Java and the JVM
- The Lifecycle of a Java Program
- Frequently Asked Questions
- Java Security
- Comparing Java to Other Languages
- Java Compared to C
- Java Compared to C++
- Java Compared to Python
- Java Compared to JavaScript
- Answering Some Criticisms of Java
- Overly Verbose
- Slow to Change
- Performance Problems
- Insecure
- Too Corporate
- Chapter 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 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
- Chapter 3. Object-Oriented Programming in Java
- Overview of Classes
- Basic OO Definitions
- 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
- 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
- Data Hiding and Encapsulation
- Access Control
- Data Accessor Methods
- Abstract Classes and Methods
- Reference Type Conversions
- Modifier Summary
- Chapter 4. The Java Type System
- Interfaces
- Defining an Interface
- Extending Interfaces.
- Implementing an Interface
- 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
- Non-Denotable Types and var
- Summary
- Chapter 5. Introduction to Object-Oriented Design in Java
- Java Values
- Important Methods of java.lang.Object
- toString()
- equals()
- hashCode()
- Comparable::compareTo()
- clone()
- Aspects of Object-Oriented Design
- Constants
- Interfaces Versus Abstract Classes
- Can Default Methods Be Used as Traits?
- Instance Methods or Class Methods?
- Composition Versus Inheritance
- Field Inheritance and Accessors
- Singleton
- Object-Oriented Design with Lambdas
- Lambdas Versus Nested Classes
- Lambdas Versus Method References
- Exceptions and Exception Handling
- Safe Java Programming
- Chapter 6. Java's Approach to Memory and Concurrency
- Basic Concepts of Java Memory Management
- Memory Leaks in Java
- Introducing Mark-and-Sweep
- The Basic Mark-and-Sweep Algorithm
- How the JVM Optimizes Garbage Collection
- Evacuation
- The HotSpot Heap
- Other Collectors
- ParallelOld
- 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
- Part II. Working with the Java Platform
- Chapter 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
- Chapter 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
- Chapter 9. Handling Common Data Formats
- Text
- Special Syntax for Strings
- String Immutability
- Regular Expressions
- Numbers and Math
- How Java Represents Integer Types
- Java and Floating-Point Numbers
- Java's Standard Library of Mathematical Functions
- Java 8 Date and Time
- Introducing the Java 8 Date and Time API
- Queries
- Adjusters
- Legacy Date and Time
- Summary
- Chapter 10. File Handling and I/O
- Classic Java I/O
- Files
- 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
- Chapter 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
- Chapter 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
- 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
- Chapter 13. Platform Tools
- Command-Line Tools
- Introduction to JShell
- Summary
- Appendix A. Additional Tools
- Introduction to Nashorn
- Non-Java Languages on the JVM
- Motivation
- Executing JavaScript with Nashorn
- Running from the Command Line
- Using the Nashorn Shell
- Nashorn and javax.script
- Introducing javax.script with Nashorn
- Advanced Nashorn
- Calling Java from Nashorn
- Nashorn's JavaScript Language Extensions
- Under the Hood
- The Future of Nashorn and GraalVM
- VisualVM
- Index.