您的位置：寻梦网首页＞编程乐园＞Java天地＞Core Java＞Thinking in Java, 2nd ed

Thinking in Java, 2nd ed. Revision 12 - Contents

Thinking in Java, 2nd ed. Revision 12 - Title Page

Preface to the 2nd edition

Online documentation

Multimedia CD ROM

Coding standards

Seminars and mentoring

Note on the cover design

Acknowledgements

Internet contributors

1: Introduction to Objects

The progress of abstraction

An object has an interface

The hidden implementation

Reusing the implementation

Inheritance: reusing the interface

Is-a vs. is-like-a relationships

Interchangeable objects with polymorphism

Abstract base classes and interfaces

Object landscapes and lifetimes

Collections and iterators

The singly rooted hierarchy

Collection libraries and support for easy collection use

Downcasting vs. templates/generics

The housekeeping dilemma: who should clean up?

Garbage collectors vs. efficiency and flexibility

Exception handling: dealing with errors

Java and the Internet

What is the Web?

Client/Server computing

The Web as a giant server

Client-side programming

Scripting languages

Internet vs. intranet

Server-side programming

A separate arena: applications

Analysis and design

Phase 0: Make a plan

The mission statement

Phase 1: What are we making?

Phase 2: How will we build it?

Five stages of object design

Guidelines for object development

Phase 3: Build the core

Phase 4: Iterate the use cases

Phase 5: Evolution

Extreme programming

Write tests first

Pair programming

Why Java succeeds

Systems are easier to express and understand

Maximal leverage with libraries

Programming in the large

Strategies for transition

2. Low-risk project

3. Model from success

4. Use existing class libraries

5. Don’t rewrite existing code in Java

Management obstacles

Performance issues

Common design errors

2: Everything is an Object

You manipulate objects with references

You must create all the objects

Where storage lives

Special case: primitive types

High-precision numbers

You never need to destroy an object

Scope of objects

Creating new data types: class

Fields and methods

Default values for primitive members

Methods, arguments, and return values

The argument list

Building a Java program

Name visibility

Using other components

The static keyword

Your first Java program

Compiling and running

Comments and embedded documentation

Comment documentation

@see: referring to other classes

Class documentation tags

Variable documentation tags

Method documentation tags

Documentation example

3: Controlling Program Flow

Using Java operators

Aliasing during method calls

Mathematical operators

Unary minus and plus operators

Auto increment and decrement

Relational operators

Testing object equivalence

Logical operators

Short-circuiting

Bitwise operators

Shift operators

Ternary if-else operator

The comma operator

String operator +

Common pitfalls when using operators

Casting operators

Java has no “sizeof”

Precedence revisited

A compendium of operators

Execution control

The comma operator

break and continue

The infamous “goto”

Calculation details

4: Initialization & Cleanup

Guaranteed initialization with the constructor

Method overloading

Distinguishing overloaded methods

Overloading with primitives

Overloading on return values

Default constructors

The this keyword

Calling constructors from constructors

The meaning of static

Cleanup: finalization and garbage collection

What is finalize( ) for?

You must perform cleanup

The death condition

How a garbage collector works

Member initialization

Specifying initialization

Constructor initialization

Order of initialization

Static data initialization

Explicit static initialization

Non-static instance initialization

Array initialization

Multidimensional arrays

5: Hiding the Implementation

package: the library unit

Creating unique package names

A custom tool library

Using imports to change behavior

Java access specifiers

public: interface access

The default package

private: you can’t touch that!

protected: “sort of friendly”

Interface and implementation

6: Reusing Classes

Composition syntax

Inheritance syntax

Initializing the base class

Constructors with arguments

Catching base constructor exceptions

Combining composition and inheritance

Guaranteeing proper cleanup

Order of garbage collection

Choosing composition vs. inheritance

Incremental development

Why “upcasting”?

Composition vs. inheritance revisited

The final keyword

Final arguments

final and private

Initialization and class loading

Initialization with inheritance

7: Polymorphism

Upcasting revisited

Forgetting the object type

Method-call binding

Producing the right behavior

Overriding vs. overloading

Abstract classes and methods

Constructors and polymorphism

Order of constructor calls

Inheritance and finalize( )

Behavior of polymorphic methods inside constructors

Designing with inheritance

Pure inheritance vs. extension

Downcasting and run-time type identification

8: Interfaces & Inner Classes

“Multiple inheritance” in Java

Name collisions when combining interfaces

Extending an interface with inheritance

Grouping constants

Initializing fields in interfaces

Nesting interfaces

Inner classes and upcasting

Inner classes in methods and scopes

Anonymous inner classes

The link to the outer class

static inner classes

Referring to the outer class object

Reaching outward from a multiply-nested class

Inheriting from inner classes

Can inner classes be overridden?

Inner class identifiers

Why inner classes?

Closures & Callbacks

Inner classes & control frameworks

9: Holding Your Objects

Arrays are first-class objects

Containers of primitives

Returning an array

The Arrays class

Filling an array

Copying an array

Comparing arrays

Array element comparisons

Sorting an array

Searching a sorted array

Introduction to containers

Printing containers

Filling containers

Container disadvantage: unknown type

Sometimes it works anyway

Making a type-conscious ArrayList

Parameterized types

Unintended recursion

Container taxonomy

Collection functionality

List functionality

Making a stack from a LinkedList

Making a queue from a LinkedList

Set functionality

Map functionality

Hashing and hash codes

Understanding hashCode( )

HashMap performance factors

Overriding hashCode( )

Holding references

The WeakHashMap

Iterators revisited

Choosing an implementation

Choosing between Lists

Choosing between Sets

Choosing between Maps

Sorting and searching Lists

Making a Collection or Map unmodifiable

Synchronizing a Collection or Map

Unsupported operations

Java 1.0/1.1 containers

Vector & Enumeration

10: Error Handling with Exceptions

Basic exceptions

Exception arguments

Catching an exception

Exception handlers

Termination vs. resumption

Creating your own exceptions

The exception specification

Catching any exception

Rethrowing an exception

Standard Java exceptions

The special case of RuntimeException

Performing cleanup with finally

What’s finally for?

Pitfall: the lost exception

Exception restrictions

Exception matching

Exception guidelines

11: The Java I/O System

A directory lister

Anonymous inner classes

Checking for and creating directories

Input and output

Types of InputStream

Types of OutputStream

Adding attributes and useful interfaces

Reading from an InputStream with FilterInputStream

Writing to an OutputStream with FilterOutputStream

Readers & Writers

Sources and sinks of data

Modifying stream behavior

Unchanged Classes

Off by itself: RandomAccessFile

Typical uses of I/O streams

1. Buffered input file

2. Input from memory

3. Formatted memory input

5. Storing and recovering data

6. Reading and writing random access files

Reading from standard input

Changing System.out to a PrintWriter

Redirecting standard I/O

Simple compression with GZIP

Multifile storage with Zip

Java ARchives (JARs)

Object serialization

Finding the class

Controlling serialization

The transient keyword

An alternative to Externalizable

Using persistence

Tokenizing input

StreamTokenizer

StringTokenizer

Checking capitalization style

12: Run-time Type Identification

The need for RTTI

The Class object

Checking before a cast

Using class literals

A dynamic instanceof

instanceof vs. Class equivalence

Reflection: run-time class information

A class method extractor

13: Creating Windows & Applets

The basic applet

Applet restrictions

Applet advantages

Application frameworks

Running applets inside a Web browser

Using Appletviewer

Testing applets

Running applets from the command line

A display framework

Using the Windows Explorer

Making a button

Capturing an event

Controlling layout

Absolute positioning

The best approach?

The Swing event model

Event and listener types

Using listener adapters for simplicity

Tracking multiple events

A catalog of Swing components

Combo boxes (drop-down lists)

HTML on Swing components

Sliders and progress bars

Selecting Look & Feel

Packaging an applet into a JAR file

Programming techniques

Binding events dynamically

Separating business logic from UI logic

A canonical form

Visual programming and Beans

What is a Bean?

Extracting BeanInfo with the Introspector

A more sophisticated Bean

Packaging a Bean

More complex Bean support

14: Multiple Threads

Responsive user interfaces

Inheriting from Thread

Threading for a responsive interface

Combining the thread with the main class

Making many threads

Sharing limited resources

Improperly accessing resources

How Java shares resources

Synchronizing the counters

Synchronized efficiency

JavaBeans revisited

Becoming blocked

Suspending and resuming

Wait and notify

Blocking on I/O

The deprecation of stop( ), suspend( ), resume( ), and destroy( ) in Java 2

Reading and setting priorities

Controlling thread groups

Runnable revisited

Too many threads

15: Distributed Computing

Network programming

Identifying a machine

Servers and clients

Testing programs without a network

Port: a unique place within the machine

A simple server and client

Serving multiple clients

Using URLs from within an applet

Reading a file from the server

More to networking

Java Database Connectivity (JDBC)

Getting the example to work

Step 1: Find the JDBC Driver

Step 2: Configure the database

Step 3: Test the configuration

Step 4: Generate your SQL query

Step 5: Modify and paste in your query

A GUI version of the lookup program

Why the JDBC API seems so complex

A more sophisticated example

The basic servlet

Servlets and multithreading

Handling sessions with servlets

The Cookie class

The Session class

Running the servlet examples

Java Server Pages

Implicit objects

JSP scripting elements

Extracting fields and values

JSP page attributes and scope

Manipulating sessions in JSP

Creating and modifying cookies

RMI (Remote Method Invocation)

Remote interfaces

Implementing the remote interface

Setting up the registry

Creating stubs and skeletons

Using the remote object

CORBA fundamentals

CORBA Interface Definition Language (IDL)

The naming service

Writing the IDL source

Creating stubs and skeletons

Implementing the server and the client

Some CORBA services

Activating the name service process

Activating the server and the client

Java Applets and CORBA

Enterprise JavaBeans

JavaBeans vs. EJBs

The EJB specification

EJB Container & Server

Java Naming and Directory Interface (JNDI)

Java Transaction API/Java Transaction Service (JTA/JTS)

CORBA and RMI/IIOP

The pieces of an EJB component

Enterprise Bean

Remote interface

Deployment descriptor

Developing an EJB

Jini: distributed services

Jini in context

The discovery process

The join process

The lookup process

Separation of interface and implementation

Abstracting distributed systems

A: Passing & Returning Objects

Passing references around

Making local copies

Cloning objects

Adding cloneability to a class

Using a trick with protected

Implementing the Cloneable interface

Successful cloning

The effect of Object.clone( )

Cloning a composed object

A deep copy with ArrayList

Deep copy via serialization

Adding cloneability further down a hierarchy

Why this strange design?

Controlling cloneability

The copy constructor

Why does it work in C++ and not Java?

Read-only classes

Creating read-only classes

The drawback to immutability

Immutable Strings

Implicit constants

Overloading ‘+’ and the StringBuffer

The String and StringBuffer classes

Strings are special

B: The Java Native Interface (JNI)

Calling a native method

The header file generator: javah

Name mangling and function signatures

Implementing your DLL

Accessing JNI functions: the JNIEnv argument

Accessing Java Strings

Passing and using Java objects

JNI and Java exceptions

JNI and threading

Using a preexisting code base

Additional information

C: Java Programming Guidelines

Analysis & design

My own list of books