About James	My MySpace	Internet Marketing	Enron Loophole	Lock Bumping	Contact Me

JamesThornton.com

Bruce Eckel Books

TIJ-2nd-edition

One Page

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

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

Preface

Preface to the 2nd edition

Java 2

The CD ROM

Introduction

Prerequisites

Learning Java

Goals

Online documentation

Chapters

Exercises

Multimedia CD ROM

Source code

Coding standards

Java versions

Seminars and mentoring

Errors

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

Multithreading

Persistence

Java and the Internet

What is the Web?

Client/Server computing

The Web as a giant server

Client-side programming

Plug-ins

Scripting languages

Java

ActiveX

Security

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

Plans pay off

Extreme programming

Write tests first

Pair programming

Why Java succeeds

Systems are easier to express and understand

Maximal leverage with libraries

Error handling

Programming in the large

Strategies for transition

Guidelines

1. Training

2. Low-risk project

3. Model from success

4. Use existing class libraries

5. Don’t rewrite existing code in Java

Management obstacles

Startup costs

Performance issues

Common design errors

Java vs. C++?

Summary

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

Arrays in Java

You never need to destroy an object

Scoping

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

Syntax

Embedded HTML

@see: referring to other classes

Class documentation tags

@version

@author

@since

Variable documentation tags

Method documentation tags

@param

@return

@throws

@deprecated

Documentation example

Coding style

Summary

Exercises

3: Controlling Program Flow

Using Java operators

Precedence

Assignment

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

Literals

Promotion

Java has no “sizeof”

Precedence revisited

A compendium of operators

Execution control

true and false

if-else

return

Iteration

do-while

for

The comma operator

break and continue

The infamous “goto”

switch

Calculation details

Summary

Exercises

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

Summary

Exercises

5: Hiding the Implementation

package: the library unit

Creating unique package names

Collisions

A custom tool library

Using imports to change behavior

Package caveat

Java access specifiers

“Friendly”

public: interface access

The default package

private: you can’t touch that!

protected: “sort of friendly”

Interface and implementation

Class access

Summary

Exercises

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

Name hiding

Choosing composition vs. inheritance

protected

Incremental development

Upcasting

Why “upcasting”?

Composition vs. inheritance revisited

The final keyword

Final data

Blank finals

Final arguments

Final methods

final and private

Final classes

Final caution

Initialization and class loading

Initialization with inheritance

Summary

Exercises

7: Polymorphism

Upcasting revisited

Forgetting the object type

The twist

Method-call binding

Producing the right behavior

Extensibility

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

Summary

Exercises

8: Interfaces & Inner Classes

Interfaces

“Multiple inheritance” in Java

Name collisions when combining interfaces

Extending an interface with inheritance

Grouping constants

Initializing fields in interfaces

Nesting interfaces

Inner classes

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

Summary

Exercises

9: Holding Your Objects

Arrays

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

Array summary

Introduction to containers

Printing containers

Filling containers

Container disadvantage: unknown type

Sometimes it works anyway

Making a type-conscious ArrayList

Parameterized types

Iterators

Unintended recursion

Container taxonomy

Collection functionality

List functionality

Making a stack from a LinkedList

Making a queue from a LinkedList

Set functionality

SortedSet

Map functionality

SortedMap

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

Utilities

Making a Collection or Map unmodifiable

Synchronizing a Collection or Map

Fail fast

Unsupported operations

Java 1.0/1.1 containers

Vector & Enumeration

Hashtable

Stack

BitSet

Summary

Exercises

10: Error Handling with Exceptions

Basic exceptions

Exception arguments

Catching an exception

The try block

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

Constructors

Exception matching

Exception guidelines

Summary

Exercises

11: The Java I/O System

The File class

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

Input streams

1. Buffered input file

2. Input from memory

3. Formatted memory input

4. File output

Output streams

5. Storing and recovering data

6. Reading and writing random access files

A bug?A bug?

Piped streams

Standard I/O

Reading from standard input

Changing System.out to a PrintWriter

Redirecting standard I/O

Compression

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

Versioning

Using persistence

Tokenizing input

StreamTokenizer

StringTokenizer

Checking capitalization style

Summary

Exercises

12: Run-time Type Identification

The need for RTTI

The Class object

Class literals

Checking before a cast

Using class literals

A dynamic instanceof

instanceof vs. Class equivalence

RTTI syntax

Reflection: run-time class information

A class method extractor

Summary

Exercises

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

Text areas

Controlling layout

BorderLayout

FlowLayout

GridLayout

GridBagLayout

Absolute positioning

BoxLayout

The best approach?

The Swing event model

Event and listener types

Using listener adapters for simplicity

Tracking multiple events

A catalog of Swing components

Buttons

Button groups

Icons

Tool tips

Text fields

Borders

JScrollPanes

A mini-editor

Check boxes

Radio buttons

Combo boxes (drop-down lists)

List boxes

Tabbed panes

Message boxes

Menus

Pop-up menus

Drawing

Dialog Boxes

File dialogs

HTML on Swing components

Sliders and progress bars

Trees

Tables

Selecting Look & Feel

The clipboard

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

More to Beans

Summary

Exercises

14: Multiple Threads

Responsive user interfaces

Inheriting from Thread

Threading for a responsive interface

Combining the thread with the main class

Making many threads

Daemon threads

Sharing limited resources

Improperly accessing resources

How Java shares resources

Synchronizing the counters

Synchronized efficiency

JavaBeans revisited

Blocking

Becoming blocked

Sleeping

Suspending and resuming

Wait and notify

Blocking on I/O

Testing

Deadlock

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

Priorities

Reading and setting priorities

Thread groups

Controlling thread groups

Runnable revisited

Too many threads

Summary

Exercises

15: Distributed Computing

Network programming

Identifying a machine

Servers and clients

Testing programs without a network

Port: a unique place within the machine

Sockets

A simple server and client

Serving multiple clients

Datagrams

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

Servlets

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 directives

JSP scripting elements

Extracting fields and values

JSP page attributes and scope

Manipulating sessions in JSP

Creating and modifying cookies

JSP summary

RMI (Remote Method Invocation)

Remote interfaces

Implementing the remote interface

Setting up the registry

Creating stubs and skeletons

Using the remote object

CORBA

CORBA fundamentals

CORBA Interface Definition Language (IDL)

The naming service

An example

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

CORBA vs. RMI

Enterprise JavaBeans

JavaBeans vs. EJBs

The EJB specification

EJB components

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

Home interface

Remote interface

Deployment descriptor

EJB-Jar file

EJB operation

Types of EJBs

Session Beans

Entity Beans

Developing an EJB

EJB summary

Jini: distributed services

Jini in context

What is Jini?

How Jini works

The discovery process

The join process

The lookup process

Separation of interface and implementation

Abstracting distributed systems

Summary

Exercises

A: Passing & Returning Objects

Passing references around

Aliasing

Making local copies

Pass by value

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

Summary

Exercises

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

Design

Implementation

D: Resources

Software

Books

Analysis & design

Python

My own list of books

Index

Add a comment | Add a link