< prev index next >

src/java.desktop/share/classes/java/beans/DefaultPersistenceDelegate.java

Print this page

        

@@ -29,24 +29,24 @@
 import java.util.Objects;
 import sun.reflect.misc.*;
 
 
 /**
- * The <code>DefaultPersistenceDelegate</code> is a concrete implementation of
- * the abstract <code>PersistenceDelegate</code> class and
+ * The {@code DefaultPersistenceDelegate} is a concrete implementation of
+ * the abstract {@code PersistenceDelegate} class and
  * is the delegate used by default for classes about
- * which no information is available. The <code>DefaultPersistenceDelegate</code>
+ * which no information is available. The {@code DefaultPersistenceDelegate}
  * provides, version resilient, public API-based persistence for
  * classes that follow the JavaBeans&trade; conventions without any class specific
  * configuration.
  * <p>
  * The key assumptions are that the class has a nullary constructor
  * and that its state is accurately represented by matching pairs
  * of "setter" and "getter" methods in the order they are returned
  * by the Introspector.
  * In addition to providing code-free persistence for JavaBeans,
- * the <code>DefaultPersistenceDelegate</code> provides a convenient means
+ * the {@code DefaultPersistenceDelegate} provides a convenient means
  * to effect persistent storage for classes that have a constructor
  * that, while not nullary, simply requires some property values
  * as arguments.
  *
  * @see #DefaultPersistenceDelegate(String[])

@@ -72,17 +72,17 @@
     }
 
     /**
      * Creates a default persistence delegate for a class with a
      * constructor whose arguments are the values of the property
-     * names as specified by <code>constructorPropertyNames</code>.
+     * names as specified by {@code constructorPropertyNames}.
      * The constructor arguments are created by
      * evaluating the property names in the order they are supplied.
      * To use this class to specify a single preferred constructor for use
      * in the serialization of a particular type, we state the
      * names of the properties that make up the constructor's
-     * arguments. For example, the <code>Font</code> class which
+     * arguments. For example, the {@code Font} class which
      * does not define a nullary constructor can be handled
      * with the following persistence delegate:
      *
      * <pre>
      *     new DefaultPersistenceDelegate(new String[]{"name", "style", "size"});

@@ -116,19 +116,19 @@
         }
     }
 
     /**
      * If the number of arguments in the specified constructor is non-zero and
-     * the class of <code>oldInstance</code> explicitly declares an "equals" method
-     * this method returns the value of <code>oldInstance.equals(newInstance)</code>.
+     * the class of {@code oldInstance} explicitly declares an "equals" method
+     * this method returns the value of {@code oldInstance.equals(newInstance)}.
      * Otherwise, this method uses the superclass's definition which returns true if the
      * classes of the two instances are equal.
      *
      * @param oldInstance The instance to be copied.
      * @param newInstance The instance that is to be modified.
-     * @return True if an equivalent copy of <code>newInstance</code> may be
-     *         created by applying a series of mutations to <code>oldInstance</code>.
+     * @return True if an equivalent copy of {@code newInstance} may be
+     *         created by applying a series of mutations to {@code oldInstance}.
      *
      * @see #DefaultPersistenceDelegate(String[])
      */
     protected boolean mutatesTo(Object oldInstance, Object newInstance) {
         // Assume the instance is either mutable or a singleton

@@ -137,18 +137,18 @@
             super.mutatesTo(oldInstance, newInstance) :
             oldInstance.equals(newInstance);
     }
 
     /**
-     * This default implementation of the <code>instantiate</code> method returns
+     * This default implementation of the {@code instantiate} method returns
      * an expression containing the predefined method name "new" which denotes a
      * call to a constructor with the arguments as specified in
-     * the <code>DefaultPersistenceDelegate</code>'s constructor.
+     * the {@code DefaultPersistenceDelegate}'s constructor.
      *
      * @param  oldInstance The instance to be instantiated.
      * @param  out The code output stream.
-     * @return An expression whose value is <code>oldInstance</code>.
+     * @return An expression whose value is {@code oldInstance}.
      *
      * @throws NullPointerException if {@code out} is {@code null}
      *                              and this value is used in the method
      *
      * @see #DefaultPersistenceDelegate(String[])

@@ -346,26 +346,26 @@
             }
         }
     }
 
     /**
-     * This default implementation of the <code>initialize</code> method assumes
+     * This default implementation of the {@code initialize} method assumes
      * all state held in objects of this type is exposed via the
      * matching pairs of "setter" and "getter" methods in the order
      * they are returned by the Introspector. If a property descriptor
      * defines a "transient" attribute with a value equal to
-     * <code>Boolean.TRUE</code> the property is ignored by this
+     * {@code Boolean.TRUE} the property is ignored by this
      * default implementation. Note that this use of the word
      * "transient" is quite independent of the field modifier
-     * that is used by the <code>ObjectOutputStream</code>.
+     * that is used by the {@code ObjectOutputStream}.
      * <p>
      * For each non-transient property, an expression is created
      * in which the nullary "getter" method is applied
-     * to the <code>oldInstance</code>. The value of this
+     * to the {@code oldInstance}. The value of this
      * expression is the value of the property in the instance that is
      * being serialized. If the value of this expression
-     * in the cloned environment <code>mutatesTo</code> the
+     * in the cloned environment {@code mutatesTo} the
      * target value, the new value is initialized to make it
      * equivalent to the old value. In this case, because
      * the property value has not changed there is no need to
      * call the corresponding "setter" method and no statement
      * is emitted. If not however, the expression for this value

@@ -374,11 +374,11 @@
      * the new property value in the object. This scheme removes
      * default information from the output produced by streams
      * using this delegate.
      * <p>
      * In passing these statements to the output stream, where they
-     * will be executed, side effects are made to the <code>newInstance</code>.
+     * will be executed, side effects are made to the {@code newInstance}.
      * In most cases this allows the problem of properties
      * whose values depend on each other to actually help the
      * serialization process by making the number of statements
      * that need to be written to the output smaller. In general,
      * the problem of handling interdependent properties is reduced to
< prev index next >