Java in a Nutshell, 7th Edition by Flanagan, David -- Read -- Imperial Library of Trantor

Index

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

← Prev
Back
Next →

← Prev
Back
Next →