java核心技术英文_Java核心技术卷I:基础知识(第8版)(英文影印版)

Contents

1　AN INTRODUCTION TO JAVA

Java As a Programming Platform

The Java “White Paper” Buzzwords

Simple

Object Oriented

Network-Savvy

Robust

Secure

Architecture Neutral

Portable

Interpreted

High Performance

Multithreaded

Dynamic

Java Applets and the Internet

A Short History of Java

Common Misconceptions about Java

2　THE JAVA PROGRAMMING ENVIRONMENT

Installing the Java Development Kit

Downloading the JDK

Setting the Execution Path

Installing the Library Source and Documentation

Installing the Core Java Program Examples

Navigating the Java Directories

Choosing a Development Environment

Using the Command-Line Tools

Troubleshooting Hints

Using an Integrated Development Environment

Locating Compilation Errors

Running a Graphical Application

Building and Running Applets

3　FUNDAMENTAL PROGRAMMING STRUCTURES IN JAVA

A Simple Java Program

Comments

Data Types

Integer Types

Floating-Point Types

The char Type

The boolean Type

Variables

Initializing Variables

Constants

Operators

Increment and Decrement Operators

Relational and boolean Operators

Bitwise Operators

Mathematical Functions and Constants

Conversions between Numeric Types

Casts

Parentheses and Operator Hierarchy

Enumerated Types

Strings

Substrings

Concatenation

Strings Are Immutable

Testing Strings for Equality

Code Points and Code Units

The String API

Reading the On-Line API Documentation

Building Strings

Input and Output

Reading Input

Formatting Output

File Input and Output

Control Flow

Block Scope

Conditional Statements

Loops

Determinate Loops

Multiple Selections——The switch Statement

Statements That Break Control Flow

Big Numbers

Arrays

The “for each” Loop

Array Initializers and Anonymous Arrays

Array Copying

Command-Line Parameters

Array Sorting

Multidimensional Arrays

Ragged Arrays

4　OBJECTS AND CLASSES

Introduction to Object-Oriented Programming

Classes

Objects

Identifying Classes

Relationships between Classes

Using Predefined Classes

Objects and Object Variables

The GregorianCalendar Class of the Java Library

Mutator and Accessor Methods

Defining Your Own Classes

An Employee Class

Use of Multiple Source Files

Dissecting the Employee Class

First Steps with Constructors

Implicit and Explicit Parameters

Benefits of Encapsulation

Class-Based Access Privileges

Private Methods

Final Instance Fields

Static Fields and Methods

Static Fields

Static Constants

Static Methods

Factory Methods

The main Method

Method Parameters

Object Construction

Overloading

Default Field Initialization

Default Constructors

Explicit Field Initialization

Parameter Names

Calling Another Constructor

Initialization Blocks

Object Destruction and the finalize Method

Packages

Class Importation

Static Imports

Addition of a Class into a Package

Package Scope

The Class Path

Setting the Class Path

Documentation Comments

Comment Insertion

Class Comments

Method Comments

Field Comments

General Comments

Package and Overview Comments

Comment Extraction

Class Design Hints

5　INHERITANCE

Classes, Superclasses, and Subclasses

Inheritance Hierarchies

Polymorphism

Dynamic Binding

Preventing Inheritance: Final Classes and Methods

Casting

Abstract Classes

Protected Access

Object: The Cosmic Superclass

The equals Method

Equality Testing and Inheritance

The hashCode Method

The toString Method

Generic Array Lists

Accessing Array List Elements

Compatibility between Typed and Raw Array Lists

Object Wrappers and Autoboxing

Methods with a Variable Number of Parameters

Enumeration Classes

Reflection

The Class Class

A Primer on Catching Exceptions

Using Reflection to Analyze the Capabilities of Classes

Using Reflection to Analyze Objects at Runtime

Using Reflection to Write Generic Array Code

Method Pointers!

Design Hints for Inheritance

6　INTERFACES AND INNER CLASSES

Interfaces

Properties of Interfaces

Interfaces and Abstract Classes

Object Cloning

Interfaces and Callbacks

Inner Classes

Use of an Inner Class to Access Object State

Special Syntax Rules for Inner Classes

Are Inner Classes Useful? Actually Necessary? Secure?

Local Inner Classes

Accessing final Variables from Outer Methods

Anonymous Inner Classes

Static Inner Classes

Proxies

Properties of Proxy Classes

7　GRAPHICS PROGRAMMING

Introducing Swing

Creating a Frame

Positioning a Frame

Frame Properties

Determining a Good Frame Size

Displaying Information in a Component

Working with D Shapes

Using Color

Using Special Fonts for Text

Displaying Images

8　EVENT HANDLING

Basics of Event Handling

Example: Handling a Button Click

Becoming Comfortable with Inner Classes

Creating Listeners Containing a Single Method Call

Example: Changing the Look and Feel

Adapter Classes

Actions

Mouse Events

The AWT Event Hierarchy

Semantic and Low-Level Events

9　USER INTERFACE COMPONENTS WITH SWING

Swing and the Model-View-Controller Design Pattern

Design Patterns

The Model-View-Controller Pattern

A Model-View-Controller Analysis of Swing Buttons

Introduction to Layout Management

Border Layout

Grid Layout

Text Input

Text Fields

Labels and Labeling Components

Password Fields

Text Areas

Scroll Panes

Choice Components

Checkboxes

Radio Buttons

Borders

Combo Boxes

Sliders

Menus

Menu Building

Icons in Menu Items

Checkbox and Radio Button Menu Items

Pop-Up Menus

Keyboard Mnemonics and Accelerators

Enabling and Disabling Menu Items

Toolbars

Tooltips

Sophisticated Layout Management

The Grid Bag Layout

Group Layout

Using No Layout Manager

Custom Layout Managers

Traversal Order

Dialog Boxes

Option Dialogs

Creating Dialogs

Data Exchange

File Dialogs

Color Choosers

10　DEPLOYING APPLICATIONS AND APPLETS

JAR Files

The Manifest

Executable JAR Files

Resources

Sealing

Java Web Start

The Sandbox

Signed Code

The JNLP API

Applets

A Simple Applet

The Applet HTML Tag and Its Attributes

The object Tag

Use of Parameters to Pass Information to Applets

Accessing Image and Audio Files

The Applet Context

Storage of Application Preferences

Property Maps

The Preferences API

11　EXCEPTIONS, LOGGING, ASSERTIONS, AND DEBUGGING

Dealing with Errors

The Classification of Exceptions

Declaring Checked Exceptions

How to Throw an Exception

Creating Exception Classes

Catching Exceptions

Catching Multiple Exceptions

Rethrowing and Chaining Exceptions

The finally Clause

Analyzing Stack Trace Elements

Tips for Using Exceptions

Using Assertions

Assertion Enabling and Disabling

Using Assertions for Parameter Checking

Using Assertions for Documenting Assumptions

Logging

Basic Logging

Advanced Logging

Changing the Log Manager Configuration

Localization

Handlers

Filters

Formatters

A Logging Recipe

Debugging Tips

Using a Console Window

Tracing AWT Events

Letting the AWT Robot Do the Work

Using a Debugger

12　GENERIC PROGRAMMING

Why Generic Programming?

Who Wants to Be a Generic Programmer?

Definition of a Simple Generic Class

Generic Methods

Bounds for Type Variables

Generic Code and the Virtual Machine

Translating Generic Expressions

Translating Generic Methods

Calling Legacy Code

Restrictions and Limitations

Type Parameters Cannot Be Instantiated with Primitive Types

Runtime Type Inquiry Only Works with Raw Types

You Cannot Throw or Catch Instances of a Generic Class

Arrays of Parameterized Types Are Not Legal

You Cannot Instantiate Type Variables

Type Variables Are Not Valid in Static Contexts of Generic Classes

Beware of Clashes After Erasure

Inheritance Rules for Generic Types

Wildcard Types

Supertype Bounds for Wildcards

Unbounded Wildcards

Wildcard Capture

Reflection and Generics

Using Class[T] Parameters for Type Matching

Generic Type Information in the Virtual Machine

13　COLLECTIONS

Collection Interfaces

Separating Collection Interfaces and Implementation

Collection and Iterator Interfaces in the Java Library

Concrete Collections

Linked Lists

Array Lists

Hash Sets

Tree Sets

Object Comparison

Queues and Deques

Priority Queues

Maps

Specialized Set and Map Classes

The Collections Framework

Views and Wrappers

Bulk Operations

Converting between Collections and Arrays

Algorithms

Sorting and Shuffling

Binary Search

Simple Algorithms

Writing Your Own Algorithms

Legacy Collections

The Hashtable Class

Enumerations

Property Maps

Stacks

Bit Sets

14　MULTITHREADING

What Are Threads?

Using Threads to Give Other Tasks a Chance

Interrupting Threads

Thread States

New Threads

Runnable Threads

Blocked and Waiting Threads

Terminated Threads

Thread Properties

Thread Priorities

Daemon Threads

Handlers for Uncaught Exceptions

Synchronization

An Example of a Race Condition

The Race Condition Explained

Lock Objects

Condition Objects

The synchronized Keyword

Synchronized Blocks

The Monitor Concept

Volatile Fields

Deadlocks

Lock Testing and Timeouts

Read/Write Locks

Why the stop and suspend Methods Are Deprecated

Blocking Queues

Thread-Safe Collections

Efficient Maps, Sets, and Queues

Copy on Write Arrays

Older Thread-Safe Collections

Callables and Futures

Executors

Thread Pools

Scheduled Execution

Controlling Groups of Tasks

Synchronizers

Semaphores

Countdown Latches

Barriers

Exchangers

Synchronous Queues

Example: Pausing and Resuming an Animation

Threads and Swing

Running Time-Consuming Tasks

Using the Swing Worker

The Single-Thread Rule

Appendix

Index