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

Thinking in Java, 2nd ed. Revision 5 - 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 handles

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

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 and 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

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

Automatic compilation

A custom tool library

Classpath pitfall

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

Initialization and class loading

Initialization with inheritance

7: Polymorphism

Method call binding

Producing the right behavior

Overriding vs. overloading

Abstract classes and methods

“Multiple inheritance” in Java

Extending an interface with inheritance

Grouping constants

Initializing fields in interfaces

Inner classes and upcasting

Inner classes in methods and scopes

The link to the outer class

static inner classes

Referring to the outer class object

Inheriting from inner classes

Can inner classes be overridden?

Inner class identifiers

Why inner classes: control frameworks

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: Holding your objects

Arrays are first-class objects

Collections of primitives

Returning an array

Disadvantage: unknown type

Sometimes it works right anyway

Making a type-conscious Vector

Parameterized types

Types of collections

Creating “key” classes

Properties: a type of HashMap

Enumerators revisited

Java 2 Collections

Using Collections

Choosing an implementation

Choosing between Lists

Choosing between Sets

Choosing between Maps

Unsupported operations

Sorting and searching

Comparable and Comparator

Making a Collection or Map unmodifiable

Synchronizing a Collection or Map

9: Error handling with exceptions

Basic exceptions

Exception arguments

Catching an exception

Exception handlers

Termination vs. resumption

The exception specification

Catching any exception

Rethrowing an exception

Standard Java exceptions

The special case of RuntimeException

Creating your own exceptions

Exception restrictions

Performing cleanup with finally

What’s finally for?

Pitfall: the lost exception

Exception matching

Exception guidelines

10: The Java IO system

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

Off by itself: RandomAccessFile

A directory lister

Anonymous inner classes

A sorted directory listing

Checking for and creating directories

Typical uses of IO streams

1. Buffered input file

2. Input from memory

3. Formatted memory input

4. Line numbering and file output

5. Storing and recovering data

6. Reading and writing random access files

Shorthand for file manipulation

7. File input shorthand

8. Formatted file output shorthand

9. Data file output shorthand

Reading from standard input

StreamTokenizer

StringTokenizer

Java 1.1 IO streams

Sources and sinks of data

Modifying stream behavior

Unchanged Classes

A cross-reference generator

Redirecting standard IO

Simple compression with GZIP

Multi-file storage with Zip

The Java archive (jar) utility

Object serialization

Finding the class

Controlling serialization

The transient keyword

An alternative to Externalizable

Using persistence

Checking capitalization style

11: Run-time type identification

The need for RTTI

The Class object

Checking before a cast

Using class literals

A dynamic instanceof

Reflection: run-time class information

A class method extractor

12: Creating windows and applets

The basic applet

Running applets inside a Web browser

Automatically generating HTML files

Using Appletviewer

Testing applets

Making a button

Capturing an event

HTML text on Swing components

Drop-down lists

Controlling layout

Absolute positioning

Alternatives to action

Closing the window

Applet restrictions

Applet advantages

Windowed applications

Combined application/applet

The event model

Event and listener types

Using listener adapters for simplicity

Making windows and applets

Packaging the applet into a JAR file

Revisiting the earlier examples

Demonstrating the framework methods

Check boxes and radio buttons

Drop-down lists

Selecting Look & Feel

Binding events dynamically

Separating business logic from UI logic

Recommended coding approaches

Baseline: the good way to do it

Implementing the main class as a listener

Mixing the approaches

Inheriting a component

Ugly component inheritance

Visual programming and Beans

What is a Bean?

Extracting BeanInfo with the Introspector

A more sophisticated Bean

Packaging a Bean

More complex Bean support

Introduction to Swing

Benefits of Swing

Easy conversion

A display framework

List boxes and combo boxes

Sliders and progress bars

Using URLs from within an applet

Reading a file from the server

A method lookup tool

13: Multiple threads

Responsive user interfaces

Inheriting from Thread

Threading for a responsive interface

Improving the code with an inner class

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

Java Beans revisited

Becoming blocked

Suspending and resuming

Wait and notify

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

Controlling thread groups

Runnable revisited

Too many threads

14: Distributed computing

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

RMI (Remote Method Invocation)

Remote interfaces

Implementing the remote interface

Setting up the registry

Creating stubs and skeletons

Using the remote object

Introduction to CORBA

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

Jini: distributed services

Jini in context

The discovery process

The join process

The lookup process

Separation of interface and implementation

Abstracting distributed systems

15: Enterprise programming

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

The basic servlet

Java Server Pages

Basic operations

Embedding blocks of code

Extracting fields and values

Manipulating sessions in JSP

Creating and modifying Cookies

Passing control to other servlets

RMI in the enterprise

Corba in the enterprise

Enterprise Java Beans (EJB)

Why do we need EJB?

How do I put the ‘E’ in my existing JavaBeans?

Components in the Enterprise Java Beans

Enterprise JavaBeans

Bean Managed Persistence

Container Managed Persistence

Bean Managed vs. Container Managed Persistence

Deployment Descriptors

Roles of Enterprise Java Beans

Enterprise Bean Provider

Application Assembler

EJB Server/Container Provider

System Administrator

Development with Enterprise Java Beans

Developing a Simple Stateless Session Bean

Developing a Simple Stateful Session Bean

Developing a BMP Entity Bean

Developing a CMP Entity Bean

Discussion Points, Interesting Issues and Further Reading

Why so many rules?

What is not defined in the EJB Specification

Other References

Accessing enterprise services

Java Naming and Directory Interface (JNDI)

Java Messaging Service (JMS)

Enterprise security

16: Design patterns

The pattern concept

Classifying patterns

Building application frameworks

Template method

Fronting for an implementation

Factories: encapsulating object creation

Polymorphic factories

Abstract factories

Chain of responsibility

Changing the interface

Package as a variation of Façade

Interpreter: run-time flexibility

Observing flowers

A visual example of observers

Multiple dispatching

Visitor, a type of multiple dispatching

Pattern refactoring

Simulating the trash recycler

Improving the design

“Make more objects”

A pattern for prototyping creation

Trash subclasses

Parsing Trash from an external file

Recycling with prototyping

Abstracting usage

Multiple dispatching

Implementing the double dispatch

The Visitor pattern

RTTI considered harmful?

A: Passing and returning objects

Passing handles 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)

The Java Native Interface

Calling a native method

The C 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 pre-existing code base

The Microsoft way

C: Java programming guidelines

D: Recommended reading