An ObjectFactory is responsible + *
An {@code ObjectFactory} is responsible * for creating objects of a specific type. In the above example, * you may have a PrinterObjectFactory for creating Printer objects. *
- * An object factory must implement the ObjectFactory interface. + * An object factory must implement the {@code ObjectFactory} interface. * In addition, the factory class must be public and must have a * public constructor that accepts no parameters. *
- * The getObjectInstance() method of an object factory may + * The {@code getObjectInstance()} method of an object factory may * be invoked multiple times, possibly using different parameters. * The implementation is thread-safe. *
@@ -73,15 +73,15 @@ * specified. *
* Special requirements of this object are supplied
- * using environment.
+ * using {@code environment}.
* An example of such an environment property is user identity
* information.
*
- * NamingManager.getObjectInstance() + * {@code NamingManager.getObjectInstance()} * successively loads in object factories and invokes this method * on them until one produces a non-null answer. When an exception * is thrown by an object factory, the exception is passed on to the caller - * of NamingManager.getObjectInstance() + * of {@code NamingManager.getObjectInstance()} * (and no search is made for other factories * that may produce a non-null answer). * An object factory should only throw an exception if it is sure that @@ -92,27 +92,27 @@ *
* A URL context factory is a special ObjectFactory that * creates contexts for resolving URLs or objects whose locations - * are specified by URLs. The getObjectInstance() method + * are specified by URLs. The {@code getObjectInstance()} method * of a URL context factory will obey the following rules. *
obj is null, create a context for resolving URLs of the
+ * obj set to null on an LDAP URL context factory would return a
+ * scheme id. For example, invoking {@code getObjectInstance()} with
+ * {@code obj} set to null on an LDAP URL context factory would return a
* context that can resolve LDAP URLs
* such as "ldap://ldap.wiz.com/o=wiz,c=us" and
* "ldap://ldap.umich.edu/o=umich,c=us".
* obj is a URL string, create an object (typically a context)
+ * If {@code obj} is a URL string, create an object (typically a context)
* identified by the URL. For example, suppose this is an LDAP URL context
- * factory. If obj is "ldap://ldap.wiz.com/o=wiz,c=us",
+ * factory. If {@code obj} is "ldap://ldap.wiz.com/o=wiz,c=us",
* getObjectInstance() would return the context named by the distinguished
* name "o=wiz, c=us" at the LDAP server ldap.wiz.com. This context can
* then be used to resolve LDAP names (such as "cn=George")
* relative to that context.
* obj is an array of URL strings, the assumption is that the
+ * If {@code obj} is an array of URL strings, the assumption is that the
* URLs are equivalent in terms of the context to which they refer.
* Verification of whether the URLs are, or need to be, equivalent is up
* to the context factory. The order of the URLs in the array is
@@ -120,13 +120,13 @@
* The object returned by getObjectInstance() is like that of the single
* URL case. It is the object named by the URLs.
* obj is of any other type, the behavior of
- * getObjectInstance() is determined by the context factory
+ * If {@code obj} is of any other type, the behavior of
+ * {@code getObjectInstance()} is determined by the context factory
* implementation.
*
- * The name and environment parameters
+ * The {@code name} and {@code environment} parameters
* are owned by the caller.
* The implementation will not modify these objects or keep references
* to them, although it may keep references to clones or copies.
@@ -135,27 +135,27 @@
* Name and Context Parameters.
*
*
- * The name and nameCtx parameters may
+ * The {@code name} and {@code nameCtx} parameters may
* optionally be used to specify the name of the object being created.
- * name is the name of the object, relative to context
- * nameCtx.
+ * {@code name} is the name of the object, relative to context
+ * {@code nameCtx}.
* If there are several possible contexts from which the object
* could be named -- as will often be the case -- it is up to
* the caller to select one. A good rule of thumb is to select the
* "deepest" context available.
- * If nameCtx is null, name is relative
+ * If {@code nameCtx} is null, {@code name} is relative
* to the default initial context. If no name is being specified, the
- * name parameter should be null.
- * If a factory uses nameCtx it should synchronize its use
+ * {@code name} parameter should be null.
+ * If a factory uses {@code nameCtx} it should synchronize its use
* against concurrent access, since context implementations are not
* guaranteed to be thread-safe.
*
* @param obj The possibly null object containing location or reference
* information that can be used in creating an object.
- * @param name The name of this object relative to nameCtx,
+ * @param name The name of this object relative to {@code nameCtx},
* or null if no name is specified.
- * @param nameCtx The context relative to which the name
- * parameter is specified, or null if name is
+ * @param nameCtx The context relative to which the {@code name}
+ * parameter is specified, or null if {@code name} is
* relative to the default initial context.
* @param environment The possibly null environment that is used in
* creating the object.