Prototype Pattern

If you've worked with ISO9000 and the like, you know there is a Document Control Librarian. This person is responsible for handing out and maintaining "official" copies of documents as required by ISO. If you want to get access to a document, you go to the Librarian and request a copy.

The Librarian doesn't know very much at all about the documents he's handing out. Someone else created the document and gave it to him. He just knows a very few things:

how to find the document (he may have many available to him)
how to copy it
how to hand out the copy

From time to time, he's given updates to a document. Again, he doesn't know what the updates are or what they mean, he just knows that he now hands out copies of the new version.

You don't know who gave the original copy to the Librarian. It may have been an outside consultant, it could be another Engineer in your company, or it may have even been you. You don't know how that original copy was created in the first place. It may be a very complicated document requiring elaborate steps to create or it took many years to create.

You can't ask the librarian for a slightly different version of a document, he won't know what you're talking about. However, the copy you received might give you a way to modify itself, perhaps with some fill-in-the-blank pages.

Analogous Entities

Document Control Librarian	=>	PrototypeManager class
the documents	=>	the Prototypical classes
the photocopier	=>	the Clone() method(s) on all the prototype classes
document created elsewhere	=>	the construction of the prototype class is done by another class

The analogy breaks down

There is no illustration of deep vs shallow copy. The Librarian always hands out a shallow copy. If the document has references to other documents, he doesn't normally give you a copy of all those other documents as well.
You can't ask a document to create a clone of itself, you need a third party e.g. photocopier. This third party is not present in the software version of the Prototype Pattern.
the Librarian "finds" a document for you. There may not be a search involved in the software version.

The highlights are:

minimal knowledge inside the PrototypeManager
no parameterization cabability unless the object instance allows it after cloning
compile-time or run-time isolation between the client code and the constructing entity.
object creation is done via a call to Clone()

Factory Pattern

In contrast, a Factory RWE might be McDonalds. If you need a hamburger, you go to the local McDonalds to get one. You don't go to the local bakery because they don't make hamburgers there. You somehow magically know that hamburgers are created at McDonalds.

McDonalds builds the hamburger on the spot. They don't, for example, have Ray Kroc's first hamburger, ask it to copy itself and give you the copy. And you, as the customer, don't have to know what's in the secret sauce (1000 Island dressing).

The people who work at McDonalds have some knowledge about constructing hamburgers but can only generate what's on the menu. You can tailor your hamburger on the spot, e.g. "Hold the pickles". But you have to know what you can and can't change about the hamburger, with a little help from the McDonald's staff and menu, e.g. you have to know what "Supersize" means, and you can't ask for Adovo sauce instead of secret sauce.

The people who work at McDonald's don't really create the hamburgers, they just assemble it according to instructions given to them from McDonald's HQ. The "hamburger creation knowledge" is not at the local McDonald's, just the ingredients and the instructions.

The analogous entities are:

McDonalds	=>	the Factory class
the hamburger	=>	the object instance
the staff	=>	the Factory method used to create the object instance
McDonald's HQ	=>	the actual class constructor(s)

The analogy breaks down:

McDonald's may in fact create the hamburgers prior to you entering the store.
The distinction between McDonald's HQ and the local McDonalds staff is weak. The staff cook the hamburgers locally.

The highlights are:

The Factory has knowledge about how to create an instance
some parameterization cabability can be provided
you require compile-time access to the constructing entity
the factory has access to the creating entity e.g. new