Java : the complete reference / Herbert Schildt.

Format:

Book

Author/Creator:

Schildt, Herbert, author.

Series:

McGraw-Hill's AccessEngineeringLibrary

Language:

English

Subjects (All):

Java (Computer program language).

Physical Description:

1 online resource (1573 pages)

Edition:

Twelfth edition.

Place of Publication:

New York, New York : McGraw Hill, [2022]

Language Note:

In English.

Summary:

Fully updated for Java SE 17, Java: The Complete Reference, Twelfth Edition explains how to develop, compile, debug, and run Java programs. Best-selling programming author Herb Schildt covers the entire Java language, including its syntax, keywords, and fundamental programming principles. You'll also find information on key portions of the Java API library, such as I/O, the Collections Framework, the stream library, and the concurrency utilities. Swing, JavaBeans, and servlets are examined, and numerous examples demonstrate Java in action. Of course, recent additions to the Java language, such as records, sealed classes, and switch expressions are discussed in detail.

Contents:

Cover

About the Author

Title Page

Copyright Page

Contents at a Glance

Contents

Preface

For Further Study

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

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

if

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

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( )

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

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 instanceof

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.

Notes:

Description based on print version record.

Includes bibliographical references and index.

Description based upon print version of record.

ISBN:

9781260463422

1260463427

OCLC:

1281960050