preface

preface to the 3rd edition

java 2, jdk 1.4

introduction

prerequisites

learning java

goals

jdk html

documentation

chapters

exercises

the cd rom

source code

coding standards.

java versions

errors

note on the cover design

acknowledgements

introducfion

to objects

.the progress

of abstraction

an object

has an interface

an object

provides services

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 creation,

use & lifetimes

collections and iterators

the singly rooted hierarchy

downcasting vs.

templates/generics

ensuring proper cleanup

exception handling:

dealing with errors

concurrency

persistence

java and the internet

what is the web?

client-side programming

server-side programming

applications

why java succeeds

systems are easier to

express and understand

maximal leverage

with libraries

error handling

programming in the large

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

arrays in java

you never need to

destroy an object

scoping

scope of objects

creating new

data types: class

fields and methods

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

some example tags

documentation example

coding style

summary

exercises

3: controlling

program flow

using java operators

precedence

assignment

mathematical operators

auto increment

and decrement

relational operators

logical operators

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

true and false

if-else

return

iteration

do-while

for,

break and continue

switch

summary

exercises

4: initialization

& cleanup

guaranteed initialization

with the constructor

method overloading

distinguishing

overloaded methods

overloadihg with primitives

overloading on return values

default constructors

the this keyword

cleanup: finalization

and garbage collection

what is finalize( ) for?

you must perform cleanup

the termination condition

how a garbage

collector works

member initialization

specifying initialization

constructor initialization

array initialization

multidimensional arrays

summary

exercises

5 hiding the

implementation

package: the library unit

creating unique

package names

a custom tool library

using imports

to change behavior

package caveat

java access specifiers

package access

public: interface access

private:

you can't touch that!

protected:

inheritance access

interface

and implementation

class access

summary

exercises

6: reusing classes

composition syntax

inheritance syntax

initializing the base class

combining composition

and inheritance

guaranteeing proper cleanup

name hiding

choosing composition

vs. inheritance

protected

incremental

development

upcasting

why "upcasting"?

the final keyword

final data

final methods

final classes

final caution

initialization

and class loading

initialization with inheritance

summary

exercises

7: polymorphism

upeasting revisited

forgetting the object type

the twist

method-call binding

producing the fight behavior

extensibility

pitfall: "overriding" private

methods

abstract classes

and methods

constructors and

polymorphism

order of constructor calls

inheritance and cleanup

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

extending an interface

with inheritance

grouping constants

initializing fields

in interfaces

nesting interfaces

inner classes

inner dasses and upcasting

inner dasses in methods

and scopes

anon wnous inner classes

the link to the outer class

nested classes

referring to the

outer class object

reaching outward from a

multiply-nested class

inheriting from inner classes

can inner classes

be overridden?

local inner classes

inner class identifiers

why inner classes?

closures & callbacks

inner classes

& control frameworks

summary,

exercises

9: error handling

with exceptions

basic exceptions

exception arguments

catching an exception

the try block

exception handlers

creating your

own exceptions

the exception

specification

catching any exception

rethrowing an exception

exception chaining

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

alternative approaches

history

perspectives

passing exceptions

to the console

converting checked

to unchecked exceptions

exception guidelines

summary

exercises

10: detecting types

the need for rtti

the class object

checking before a cast

rtti syntax

reflection: run time

class information

a class method extractor

summary

exercises

11: collections

of 0bjects

arrays

arrays are first-class objects

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

iterators

container taxonomy

collection functionality

list functionality

making a stack

from a linkedlist

making a queue

from a linkedlist

set functionality

sortedset

map functionality

sortedmap

linkedhashmap

hashing and hash codes

overriding hashcode( )

holding references

the weaki-iashmap

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

sypchronizing a

collection or map

unsupported operations

java 1.0/1.1 containers

vector & enumeration

hashtable

stack

bitset

summary

exercises

12: the java

i/0 system

the file class

a directory lister

checking for and

creating directories

input and output

types of inputstream

types of outputstream

adding attributes

and useful interfaces

reading from an inputstream

with filterlnputstream

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/0 streams

input streams

output streams

piped streams

file reading

& writing utilities

standard i/o

reading from standard input

changing system.out

to a printwriter

redirecting standard i/o

new i/o

converting data

fetching primitives

view buffers

data manipulation

with buffers

buffer details

memory-mapped files

file locking

compression

simple compression

with gzip

multifile storage with zip

java .archives (jars)

object serialization

finding the class

controlling serialization

using persistence

preferences

regular expressions

creating regular expressions

quantifiers

pattern and matcher

split( )

replace operations

reset( )

regular expressions

and java i/o

is stringtokenizer needed?

summary

exercises

13: concurrency

motivation

basic threads

yielding

sleeping

priority

daemon threads

joining a thread

coding variations

creating responsive

user interfaces

sharing

limited resources

improperly

accessing resources

colliding over resources

resolving shared

resource contention

critical sections

thread states

becoming blocked

cooperation

between threads

wait and notify

using pipes for i/0

between threads

more sophisticated

cooperation

deadlock

the proper way to stop

interrupting a

blocked thread

thread groups

summary

exercises

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

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

tracking multiple events

a catalog of

swing components

buttons

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

drawfng

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

signing applets

jnlp and

java web start

programming

techniques

binding events dynamically

separating business logic

from ui logic

a canonical form

concurrency & swing

runnable revisited

managing concurrency

visual programming

and javabeans

what is a javabean?

exracting beaninfo

with the introspector

a more sophisticated bean

javabeans

and synachronization

packaging a bean

more complex bean support

more to beans

summary

exercises

discovering

problems

unit testing

a simple testing framework

junit

improving reliability

with assertions

assertion syntax

using assertions for

design by contract

example: dbc +

white-box unit testing

building with ant

automate everything

problems with make

ant: the defacto standard

version control with cts

daily builds

logging

logging levels

logrecords

handlers

filters

formatters

example: sending email

to report log messages

controlling logging levels

through namespaces

logging practices

for large projects

summary

debugging

debugging with jdb

graphical debuggers

profiling and optimizing

tracking

memory consumption

tracking cpu usage

coverage testing

jvm profiling interface

using hprof

thread performance

optimization guidelines

dodets

summary

exercises

16: analysis

and design

methodology

phase o: make a plan

the mission statement

phase 1:

what are we making?

phase e:

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

strategies for transition

guidelines

management obstacles

summary

a: passing

& returning objects

passing references

around

aliasing

making local copies

pass by value

cloning objects

adding doneability

to a class

successful cloning

the effect of

object.clone( )

cloning a composed object

a deep copy

with arraylist

deep copy via serialization

adding cloneability

farther down a hierarchy

why this strange design?

controlling

doneability

the copy constructor

read-only classes

creating read-only classes

the drawback

to immutability

immutable strings

the string and

stringbuffer classes

strings are special

summary

exercises

b: java programming

guidelines

design

implementation

c: supplements

foundations for java

seminar-on-cd

thinking in java

seminar

hands-on java seminar-

on-cd 3rd edition

designing objects &

systems seminar

thinking in

enterprise java

the j2ee seminar

thinking in patterns

(with java)

thinking in patterns

seminar

design consulting

and reviews

d: resources

software

books

analysis & design

python

my own list of books

index