/**

  * Create the {@link BeanDefinitionDocumentReader} to use for actually

  * reading bean definitions from an XML document.

  * <p>The default implementation instantiates the specified "documentReaderClass".

  * @see #setDocumentReaderClass

  */

 protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {

     return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));

 }

 public class A {

     public static void show() {

         System.out.println("Class A show() function");

     }

 }

 public class B extends A {

     public static void show() {

         System.out.println("Class B show() function");

     }

 }

 public class TestCast {

     public static void main(String[] args) {

         TestCast cls = new TestCast();

         Class c = cls.getClass();

         System.out.println(c);

         Object obj = new A();

         B b1 = new B();

         b1.show();

         // casts object

         A a = new A();

         System.out.println(a.getClass());     // 1. 打印a的class对象

         a = A.class.cast(b1);

         a.show();

         System.out.println(obj.getClass());

         System.out.println(b1.getClass());

         System.out.println(a.getClass());     // 2. 打印a转换后的class对象

     }

 }

 /**

  * Casts an object to the class or interface represented

  * by this {@code Class} object.

  *

  * @param obj the object to be cast

  * @return the object after casting, or null if obj is null

  *

  * @throws ClassCastException if the object is not

  * null and is not assignable to the type T.

  *

  * @since 1.5

  */

 @SuppressWarnings("unchecked")

 public T cast(Object obj) {

     if (obj != null && !isInstance(obj))

         throw new ClassCastException(cannotCastMsg(obj));

     return (T) obj;

 }

     /**

      * Determines if the specified {@code Object} is assignment-compatible

      * with the object represented by this {@code Class}.  This method is

      * the dynamic equivalent of the Java language {@code instanceof}

      * operator. The method returns {@code true} if the specified

      * {@code Object} argument is non-null and can be cast to the

      * reference type represented by this {@code Class} object without

      * raising a {@code ClassCastException.} It returns {@code false}

      * otherwise.

      *

      * <p> Specifically, if this {@code Class} object represents a

      * declared class, this method returns {@code true} if the specified

      * {@code Object} argument is an instance of the represented class (or

      * of any of its subclasses); it returns {@code false} otherwise. If

      * this {@code Class} object represents an array class, this method

      * returns {@code true} if the specified {@code Object} argument

      * can be converted to an object of the array class by an identity

      * conversion or by a widening reference conversion; it returns

      * {@code false} otherwise. If this {@code Class} object

      * represents an interface, this method returns {@code true} if the

      * class or any superclass of the specified {@code Object} argument

      * implements this interface; it returns {@code false} otherwise. If

      * this {@code Class} object represents a primitive type, this method

      * returns {@code false}.

      *

      * @param   obj the object to check

      * @return  true if {@code obj} is an instance of this class

      *

      * @since JDK1.1

      */

     public native boolean isInstance(Object obj);

 /**

  * Casts this {@code Class} object to represent a subclass of the class

  * represented by the specified class object.  Checks that the cast

  * is valid, and throws a {@code ClassCastException} if it is not.  If

  * this method succeeds, it always returns a reference to this class object.

  *

  * <p>This method is useful when a client needs to "narrow" the type of

  * a {@code Class} object to pass it to an API that restricts the

  * {@code Class} objects that it is willing to accept.  A cast would

  * generate a compile-time warning, as the correctness of the cast

  * could not be checked at runtime (because generic types are implemented

  * by erasure).

  *

  * @param <U> the type to cast this class object to

  * @param clazz the class of the type to cast this class object to

  * @return this {@code Class} object, cast to represent a subclass of

  *    the specified class object.

  * @throws ClassCastException if this {@code Class} object does not

  *    represent a subclass of the specified class (here "subclass" includes

  *    the class itself).

  * @since 1.5

  */

 @SuppressWarnings("unchecked")

 public <U> Class<? extends U> asSubclass(Class<U> clazz) {

     if (clazz.isAssignableFrom(this))

         return (Class<? extends U>) this;

     else

         throw new ClassCastException(this.toString());

 }