Java: The Complete Reference 13th Edition PDF by Herbert Schildt and Dr. Danny Coward

By

Java: The Complete Reference, 13th Edition

Herbert Schildt and Dr. Danny Coward

Java The Complete Reference

Contents

Foreword

Preface

Part I The Java Language

Chapter 1 The History and Evolution of Java

Java’s Lineage

The Birth of Modern Programming: C

C++: The Next Step

The Stage Is Set for Java

The Creation of Java

The C# Connection

Longevity

How Java Impacted the Internet

Java Applets

Security

Portability

Java’s Magic: The Bytecode

Moving Beyond Applets

A Faster Release Schedule

Servlets: Java on the Server Side

The Java Buzzwords

Simple

Object-Oriented

Robust

Multithreaded

Architecture-Neutral

Interpreted and High Performance

Distributed

Dynamic

The Evolution of Java

A Culture of Innovation

Chapter 2 An Overview of Java

Object-Oriented Programming

Two Paradigms

Abstraction

The Three OOP Principles

A First Simple Program

Entering the Program

Compiling the Program

A Closer Look at the First Sample Program

A Second Short Program

Two Control Statements

The if Statement

The for Loop

Using Blocks of Code

Lexical Issues

Whitespace

Identifiers

Literals

Comments

Separators

The Java Keywords

The Java Class Libraries

Chapter 3 Data Types, Variables, and Arrays

Java Is a Strongly Typed Language

The Primitive Types

Integers

byte

short

int

long

Floating-Point Types

float

double

Characters

Booleans

A Closer Look at Literals

Integer Literals

Floating-Point Literals

Boolean Literals

Character Literals

String Literals

Variables

Declaring a Variable

Dynamic Initialization

The Scope and Lifetime of Variables

Type Conversion and Casting

Java’s Automatic Conversions

Casting Incompatible Types

Automatic Type Promotion in Expressions

The Type Promotion Rules

Arrays

One-Dimensional Arrays

Multidimensional Arrays

Alternative Array Declaration Syntax

Introducing Type Inference with Local Variables

Some var Restrictions

A Few Words About Strings

Chapter 4 Operators

Arithmetic Operators

The Basic Arithmetic Operators

The Modulus Operator

Arithmetic Compound Assignment Operators

Increment and Decrement

The Bitwise Operators

The Bitwise Logical Operators

The Left Shift

The Right Shift

The Unsigned Right Shift

Bitwise Operator Compound Assignments

Relational Operators

Boolean Logical Operators

Short-Circuit Logical Operators

The Assignment Operator

The ? Operator

Operator Precedence

Using Parentheses

Chapter 5 Control Statements

Java’s Selection Statements

The Traditional switch

Iteration Statements

while

do-while

for

The For-Each Version of the for Loop

Local Variable Type Inference in a for Loop

Nested Loops

Jump Statements

Using break

Using continue

return

Chapter 6 Introducing Classes

Class Fundamentals

The General Form of a Class

A Simple Class

Declaring Objects

A Closer Look at new

Assigning Object Reference Variables

Introducing Methods

Adding a Method to the Box Class

Returning a Value

Adding a Method That Takes Parameters

Constructors

Parameterized Constructors

The this Keyword

Instance Variable Hiding

Garbage Collection

A Stack Class

Chapter 7 A Closer Look at Methods and Classes

Overloading Methods

Overloading Constructors

Using Objects as Parameters

A Closer Look at Argument Passing

Returning Objects

Recursion

Introducing Access Control

Understanding static

Introducing final

Arrays Revisited

Introducing Nested and Inner Classes

Exploring the String Class

Using Command-Line Arguments

Varargs: Variable-Length Arguments

Overloading Vararg Methods

Varargs and Ambiguity

Local Variable Type Inference with Reference Types

Chapter 8 Inheritance

Inheritance Basics

Member Access and Inheritance

A More Practical Example

A Superclass Variable Can Reference a Subclass Object

Using super

Using super to Call Superclass Constructors

A Second Use for super

Creating a Multilevel Hierarchy

When Constructors Are Executed

Method Overriding

Dynamic Method Dispatch

Why Overridden Methods?

Applying Method Overriding

Using Abstract Classes

Using final with Inheritance

Using final to Prevent Overriding

Using final to Prevent Inheritance

Local Variable Type Inference and Inheritance

The Object Class

Chapter 9 Packages and Interfaces

Packages

Defining a Package

Finding Packages and CLASSPATH

A Short Package Example

Packages and Member Access

An Access Example

Importing Packages

Interfaces

Defining an Interface

Implementing Interfaces

Nested Interfaces

Applying Interfaces

Variables in Interfaces

Interfaces Can Be Extended

Default Interface Methods

Default Method Fundamentals

A More Practical Example

Multiple Inheritance Issues

Use static Methods in an Interface

Private Interface Methods

Final Thoughts on Packages and Interfaces

Chapter 10 Exception Handling

Exception-Handling Fundamentals

Exception Types

Uncaught Exceptions

Using try and catch

Displaying a Description of an Exception

Multiple catch Clauses

Nested try Statements

throw

throws

finally

Java’s Built-in Exceptions

Creating Your Own Exception Subclasses

Chained Exceptions

Three Additional Exception Features

Using Exceptions

Chapter 11 Multithreaded Programming

The Java Thread Model

Thread Priorities

Synchronization

Messaging

The Thread Class and the Runnable Interface

The Main Thread

Creating a Thread

Implementing Runnable

Extending Thread

Choosing an Approach

Creating Multiple Threads

Using isAlive( ) and join( )

Thread Priorities

Synchronization

Using Synchronized Methods

The synchronized Statement

Interthread Communication

Deadlock

Suspending, Resuming, and Stopping Threads

Obtaining a Thread’s State

Using a Factory Method to Create and Start a Thread

Virtual Threads

Using Multithreading

Chapter 12 Enumerations, Autoboxing, and Annotations

Enumerations

Enumeration Fundamentals

The values( ) and valueOf( ) Methods

Java Enumerations Are Class Types

Enumerations Inherit Enum

Another Enumeration Example

Type Wrappers

Character

Boolean

The Numeric Type Wrappers

Autoboxing

Autoboxing and Methods

Autoboxing/Unboxing Occurs in Expressions

Autoboxing/Unboxing Boolean and Character Values

Autoboxing/Unboxing Helps Prevent Errors

A Word of Warning

Annotations

Annotation Basics

Specifying a Retention Policy

Obtaining Annotations at Run Time by Use of

Reflection

The AnnotatedElement Interface

Using Default Values

Marker Annotations

Single-Member Annotations

The Built-In Annotations

Type Annotations

Repeating Annotations

Some Restrictions

Chapter 13 I/O, Try-with-Resources, and Other Topics

I/O Basics

Streams

Byte Streams and Character Streams

The Predefined Streams

Reading Console Input

Reading Characters

Reading Strings

Writing Console Output

The PrintWriter Class

Reading and Writing Files

Automatically Closing a File

The transient and volatile Modifiers

Introducing instance of strictfp

Native Methods

Using assert

Assertion Enabling and Disabling Options

Static Import

Invoking Overloaded Constructors Through this( )

A Word About Value-Based Classes

Chapter 14 Generics

What Are Generics?

A Simple Generics Example

Generics Work Only with Reference Types

Generic Types Differ Based on Their Type Arguments

How Generics Improve Type Safety

A Generic Class with Two Type Parameters

The General Form of a Generic Class

Bounded Types

Using Wildcard Arguments

Bounded Wildcards

Creating a Generic Method

Generic Constructors

Generic Interfaces

Raw Types and Legacy Code

Generic Class Hierarchies

Using a Generic Superclass

A Generic Subclass

Run-Time Type Comparisons Within a Generic

Hierarchy

Casting

Overriding Methods in a Generic Class

Type Inference with Generics

Local Variable Type Inference and Generics

Erasure

Bridge Methods

Ambiguity Errors

Some Generic Restrictions

Type Parameters Can’t Be Instantiated

Restrictions on Static Members

Generic Array Restrictions

Generic Exception Restriction

Chapter 15 Lambda Expressions

Introducing Lambda Expressions

Lambda Expression Fundamentals

Functional Interfaces

Some Lambda Expression Examples

Block Lambda Expressions

Generic Functional Interfaces

Passing Lambda Expressions as Arguments

Lambda Expressions and Exceptions

Lambda Expressions and Variable Capture

Method References

Method References to static Methods

Method References to Instance Methods

Method References with Generics

Constructor References

Predefined Functional Interfaces

Chapter 16 Modules

Module Basics

A Simple Module Example

Compile and Run the First Module Example

A Closer Look at requires and exports

java.base and the Platform Modules

Legacy Code and the Unnamed Module

Exporting to a Specific Module

Using requires transitive

Use Services

Service and Service Provider Basics

The Service-Based Keywords

A Module-Based Service Example

Module Graphs

Three Specialized Module Features

Open Modules

The opens Statement

requires static

Introducing jlink and Module JAR Files

Linking Files in an Exploded Directory

Linking Modular JAR Files

JMOD Files

A Brief Word About Layers and Automatic Modules

Final Thoughts on Modules

Chapter 17 Switch Expressions, Records, and Other Recently Added

Features

Records

Record Basics

Create Record Constructors

Another Record Constructor Example

Create Record Getter Methods

Pattern Matching with instanceof

Pattern Variables in a Logical AND Expression

Pattern Matching in Other Statements

Enhancements to switch

Use a List of case Constants

Introducing the switch Expression and the yield

Statement

Introducing the Arrow in a case Statement

A Closer Look at the Arrow case

Another switch Expression Example

Pattern Matching in switch

Text Blocks

Text Block Fundamentals

Understanding Leading Whitespace

Use Double Quotes in a Text Block

Escape Sequences in Text Blocks

Pattern Matching with Records

Sealed Classes and Interfaces

Sealed Classes

Sealed Interfaces

Future Directions

Part II The Java Library

Chapter 18 String Handling

The String Constructors

String Length

Special String Operations

String Literals

String Concatenation

String Concatenation with Other Data Types

String Conversion and toString( )

Character Extraction

charAt( )

getChars( )

getBytes( )

toCharArray( )

String Comparison

equals( ) and equalsIgnoreCase( )

regionMatches( )

startsWith( ) and endsWith( )

equals( ) Versus ==

compareTo( )

Searching Strings

Modifying a String

substring( )

concat( )

replace( )

trim( ) and strip( )

Data Conversion Using valueOf( )

Changing the Case of Characters Within a String

Joining Strings

Additional String Methods

StringBuffer

StringBuffer Constructors

length( ) and capacity( )

ensureCapacity( )

setLength( )

charAt( ) and setCharAt( )

getChars( )

append( )

insert( )

reverse( )

delete( ) and deleteCharAt( )

replace( )

substring( )

Additional StringBuffer Methods

StringBuilder

Chapter 19 Exploring java.lang

Primitive Type Wrappers

Number

Double and Float

Understanding isInfinite( ) and isNaN( )

Byte, Short, Integer, and Long

Character

Additions to Character for Unicode Code Point Support

Boolean

Void

Process

Runtime

Executing Other Programs

Runtime.Version

ProcessBuilder

System

Using currentTimeMillis( ) to Time Program Execution

Using arraycopy( )

Environment Properties

System.Logger and System.LoggerFinder

Object

Using clone( ) and the Cloneable Interface

Class

ClassLoader

Math

Trigonometric Functions

Exponential Functions

Rounding Functions

Miscellaneous Math Methods

StrictMath

Compiler

Thread, ThreadGroup, and Runnable

The Runnable Interface

Thread

ThreadGroup

ThreadLocal and InheritableThreadLocal

Package

Module

ModuleLayer

RuntimePermission

Throwable

SecurityManager

StackTraceElement

StackWalker and StackWalker.StackFrame

Enum

Record

ClassValue

The CharSequence Interface

The Comparable Interface

The Appendable Interface

The Iterable Interface

The Readable Interface

The AutoCloseable Interface

The Thread.UncaughtExceptionHandler Interface

The java.lang Subpackages

java.lang.annotation

java.lang.constant

java.lang.instrument

java.lang.invoke

java.lang.management

java.lang.module

java.lang.ref

java.lang.reflect

Chapter 20 java.util Part 1: The Collections Framework

Collections Overview

The Collection Interfaces

The Collection Interface

The SequencedCollection Interface

The List Interface

The Set Interface

The SequencedSet Interface

The SortedSet Interface

The NavigableSet Interface

The Queue Interface

The Deque Interface

The Collection Classes

The ArrayList Class

The LinkedList Class

The HashSet Class

The LinkedHashSet Class

The TreeSet Class

The PriorityQueue Class

The ArrayDeque Class

The EnumSet Class

Accessing a Collection via an Iterator

Using an Iterator

The For-Each Alternative to Iterators

Spliterators

Storing User-Defined Classes in Collections

The RandomAccess Interface

Working with Maps

The Map Interfaces

The Map Classes

Comparators

Using a Comparator

The Collection Algorithms

Arrays

The Legacy Classes and Interfaces

The Enumeration Interface

Vector

Stack

Dictionary

Hashtable

Properties

Using store( ) and load( )

Parting Thoughts on Collections

Chapter 21 java.util Part 2: More Utility Classes

StringTokenizer

BitSet

Optional, OptionalDouble, OptionalInt, and OptionalLong

Date

Calendar

GregorianCalendar

TimeZone

SimpleTimeZone

Locale

Random

Timer and TimerTask

Currency

Formatter

The Formatter Constructors

The Formatter Methods

Formatting Basics

Formatting Strings and Characters

Formatting Numbers

Formatting Time and Date

The %n and %% Specifiers

Specifying a Minimum Field Width

Specifying Precision

Using the Format Flags

Justifying Output

The Space, +, 0, and ( Flags

The Comma Flag

The # Flag

The Uppercase Option

Using an Argument Index

Closing a Formatter

The Java printf( ) Connection

Scanner

The Scanner Constructors

Scanning Basics

Some Scanner Examples

Setting Delimiters

Other Scanner Features

The ResourceBundle, ListResourceBundle, and

PropertyResourceBundle Classes

Miscellaneous Utility Classes and Interfaces

The java.util Subpackages

java.util.concurrent, java.util.concurrent.atomic, and

java.util.concurrent.locks

java.util.function

java.util.jar

java.util.logging

java.util.prefs

java.util.random

java.util.regex

java.util.spi

java.util.stream

java.util.zip

Chapter 22 Input/Output: Exploring java.io

The I/O Classes and Interfaces

File

Directories

Using FilenameFilter

The listFiles( ) Alternative

Creating Directories

The AutoCloseable, Closeable, and Flushable Interfaces

I/O Exceptions

Two Ways to Close a Stream

The Stream Classes

The Byte Streams

InputStream

OutputStream

FileInputStream

FileOutputStream

ByteArrayInputStream

ByteArrayOutputStream

Filtered Byte Streams

Buffered Byte Streams

SequenceInputStream

PrintStream

DataOutputStream and DataInputStream

RandomAccessFile

The Character Streams

Reader

Writer

FileReader

FileWriter

CharArrayReader

CharArrayWriter

BufferedReader

BufferedWriter

PushbackReader

PrintWriter

The Console Class

Serialization

Serializable

Externalizable

ObjectOutput

ObjectOutputStream

ObjectInput

ObjectInputStream

A Serialization Example

Stream Benefits

Chapter 23 Exploring NIO

The NIO Classes

NIO Fundamentals

Buffers

Channels

Charsets and Selectors

Enhancements Added by NIO.2

The Path Interface

The Files Class

The Paths Class

The File Attribute Interfaces

The FileSystem, FileSystems, and FileStore Classes

Using the NIO System

Use NIO for Channel-Based I/O

Use NIO for Stream-Based I/O

Use NIO for Path and File System Operations

Chapter 24 Networking

Networking Basics

The java.net Networking Classes and Interfaces

InetAddress

Factory Methods

Instance Methods

Inet4Address and Inet6Address

TCP/IP Client Sockets

URL

URLConnection

HttpURLConnection

The URI Class

Cookies

TCP/IP Server Sockets

Datagrams

DatagramSocket

DatagramPacket

A Datagram Example

Introducing java.net.http

Three Key Elements

A Simple HTTP Client Example

Things to Explore in java.net.http

Chapter 25 Event Handling

Two Event Handling Mechanisms

The Delegation Event Model

Events

Event Sources

Event Listeners

Event Classes

The ActionEvent Class

The AdjustmentEvent Class

The ComponentEvent Class

The ContainerEvent Class

The FocusEvent Class

The InputEvent Class

The ItemEvent Class

The KeyEvent Class

The MouseEvent Class

The MouseWheelEvent Class

The TextEvent Class

The WindowEvent Class

Sources of Events

Event Listener Interfaces

The ActionListener Interface

The AdjustmentListener Interface

The ComponentListener Interface

The ContainerListener Interface

The FocusListener Interface

The ItemListener Interface

The KeyListener Interface

The MouseListener Interface

The MouseMotionListener Interface

The MouseWheelListener Interface

The TextListener Interface

The WindowFocusListener Interface

The WindowListener Interface

Using the Delegation Event Model

Some Key AWT GUI Concepts

Handling Mouse Events

Handling Keyboard Events

Adapter Classes

Inner Classes

Anonymous Inner Classes

Chapter 26 Introducing the AWT: Working with Windows, Graphics, and Text

AWT Classes

Window Fundamentals

Component

Container

Panel

Window

Frame

Canvas

Working with Frame Windows

Setting the Window’s Dimensions

Hiding and Showing a Window

Setting a Window’s Title

Closing a Frame Window

The paint( ) Method

Displaying a String

Setting the Foreground and Background Colors

Requesting Repainting

Creating a Frame-Based Application

Introducing Graphics

Drawing Lines

Drawing Rectangles

Drawing Ellipses and Circles

Drawing Arcs

Drawing Polygons

Demonstrating the Drawing Methods

Sizing Graphics

Working with Color

Color Methods

Setting the Current Graphics Color

A Color Demonstration Program

Setting the Paint Mode

Working with Fonts

Determining the Available Fonts

Creating and Selecting a Font

Obtaining Font Information

Managing Text Output Using FontMetrics

Chapter 27 Using AWT Controls, Layout Managers, and Menus

AWT Control Fundamentals

Adding and Removing Controls

Responding to Controls

The HeadlessException

Labels

Using Buttons

Handling Buttons

Applying Check Boxes

Handling Check Boxes

CheckboxGroup

Choice Controls

Handling Choice Lists

Using Lists

Handling Lists

Managing Scroll Bars

Handling Scroll Bars

Using a TextField

Handling a TextField

Using a TextArea

Understanding Layout Managers

FlowLayout

BorderLayout

Using Insets

GridLayout

CardLayout

GridBagLayout

Menu Bars and Menus

Dialog Boxes

A Word About Overriding paint( )

Chapter 28 Images

File Formats

Image Fundamentals: Creating, Loading, and Displaying

Creating an Image Object

Loading an Image

Displaying an Image

Double Buffering

ImageProducer

MemoryImageSource

ImageConsumer

PixelGrabber

ImageFilter

CropImageFilter

RGBImageFilter

Additional Imaging Classes

Chapter 29 The Concurrency Utilities

The Concurrent API Packages

java.util.concurrent

java.util.concurrent.atomic

java.util.concurrent.locks

Using Synchronization Objects

Semaphore

CountDownLatch

CyclicBarrier

Exchanger

Phaser

Using an Executor

A Simple Executor Example

Using Callable and Future

The TimeUnit Enumeration

The Concurrent Collections

Locks

Atomic Operations

Parallel Programming via the Fork/Join Framework

The Main Fork/Join Classes

The Divide-and-Conquer Strategy

A Simple First Fork/Join Example

Understanding the Impact of the Level of Parallelism

An Example that Uses RecursiveTask<V>

Executing a Task Asynchronously

Cancelling a Task

Determining a Task’s Completion Status

Restarting a Task

Things to Explore

Some Fork/Join Tips

The Concurrency Utilities Versus Java’s Traditional

Approach

Chapter 30 The Stream API

Stream Basics

Stream Interfaces

How to Obtain a Stream

A Simple Stream Example

Reduction Operations

Using Parallel Streams

Mapping

Collecting

Iterators and Streams

Use an Iterator with a Stream

Use Spliterator

More to Explore in the Stream API

Chapter 31 Regular Expressions and Other Packages

Regular Expression Processing

Pattern

Matcher

Regular Expression Syntax

Demonstrating Pattern Matching

Two Pattern-Matching Options

Exploring Regular Expressions

Reflection

Remote Method Invocation

A Simple Client/Server Application Using RMI

Formatting Date and Time with java.text

DateFormat Class

SimpleDateFormat Class

The java.time Time and Date API

Time and Date Fundamentals

Formatting Date and Time

Parsing Date and Time Strings

Other Things to Explore in java.time

Part III Introducing GUI Programming with Swing

Chapter 32 Introducing Swing

The Origins of Swing

Swing Is Built on the AWT

Two Key Swing Features

Swing Components Are Lightweight

Swing Supports a Pluggable Look and Feel

The MVC Connection

Components and Containers

Components

Containers

The Top-Level Container Panes

The Swing Packages

A Simple Swing Application

Event Handling

Painting in Swing

Painting Fundamentals

Compute the Paintable Area

A Paint Example

Chapter 33 Exploring Swing

JLabel and ImageIcon

JTextField

The Swing Buttons

JButton

JToggleButton

Check Boxes

Radio Buttons

JTabbedPane

JScrollPane

JList

JComboBox

Trees

JTable

Chapter 34 Introducing Swing Menus

Menu Basics

An Overview of JMenuBar, JMenu, and JMenuItem

JMenuBar

JMenu

JMenuItem

Create a Main Menu

Add Mnemonics and Accelerators to Menu Items

Add Images and Tooltips to Menu Items

Use JRadioButtonMenuItem and JCheckBoxMenuItem

Create a Popup Menu

Create a Toolbar

Use Actions

Put the Entire MenuDemo Program Together

Continuing Your Exploration of Swing

Part IV Applying Java

Chapter 35 Java Beans

What Is a Java Bean?

Advantages of Beans

Introspection

Design Patterns for Properties

Design Patterns for Events

Methods and Design Patterns

Using the BeanInfo Interface

Bound and Constrained Properties

Persistence

Customizers

The JavaBeans API

Introspector

PropertyDescriptor

EventSetDescriptor

MethodDescriptor

A Bean Example

Chapter 36 Introducing Servlets

Background

The Life Cycle of a Servlet

Servlet Development Options

Using Tomcat

A Simple Servlet

Create and Compile the Servlet Source Code

Start Tomcat

Start a Web Browser and Request the Servlet

The Servlet API

The jakarta.servlet Package

The Servlet Interface

The ServletConfig Interface

The ServletContext Interface

The ServletRequest Interface

The ServletResponse Interface

The GenericServlet Class

The ServletInputStream Class

The ServletOutputStream Class

The Servlet Exception Classes

Reading Servlet Parameters

The jakarta.servlet.http Package

The HttpServletRequest Interface

The HttpServletResponse Interface

The HttpSession Interface

The Cookie Class

The HttpServlet Class

Handling HTTP Requests and Responses

Handling HTTP GET Requests

Handling HTTP POST Requests

Using Cookies

Session Tracking

Part V Appendixes

Appendix A Using Java’s Documentation Comments

The javadoc Tags

@author

{@code}

@deprecated

{@docRoot}

@end

@exception

@hidden

{@index}

{@inheritDoc}

{@link}

{@linkplain}

{@literal}

@param

@provides

@return

@see

@serial

@serialData

@serialField

@since

{@snippet}

@start

{@summary}

{@systemProperty}

@throws

@uses

{@value}

@version

The General Form of a Documentation Comment

What javadoc Outputs

An Example that Uses Documentation Comments

Appendix B Introducing JShell

JShell Basics

List, Edit, and Rerun Code

Add a Method

Create a Class

Use an Interface

Evaluate Expressions and Use Built-in Variables

Importing Packages

Exceptions

Some More JShell Commands

Exploring JShell Further

Appendix C Compile and Run Simple Single-File Programs in One

Step

Index

This book is US$10
To get free sample pages OR Buy this book
Send email: [email protected]


Share this Book!

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.