jdk-sandbox: comparison src/java.base/share/classes/java/io/ObjectOutputStream.java

equal deleted inserted replaced

-:a7f16447085e
+:48e480e56aad
 *
 * @param   out output stream to write to
 * @throws  IOException if an I/O error occurs while writing stream header
 * @throws  SecurityException if untrusted subclass illegally overrides
 *          security-sensitive methods
-* @throws  NullPointerException if <code>out</code> is <code>null</code>
+* @throws  NullPointerException if {@code out} is {@code null}
 * @since   1.4
 * @see     ObjectOutputStream#ObjectOutputStream()
 * @see     ObjectOutputStream#putFields()
 * @see     ObjectInputStream#ObjectInputStream(InputStream)
 */
 * Provide a way for subclasses that are completely reimplementing
 * ObjectOutputStream to not have to allocate private data just used by
 * this implementation of ObjectOutputStream.
 *
 * <p>If there is a security manager installed, this method first calls the
-* security manager's <code>checkPermission</code> method with a
+* security manager's {@code checkPermission} method with a
-* <code>SerializablePermission("enableSubclassImplementation")</code>
+* {@code SerializablePermission("enableSubclassImplementation")}
 * permission to ensure it's ok to enable subclassing.
 *
 * @throws  SecurityException if a security manager exists and its
-*          <code>checkPermission</code> method denies enabling
+*          {@code checkPermission} method denies enabling
 *          subclassing.
 * @throws  IOException if an I/O error occurs while creating this stream
 * @see SecurityManager#checkPermission
 * @see java.io.SerializablePermission
 */
 * this stream.  This may only be called from the writeObject method of the
 * class being serialized. It will throw the NotActiveException if it is
 * called otherwise.
 *
 * @throws  IOException if I/O errors occur while writing to the underlying
-*          <code>OutputStream</code>
+*          {@code OutputStream}
 */
 public void defaultWriteObject() throws IOException {
 SerialCallbackContext ctx = curContext;
 if (ctx == null) {
 throw new NotActiveException("not in call to writeObject");
 * Subclasses may implement this method to store custom data in the stream
 * along with descriptors for dynamic proxy classes.
 *
 * <p>This method is called exactly once for each unique proxy class
 * descriptor in the stream.  The default implementation of this method in
-* <code>ObjectOutputStream</code> does nothing.
+* {@code ObjectOutputStream} does nothing.
 *
-* <p>The corresponding method in <code>ObjectInputStream</code> is
+* <p>The corresponding method in {@code ObjectInputStream} is
-* <code>resolveProxyClass</code>.  For a given subclass of
+* {@code resolveProxyClass}.  For a given subclass of
-* <code>ObjectOutputStream</code> that overrides this method, the
+* {@code ObjectOutputStream} that overrides this method, the
-* <code>resolveProxyClass</code> method in the corresponding subclass of
+* {@code resolveProxyClass} method in the corresponding subclass of
-* <code>ObjectInputStream</code> must read any data or objects written by
+* {@code ObjectInputStream} must read any data or objects written by
-* <code>annotateProxyClass</code>.
+* {@code annotateProxyClass}.
 *
 * @param   cl the proxy class to annotate custom data for
 * @throws  IOException any exception thrown by the underlying
-*          <code>OutputStream</code>
+*          {@code OutputStream}
 * @see ObjectInputStream#resolveProxyClass(String[])
 * @since   1.3
 */
 protected void annotateProxyClass(Class<?> cl) throws IOException {
 }
 * Write the specified class descriptor to the ObjectOutputStream.  Class
 * descriptors are used to identify the classes of objects written to the
 * stream.  Subclasses of ObjectOutputStream may override this method to
 * customize the way in which class descriptors are written to the
 * serialization stream.  The corresponding method in ObjectInputStream,
-* <code>readClassDescriptor</code>, should then be overridden to
+* {@code readClassDescriptor}, should then be overridden to
 * reconstitute the class descriptor from its custom stream representation.
 * By default, this method writes class descriptors according to the format
 * defined in the Object Serialization specification.
 *
 * <p>Note that this method will only be called if the ObjectOutputStream
 * is not using the old serialization stream format (set by calling
-* ObjectOutputStream's <code>useProtocolVersion</code> method).  If this
+* ObjectOutputStream's {@code useProtocolVersion} method).  If this
 * serialization stream is using the old format
-* (<code>PROTOCOL_VERSION_1</code>), the class descriptor will be written
+* ({@code PROTOCOL_VERSION_1}), the class descriptor will be written
 * internally in a manner that cannot be overridden or customized.
 *
 * @param   desc class descriptor to write to the stream
 * @throws  IOException If an I/O error has occurred.
 * @see java.io.ObjectInputStream#readClassDescriptor()
 /**
 * Put the value of the named boolean field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>boolean</code>
+* {@code boolean}
 */
 public abstract void put(String name, boolean val);
 /**
 * Put the value of the named byte field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>byte</code>
+* {@code byte}
 */
 public abstract void put(String name, byte val);
 /**
 * Put the value of the named char field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>char</code>
+* {@code char}
 */
 public abstract void put(String name, char val);
 /**
 * Put the value of the named short field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>short</code>
+* {@code short}
 */
 public abstract void put(String name, short val);
 /**
 * Put the value of the named int field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>int</code>
+* {@code int}
 */
 public abstract void put(String name, int val);
 /**
 * Put the value of the named long field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>long</code>
+* {@code long}
 */
 public abstract void put(String name, long val);
 /**
 * Put the value of the named float field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>float</code>
+* {@code float}
 */
 public abstract void put(String name, float val);
 /**
 * Put the value of the named double field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not
-* <code>double</code>
+* {@code double}
 */
 public abstract void put(String name, double val);
 /**
 * Put the value of the named Object field into the persistent field.
 *
 * @param  name the name of the serializable field
 * @param  val the value to assign to the field
-*         (which may be <code>null</code>)
+*         (which may be {@code null})
-* @throws IllegalArgumentException if <code>name</code> does not
+* @throws IllegalArgumentException if {@code name} does not
 * match the name of a serializable field for the class whose fields
 * are being written, or if the type of the named field is not a
 * reference type
 */
 public abstract void put(String name, Object val);
 /**
 * Write the data and fields to the specified ObjectOutput stream,
 * which must be the same stream that produced this
-* <code>PutField</code> object.
+* {@code PutField} object.
 *
 * @param  out the stream to write the data and fields to
 * @throws IOException if I/O errors occur while writing to the
 *         underlying stream
 * @throws IllegalArgumentException if the specified stream is not
-*         the same stream that produced this <code>PutField</code>
+*         the same stream that produced this {@code PutField}
 *         object
 * @deprecated This method does not write the values contained by this
-*         <code>PutField</code> object in a proper format, and may
+*         {@code PutField} object in a proper format, and may
 *         result in corruption of the serialization stream.  The
-*         correct way to write <code>PutField</code> data is by
+*         correct way to write {@code PutField} data is by
 *         calling the {@link java.io.ObjectOutputStream#writeFields()}
 *         method.
 */
 @Deprecated
 public abstract void write(ObjectOutput out) throws IOException;

changeset 58288	48e480e56aad
parent 58244	da8673f61e94
child 58679	9c3209ff7550