Free books

Our Java forum  

Newsletters archive..

Zipped source of this book you can take here

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