jdk-sandbox: comparison jdk/src/share/classes/javax/management/openmbean/ArrayType.java

equal deleted inserted replaced

-:55f32ae4f920
+:d4c777ccb1db
 /**
 * The <code>ArrayType</code> class is the <i>open type</i> class whose instances describe
 * all <i>open data</i> values which are n-dimensional arrays of <i>open data</i> values.
 * <p>
 * Examples of valid {@code ArrayType} instances are:
-* <pre>
+* <pre>{@code
 * // 2-dimension array of java.lang.String
 * ArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING);
 *
 * // 1-dimension array of int
 * ArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true);
 * // 2-dimension array of java.lang.String
 * ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17);
 *
 * // 3-dimension array of java.lang.String
 * ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18);
-* </pre>
+* }</pre>
 *
 *
 * @since 1.5
 */
 /*
 * <li>if non-primitive array: <tt><i>&lt;dimension&gt;</i>-dimension array of <i>&lt;element_class_name&gt;</i></tt></li>
 * <li>if primitive array: <tt><i>&lt;dimension&gt;</i>-dimension array of <i>&lt;primitive_type_of_the_element_class_name&gt;</i></tt></li>
 * </ul>
 * <p>
 * As an example, the following piece of code:
-* <pre>
+* <pre>{@code
 * ArrayType<String[][][]> t = new ArrayType<String[][][]>(3, SimpleType.STRING);
 * System.out.println("array class name       = " + t.getClassName());
 * System.out.println("element class name     = " + t.getElementOpenType().getClassName());
 * System.out.println("array type name        = " + t.getTypeName());
 * System.out.println("array type description = " + t.getDescription());
-* </pre>
+* }</pre>
 * would produce the following output:
-* <pre>
+* <pre>{@code
 * array class name       = [[[Ljava.lang.String;
 * element class name     = java.lang.String
 * array type name        = [[[Ljava.lang.String;
 * array type description = 3-dimension array of java.lang.String
-* </pre>
+* }</pre>
 * And the following piece of code which is equivalent to the one listed
 * above would also produce the same output:
-* <pre>
+* <pre>{@code
 * ArrayType<String[]> t1 = new ArrayType<String[]>(1, SimpleType.STRING);
 * ArrayType<String[][]> t2 = new ArrayType<String[][]>(1, t1);
 * ArrayType<String[][][]> t3 = new ArrayType<String[][][]>(1, t2);
 * System.out.println("array class name       = " + t3.getClassName());
 * System.out.println("element class name     = " + t3.getElementOpenType().getClassName());
 * System.out.println("array type name        = " + t3.getTypeName());
 * System.out.println("array type description = " + t3.getDescription());
-* </pre>
+* }</pre>
 *
 * @param  dimension  the dimension of arrays described by this <tt>ArrayType</tt> instance;
 *                    must be greater than or equal to 1.
 *
 * @param  elementType  the <i>open type</i> of element values contained
 * <li>if non-primitive array: <tt>1-dimension array of <i>&lt;element_class_name&gt;</i></tt></li>
 * <li>if primitive array: <tt>1-dimension array of <i>&lt;primitive_type_of_the_element_class_name&gt;</i></tt></li>
 * </ul>
 * <p>
 * As an example, the following piece of code:
-* <pre>
+* <pre>{@code
 * ArrayType<int[]> t = new ArrayType<int[]>(SimpleType.INTEGER, true);
 * System.out.println("array class name       = " + t.getClassName());
 * System.out.println("element class name     = " + t.getElementOpenType().getClassName());
 * System.out.println("array type name        = " + t.getTypeName());
 * System.out.println("array type description = " + t.getDescription());
-* </pre>
+* }</pre>
 * would produce the following output:
-* <pre>
+* <pre>{@code
 * array class name       = [I
 * element class name     = java.lang.Integer
 * array type name        = [I
 * array type description = 1-dimension array of int
-* </pre>
+* }</pre>
 *
 * @param elementType the {@code SimpleType} of the element values
 *                    contained in the arrays described by this
 *                    {@code ArrayType} instance.
 *
 * by the {@link OpenType#getClassName() getClassName} method, which
 * includes the dimension information),<br>&nbsp;</li>
 * <li>if this <code>ArrayType</code> instance describes an array of
 * classes implementing the {@code TabularData} interface or the
 * {@code CompositeData} interface, <var>obj</var> is assignable to
-* such a declared array, and each element contained in <var>obj</var>
+* such a declared array, and each element contained in {<var>obj</var>
 * is either null or a valid value for the element's open type specified
 * by this <code>ArrayType</code> instance.</li>
 * </ul>
 *
 * @param obj the object to be tested.
 * <p>
 * Calling this method twice with the same parameters may return the same
 * object or two equal but not identical objects.
 * <p>
 * As an example, the following piece of code:
-* <pre>
+* <pre>{@code
 * ArrayType<String[]> t1 = ArrayType.getArrayType(SimpleType.STRING);
 * ArrayType<String[][]> t2 = ArrayType.getArrayType(t1);
 * ArrayType<String[][][]> t3 = ArrayType.getArrayType(t2);
 * System.out.println("array class name       = " + t3.getClassName());
 * System.out.println("element class name     = " + t3.getElementOpenType().getClassName());
 * System.out.println("array type name        = " + t3.getTypeName());
 * System.out.println("array type description = " + t3.getDescription());
-* </pre>
+* }</pre>
 * would produce the following output:
-* <pre>
+* <pre>{@code
 * array class name       = [[[Ljava.lang.String;
 * element class name     = java.lang.String
 * array type name        = [[[Ljava.lang.String;
 * array type description = 3-dimension array of java.lang.String
-* </pre>
+* }</pre>
 *
 * @param  elementType  the <i>open type</i> of element values contained
 *                      in the arrays described by this <tt>ArrayType</tt>
 *                      instance; must be an instance of either
 *                      <tt>SimpleType</tt>, <tt>CompositeType</tt>,
 * <p>
 * Calling this method twice with the same parameters may return the
 * same object or two equal but not identical objects.
 * <p>
 * As an example, the following piece of code:
-* <pre>
+* <pre>{@code
 * ArrayType<int[][][]> t = ArrayType.getPrimitiveArrayType(int[][][].class);
 * System.out.println("array class name       = " + t.getClassName());
 * System.out.println("element class name     = " + t.getElementOpenType().getClassName());
 * System.out.println("array type name        = " + t.getTypeName());
 * System.out.println("array type description = " + t.getDescription());
-* </pre>
+* }</pre>
 * would produce the following output:
-* <pre>
+* <pre>{@code
 * array class name       = [[[I
 * element class name     = java.lang.Integer
 * array type name        = [[[I
 * array type description = 3-dimension array of int
-* </pre>
+* }</pre>
 *
 * @param arrayClass a primitive array class such as {@code int[].class},
 *                   {@code boolean[][].class}, etc. The {@link
 *                   #getElementOpenType()} method of the returned
 *                   {@code ArrayType} returns the {@link SimpleType}

changeset 21656	d4c777ccb1db
parent 5506	202f599c92aa
child 23010	6dadb192ad81