Thinking in Java, 1st edition - Contents

Thinking in Java, 1st edition - Title Page

Online documentation

Multimedia CD ROM

Coding standards

Seminars and mentoring

Note on the cover design

Acknowledgements

1: Introduction to objects

The progress of abstraction

An object has an interface

The hidden implementation

Reusing the implementation

Inheritance: reusing the interface

Overriding base-class functionality

Is-a vs. is-like-a relationships

Interchangeable objects with polymorphism

Dynamic binding

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

Staying on course

Phase 0: Let’s make a plan

Phase 1: What are we making?

Phase 2: How will we build it?

Phase 3: Let’s build it!

Phase 4: Iteration

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

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

Enumerators (iterators)

Types of collections

Creating “key” classes

Properties: a type of Hashtable

Enumerators revisited

The generic collection library

The new 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

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

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: 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 Vector

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

13: Creating windows and applets

Why use the AWT?

The basic applet

Testing applets

A more graphical example

Demonstrating the framework methods

Making a button

Capturing an event

Drop-down lists

Controlling layout

Combining layouts

Alternatives to action

Applet restrictions

Applet advantages

Windowed applications

The new event model

Event and listener types

Using listener adapters for simplicity

Making windows and applets with the Java 1.1 AWT

Making the window listener an anonymous class

Packaging the applet into a JAR file

Revisiting the earlier examples

Check boxes and radio buttons

Drop-down lists

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

Java 1.1 UI APIs

Printing graphics

Running Frames within applets

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

The Swing message box

14: 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 1.2

Controlling thread groups

Runnable revisited

Too many threads

15: 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

A Web application

The server application

The Java program

The NameSender applet

Problems with this approach

Connecting Java to CGI

Encoding data for CGI

Displaying a Web page from within an applet

The CGI program in C++

What about POST?

Connecting to databases with 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

Remote interfaces

Implementing the remote interface

Setting up the registry

Creating stubs and skeletons

Using the remote object

Alternatives to RMI

16: Design patterns

The pattern concept

Classifying patterns

The observer pattern

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?

Text processing

Extracting code listings

Building a packed file

Extracting from a packed file

Accessing and writing the listings

Containing the entire collection of listings

The main program

Checking capitalization style

A method lookup tool

Complexity theory

A: Using non-Java code

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

The @dll.import directive

Aliasing and linking by ordinal

Applying @dll.import to the entire class

The com.ms.win32 package

Writing callback functions

Other J/Direct features

Raw Native Interface (RNI)

Java/COM integration

COM Fundamentals

GUIDs and the Registry

Function return codes in COM: HRESULT

MS Java/COM Integration

Developing COM servers in Java

Developing COM clients in Java

The com.ms.com package

ActiveX/Beans integration

A note about native methods and applets

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

B: Comparing C++ and Java

C: Java programming guidelines

Locating the bottleneck

1. Install your own instrumentation

2. JDK profiling [2]

3. Special tools

Tips for measuring performance

Speedup techniques

Generic approaches

Language dependent approaches

General modifications

Specific situations

Other suggestions

Performance tools

Java specific books

E: A bit about garbage collection

F: Recommended reading