Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20
,

Java in a Nutshell

A Desktop Quick Reference (Covers Java 11)

Paperback Engels 2018 9781492037255
Verkooppositie 2517Hoogste positie: 2517
Verwachte levertijd ongeveer 8 werkdagen

Samenvatting

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 practices, this thoroughly revised book includes new material on Java Concurrency Utilities.

The book’s first section provides a fast-paced, no-fluff introduction to the Java programming language and the core runtime aspects of the Java platform. The second section is a reference to core concepts and APIs that explains how to perform real programming work in the Java environment.

- Get up to speed on language details, including Java 9-11 changes
- Learn object-oriented programming, using basic Java syntax
- Explore generics, enumerations, annotations, and lambda expressions
- Understand basic techniques used in object-oriented design
- Examine concurrency and memory, and how they’re intertwined
- Work with Java collections and handle common data formats
- Delve into Java’s latest I/O APIs, including asynchronous channels
- Use Nashorn to execute JavaScript on the Java Virtual Machine
- Become familiar with development tools in OpenJDK

Specificaties

ISBN13:9781492037255
Taal:Engels
Bindwijze:paperback
Aantal pagina's:456
Uitgever:O'Reilly
Druk:7
Hoofdrubriek:IT-management / ICT

Verschijningsdata

De verschijningsfrequentie en verschijningsdata zijn nog niet bekend

Lezersrecensies

Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht

Over David Flanagan

David Flanagan is a computer programmer who spends most of his time writing about JavaScript and Java. His books with O'Reilly include Java in a Nutshell, Java Examples in a Nutshell, Java Foundation Classes in a Nutshell, JavaScript: The Definitive Guide, and JavaScript Pocket Reference. David has a degree in computer science and engineering from the Massachusetts Institute of Technology. He lives with his wife and children in the U.S. Pacific Northwest bewteen the cities of Seattle, Washington and Vancouver, British Columbia. David has a blog at www.davidflanagan.com.

Andere boeken door David Flanagan

Inhoudsopgave

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

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?
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

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

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

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

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

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

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
Doc-Comment Tags
Inline Doc-Comment Tags
Cross-References in Doc Comments
Doc Comments for Packages
Doclets
Conventions for Portable Programs

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

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

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

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

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

13. Platform Tools
Command-Line Tools
Introduction to JShell
Summary
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

Managementboek Top 100

Rubrieken

Populaire producten

    Personen

      Trefwoorden

        Java in a Nutshell