Contents | Prev | Next

Title Pages - Contents

Title Pages - Title Page

Foreword

Introduction

Seminars and mentoring

Errors

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

Multithreading

Persistence

Java and the Internet

What is the Web?

Client/Server computing

The Web as a giant server

Client-side programming

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

Plans pay off

Java vs. C++?

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

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

Comments and embedded documentation

Comment documentation

Syntax

Embedded HTML

@see: referring to other classes

Class documentation tags

@version

@author

Variable documentation tags

Method documentation tags

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

Ternary if-else operator

The comma operator

String operator +

Common pitfalls when using operators

A compendium of operators

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

Summary

Exercises

5: Hiding the implementation

package: the library unit

Creating unique package names

Automatic compilation

Collisions

A custom tool library

Classpath pitfall

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

Initialization and class loading

Initialization with inheritance

7: Polymorphism

Producing the right behavior

Extensibility

Overriding vs. overloading

Abstract classes and methods

Interfaces

“Multiple inheritance” in Java

Extending an interface with inheritance

Grouping constants

Initializing fields in interfaces

Inner classes

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

Summary

Exercises

8: Holding your objects

Arrays

Arrays are first-class objects

Collections of primitives

Returning an array

Collections

Disadvantage: unknown type

Sometimes it works right anyway

Making a type-conscious Vector

Parameterized types

Enumerators (iterators)

Creating “key” classes

Properties: a type of Hashtable

Enumerators revisited

Sorting

The generic collection library

Choosing an implementation

Choosing between Lists

Choosing between Sets

Choosing between Maps

Unsupported operations

Sorting and searching

Arrays

Comparable and Comparator

Lists

Utilities

Making a Collection or Map unmodifiable

Synchronizing a Collection or Map

Summary

Exercises

9: Error handling with exceptions

Basic exceptions

Exception arguments

Catching an exception

The try block

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

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

The File class

A directory lister

Anonymous inner classes

A sorted directory listing

Checking for and creating directories

Typical uses of IO streams

Input streams

1. Buffered input file

2. Input from memory

3. Formatted memory input

4. Line numbering and file output

Output streams

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

Sources and sinks of data

Modifying stream behavior

Unchanged Classes

An example

Redirecting standard IO

Compression

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

11: Run-time type identification

The need for RTTI

The Class object

Class literals

Checking before a cast

Using class literals

A dynamic instanceof

RTTI syntax

Reflection: run-time class information

A class method extractor

Summary

Exercises

12: Passing and returning objects

Passing handles around

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

Summary

Exercises

13: Creating windows and applets

Why use the AWT?

The basic applet

Testing applets

A more graphical example

Demonstrating the framework methods

Alternatives to action

Applet restrictions

Applet advantages

Windowed applications

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

Text fields

Text areas

Check boxes and radio buttons

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

Running Frames within applets

The clipboard

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

Introduction to Swing

List boxes and combo boxes

Sliders and progress bars

Trees

Tables

Tabbed Panes

The Swing message box

More to Swing

Summary

Exercises

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

Daemon threads

Sharing limited resources

Improperly accessing resources

How Java shares resources

Synchronizing the counters

Synchronized efficiency

Suspending and resuming

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

Priorities

Thread groups

Controlling thread groups

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

A Web application

The server application

The C program

The Java program

The NameSender applet

The Web page

Problems with this approach

Connecting Java to CGI

Encoding data for CGI

The applet

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 methods

Remote interfaces

Implementing the remote interface

Setting up the registry

Creating stubs and skeletons

Using the remote object

Alternatives to RMI

Summary

Exercises

16: Design patterns

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

More coupling?

RTTI considered harmful?

Summary

Exercises

17: Projects

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

J/Direct

The @dll.import directive

Aliasing and linking by ordinal

Applying @dll.import to the entire class

The com.ms.win32 package

Marshaling

Writing callback functions

Other J/Direct features

Raw Native Interface (RNI)

RNI Summary

Java/COM integration

COM Fundamentals

GUIDs and the Registry

Type Libraries

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

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

Summary

B: Comparing C++ and Java

C: Java programming guidelines

D: Performance

Basic approach

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

E: A bit about garbage collection

F: Recommended reading

Index

Contents | Prev | Next