Java核心技術(shù)卷I：基礎(chǔ)知識（第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 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