Errata for Patterns in Java, Volume 1

The sentence that says 

UML provides a symbol that allows us to draw links that connect an indefinite number of projects. 

should say 

UML provides a symbol that allows us to draw links that connect an indefinite number of objects. 

• Follow the Don't Talk to Strangers pattern...

• Follow the Law of Demeter pattern...

The line should say 
 * @param factory The Factory object for creating Encryption objects.

The first line of the second code listing on the page should read 
public class EncryptionFactory implements EncryptionFactoryIF

Further down the page, 
        private static final EmberFactory emberFactory 
           = new EmberFactory(); 
        private static EnginolaFactory enginolaFactory 
           = new EnginolaFactory(); 
should say 
        private static final EmberToolkit emberToolkit 
           = new EmberToolkit(); 
        private static final EnginolaToolkit enginolaToolkit 
           = new EnginolaToolkit();

should say 

The MIMEParser class is a subclass of the MessageParser class (a class invented for but not included in this example) that can...

The code listing line that says 
    bdy = nextHeader(); 
should say 
    bdy = nextBodyPart();

The code listing line that says 
    Object getValue() { return value; } 
should say 
    Object getValue() { return value; }

    public void setFactory(DataQueryFactoryIF myFactory) { 

They should look like this: 
    private static DataQueryFactoryIF factory; 

    public static void setFactory(DataQueryFactoryIF myFactory) {

described in Volume 2

described in [BMRSS96]

1. Pass a reference to the client object

1. Pass a reference to the adaptee objecct.

1. There is a hierarchy for manufacturer-independent sensor classes shown with bold boxes—SimpleSensor, AveragingSensor, and StreamingSensor.

 
2. There is a parallel hierarchy of manufacturer specific classes shown in gray dark gray boxes—SimpleSenorImpl, AveragingSensorImpl, and StreamingSensorImpl.

 
3. There is a parallel hierarchy of interfaces, shown in light gray boxes that allow the manufacturer independent classes to remain independent of any manufacturer-specific classes

1. There is a hierarchy for the manufacturer-independent sensor classes — SimpleSensor, AveragingSensor, and StreamingSensor.

 
2. There is a parallel hierarchy of manufacturer specific classes — SimpleSenorImpl, AveragingSensorImpl, and StreamingSensorImpl that  have names beginning with Eagle and Hawk.

 
3. There is a parallel hierarchy of interfaces that allow the manufacturer independent classes to remain independent of any manufacturer-specific classes — SimpleSenorImpl, AveragingSensorImpl, and StreamingSensorImpl.

Don't Talk to Strangers  A conceptual model that uses the Don't Talk to Strangers pattern (discussed in Volume 2) ...

The paragraph should say 

Law of Demeter  A conceptual model that uses the Law of Demeter  pattern (discussed in Volume 2) ...

There are some other lines of code that say 
        if (mru != foundLink) { 
            if (foundLink.previous != null) 
              foundLink.previous.next = foundLink.next; 
            if (foundLink.next != null) 
              foundLink.next.previous = foundLink.previous; 
            foundLink.previous = null; 
            foundLink.next = mru; 
            mru = foundLink; 
        } // if currentCacheSize > 1 
They should say 
        if (mru != foundLink) { 
            if ( foundLink == lru ) { 
              lru = foundLink.previous; 
              lru.next = null; 
            } // if lru 
            if (foundLink.previous != null) 
              foundLink.previous.next = foundLink.next; 
            if (foundLink.next != null) 
              foundLink.next.previous = foundLink.previous; 
            mru.previous = foundLink 
            foundLink.previous = null; 
            foundLink.next = mru; 
            mru = foundLink; 
        } // if mru 1= foundLink

There is a line in  acode example that looks like 

objectInputStream obIn = new ObjectInputStream(fin);

The first 'o' in that line should be capalized like this: 

ObjectInputStream obIn = new ObjectInputStream(fin);

There is a line of code that says 

import java.io.serializable;

It should say 

import java.io.Serializable;

The start method also creates an instance of the DirtyState class and assigns its variables notDirty, fileDirty, paramDirty and bothDirty to the corresponding subclass instances that it creates.

The start method also creates an instance of the DirtyState class.

They should look like this 
    private final static BothDirty  bothDirty  = new BothDirty(); 
    private final static FileDirty  fileDirty  = new FileDirty(); 
    private final static ParamDirty paramDirty = new ParamDirty(); 
    private final static NotDirty   notDirty   = new NotDirty();

There is a sentence that begins with 

When the queue is empty, you want the get method to wait... 

There is a sentence that begins like this:

The call to foo will not return until a call to bar takes...

There is a range of lines of code that read 
            runningThread = (Thread)waitingThreads.get(next); 
            synchronized (runningThread) { 
                runningThread.notifyAll(); 
            } // synchronized (runningThread) 
        } // if waitCount 
    } // done() 
Those lines of code should say 
            runningThread = (Thread)waitingThreads.get(next); 
        } // if waitCount 
        synchronized (runningThread) { 
            runningThread.notifyAll(); 
        } // synchronized (runningThread) 
    } // done()

There is a sentence that says

If the Queue object is empty, a Producer object that wants to get an object from it must wait until a consumer object puts an object in the Queue object.

If the Queue object is empty, a Consumer object that wants to get an object from it must wait until a Producer object puts an object in the Queue object.

It should say: 
                writeLockedThread = (Thread)waitingForWriteLock.get(0); 
                synchronized (writeLockedThread) { 
                    writeLockedThread.notifyAll(); 
                } // synchronized 
            } // if 
        } else if (Thread.currentThread() == writeLockedThread) { 
            if ( outstandingReadLocks==0 
                 && waitingForWriteLock.size()>0) { 
                writeLockedThread = (Thread)waitingForWriteLock.get(0); 
                synchronized (writeLockedThread) { 
                    writeLockedThread.notifyAll(); 
                } // synchronized