diff -r a7f16447085e -r 48e480e56aad src/java.base/share/classes/java/io/ObjectOutputStream.java
--- a/src/java.base/share/classes/java/io/ObjectOutputStream.java	Tue Sep 24 10:04:13 2019 +0000
+++ b/src/java.base/share/classes/java/io/ObjectOutputStream.java	Tue Sep 24 09:43:43 2019 +0100
@@ -232,7 +232,7 @@
      * @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()
@@ -259,12 +259,12 @@
      * 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
-     * <code>SerializablePermission("enableSubclassImplementation")</code>
+     * security manager's {@code checkPermission} method with a
+     * {@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
@@ -429,7 +429,7 @@
      * 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;
@@ -529,18 +529,18 @@
      *
      * <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
-     * <code>resolveProxyClass</code>.  For a given subclass of
-     * <code>ObjectOutputStream</code> that overrides this method, the
-     * <code>resolveProxyClass</code> method in the corresponding subclass of
-     * <code>ObjectInputStream</code> must read any data or objects written by
-     * <code>annotateProxyClass</code>.
+     * <p>The corresponding method in {@code ObjectInputStream} is
+     * {@code resolveProxyClass}.  For a given subclass of
+     * {@code ObjectOutputStream} that overrides this method, the
+     * {@code resolveProxyClass} method in the corresponding subclass of
+     * {@code ObjectInputStream} must read any data or objects written by
+     * {@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
      */
@@ -646,16 +646,16 @@
      * 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
@@ -889,10 +889,10 @@
          *
          * @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);
 
@@ -901,10 +901,10 @@
          *
          * @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);
 
@@ -913,10 +913,10 @@
          *
          * @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);
 
@@ -925,10 +925,10 @@
          *
          * @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);
 
@@ -937,10 +937,10 @@
          *
          * @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);
 
@@ -949,10 +949,10 @@
          *
          * @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);
 
@@ -961,10 +961,10 @@
          *
          * @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);
 
@@ -973,10 +973,10 @@
          *
          * @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);
 
@@ -985,8 +985,8 @@
          *
          * @param  name the name of the serializable field
          * @param  val the value to assign to the field
-         *         (which may be <code>null</code>)
-         * @throws IllegalArgumentException if <code>name</code> does not
+         *         (which may be {@code null})
+         * @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
@@ -996,18 +996,18 @@
         /**
          * 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.
          */