--- old/src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/ObjectType.java	2017-08-08 16:05:59.063694939 -0700
+++ new/src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/ObjectType.java	2017-08-08 16:05:58.979690733 -0700
@@ -21,83 +21,148 @@
 
 package com.sun.org.apache.bcel.internal.generic;
 
-import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.Const;
 import com.sun.org.apache.bcel.internal.Repository;
 import com.sun.org.apache.bcel.internal.classfile.JavaClass;
 
 /**
  * Denotes reference such as java.lang.String.
  *
- * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
+ * @version $Id: ObjectType.java 1749603 2016-06-21 20:50:19Z ggregory $
  */
-public final class ObjectType extends ReferenceType {
-  private String class_name; // Class name of type
+public class ObjectType extends ReferenceType {
 
-  /**
-   * @param class_name fully qualified class name, e.g. java.lang.String
-   */
-  public ObjectType(String class_name) {
-    super(Constants.T_REFERENCE, "L" + class_name.replace('.', '/') + ";");
-    this.class_name = class_name.replace('/', '.');
-  }
-
-  /** @return name of referenced class
-   */
-  public String getClassName() { return class_name; }
-
-  /** @return a hash code value for the object.
-   */
-  public int hashCode()  { return class_name.hashCode(); }
-
-  /** @return true if both type objects refer to the same class.
-   */
-  public boolean equals(Object type) {
-    return (type instanceof ObjectType)?
-      ((ObjectType)type).class_name.equals(class_name) : false;
-  }
-
-  /**
-   * If "this" doesn't reference a class, it references an interface
-   * or a non-existant entity.
-   */
-  public boolean referencesClass(){
-    JavaClass jc = Repository.lookupClass(class_name);
-    if (jc == null)
-      return false;
-    else
-      return jc.isClass();
-  }
-
-  /**
-   * If "this" doesn't reference an interface, it references a class
-   * or a non-existant entity.
-   */
-  public boolean referencesInterface(){
-    JavaClass jc = Repository.lookupClass(class_name);
-    if (jc == null)
-      return false;
-    else
-      return !jc.isClass();
-  }
-
-  public boolean subclassOf(ObjectType superclass){
-    if (this.referencesInterface() || superclass.referencesInterface())
-      return false;
-
-    return Repository.instanceOf(this.class_name, superclass.class_name);
-  }
-
-  /**
-   * Java Virtual Machine Specification edition 2, 5.4.4 Access Control
-   */
-  public boolean accessibleTo(ObjectType accessor) {
-    JavaClass jc = Repository.lookupClass(class_name);
-
-    if(jc.isPublic()) {
-      return true;
-    } else {
-      JavaClass acc = Repository.lookupClass(accessor.class_name);
-      return acc.getPackageName().equals(jc.getPackageName());
+    private final String class_name; // Class name of type
+
+    /**
+     * @since 6.0
+     */
+    public static ObjectType getInstance(final String class_name) {
+        return new ObjectType(class_name);
+    }
+
+    /**
+     * @param class_name fully qualified class name, e.g. java.lang.String
+     */
+    public ObjectType(final String class_name) {
+        super(Const.T_REFERENCE, "L" + class_name.replace('.', '/') + ";");
+        this.class_name = class_name.replace('/', '.');
+    }
+
+
+    /** @return name of referenced class
+     */
+    public String getClassName() {
+        return class_name;
+    }
+
+
+    /** @return a hash code value for the object.
+     */
+    @Override
+    public int hashCode() {
+        return class_name.hashCode();
+    }
+
+
+    /** @return true if both type objects refer to the same class.
+     */
+    @Override
+    public boolean equals( final Object type ) {
+        return (type instanceof ObjectType)
+                ? ((ObjectType) type).class_name.equals(class_name)
+                : false;
+    }
+
+
+    /**
+     * If "this" doesn't reference a class, it references an interface
+     * or a non-existant entity.
+     * @deprecated (since 6.0) this method returns an inaccurate result
+     *   if the class or interface referenced cannot
+     *   be found: use referencesClassExact() instead
+     */
+    @Deprecated
+    public boolean referencesClass() {
+        try {
+            final JavaClass jc = Repository.lookupClass(class_name);
+            return jc.isClass();
+        } catch (final ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+
+    /**
+     * If "this" doesn't reference an interface, it references a class
+     * or a non-existant entity.
+     * @deprecated (since 6.0) this method returns an inaccurate result
+     *   if the class or interface referenced cannot
+     *   be found: use referencesInterfaceExact() instead
+     */
+    @Deprecated
+    public boolean referencesInterface() {
+        try {
+            final JavaClass jc = Repository.lookupClass(class_name);
+            return !jc.isClass();
+        } catch (final ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+
+    /**
+     * Return true if this type references a class,
+     * false if it references an interface.
+     * @return true if the type references a class, false if
+     *   it references an interface
+     * @throws ClassNotFoundException if the class or interface
+     *   referenced by this type can't be found
+     */
+    public boolean referencesClassExact() throws ClassNotFoundException {
+        final JavaClass jc = Repository.lookupClass(class_name);
+        return jc.isClass();
+    }
+
+
+    /**
+     * Return true if this type references an interface,
+     * false if it references a class.
+     * @return true if the type references an interface, false if
+     *   it references a class
+     * @throws ClassNotFoundException if the class or interface
+     *   referenced by this type can't be found
+     */
+    public boolean referencesInterfaceExact() throws ClassNotFoundException {
+        final JavaClass jc = Repository.lookupClass(class_name);
+        return !jc.isClass();
+    }
+
+
+    /**
+     * Return true if this type is a subclass of given ObjectType.
+     * @throws ClassNotFoundException if any of this class's superclasses
+     *  can't be found
+     */
+    public boolean subclassOf( final ObjectType superclass ) throws ClassNotFoundException {
+        if (this.referencesInterfaceExact() || superclass.referencesInterfaceExact()) {
+            return false;
+        }
+        return Repository.instanceOf(this.class_name, superclass.class_name);
+    }
+
+
+    /**
+     * Java Virtual Machine Specification edition 2,  5.4.4 Access Control
+     * @throws ClassNotFoundException if the class referenced by this type
+     *   can't be found
+     */
+    public boolean accessibleTo( final ObjectType accessor ) throws ClassNotFoundException {
+        final JavaClass jc = Repository.lookupClass(class_name);
+        if (jc.isPublic()) {
+            return true;
+        }
+        final JavaClass acc = Repository.lookupClass(accessor.class_name);
+        return acc.getPackageName().equals(jc.getPackageName());
     }
-  }
 }