Clase Java.lang.Class en Java | Serie 1

Java proporciona una clase con el nombre Class en el paquete java.lang. Las instancias de la clase Class representan clases e interfaces en una aplicación Java en ejecución. Los tipos primitivos de Java (boolean, byte, char, short, int, long, float y double) y la palabra clave void también se representan como objetos Class. No tiene constructor público. Los objetos de clase son construidos automáticamente por Java Virtual Machine ( JVM ). Es una clase final, por lo que no podemos extenderla.

Los métodos de clase Class se utilizan ampliamente en la API de Reflection .

Creación de un objeto de clase

Hay tres formas de crear un objeto de clase:

  1. Class.forName(“className”) : Dado que la clase Class no contiene ningún constructor, hay un método de fábrica estático presente en la clase Class, que es Class.forName() , que se usa para crear objetos de la clase Class. A continuación se muestra la sintaxis:
    Class c = Class.forName(String className)
    

    La declaración anterior crea el objeto Class para la clase pasada como un argumento String (className). Tenga en cuenta que el parámetro className debe ser el nombre completo de la clase deseada para la que se creará el objeto Class. Los métodos en cualquier clase en Java que devuelve el mismo objeto de clase también se conocen como métodos de fábrica. El nombre de clase para el que se va a crear el objeto Class se determina en tiempo de ejecución.

  2. Myclass.class: cuando escribimos .class después de un nombre de clase, hace referencia al objeto Class que representa la clase dada. Se usa principalmente con tipos de datos primitivos y solo cuando conocemos el nombre de la clase. El nombre de clase para el que se va a crear el objeto Class se determina en tiempo de compilación. A continuación se muestra la sintaxis:
    Class c = int.class
    

    Tenga en cuenta que este método se usa con el nombre de la clase, no con las instancias de la clase. Por ejemplo

    A a = new A();   // Any class A
    Class c = A.class; // No error
    Class c = a.class; // Error 
    
  3. obj.getClass() : este método está presente en la clase Object . Devuelve la clase de tiempo de ejecución de este objeto (obj). A continuación se muestra la sintaxis:
    A a = new A();   // Any class A
    Class c = a.getClass();
    

Métodos:

  1. String toString() : este método convierte el objeto Class en una string. Devuelve la representación de string que es la string «clase» o «interfaz», seguida de un espacio y luego del nombre completo de la clase. Si el objeto Clase representa un tipo primitivo, este método devuelve el nombre del tipo primitivo y si representa vacío , devuelve «vacío».
    Syntax : 
    public String toString()
    Parameters : 
    NA
    Returns :
    a string representation of this class object.
    Overrides :
    toString in class Object
    

    // Java program to demonstrate toString() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.String");
            Class c2 = int.class;
            Class c3 = void.class;
              
            System.out.print("Class represented by c1: ");
             
            // toString method on c1
            System.out.println(c1.toString());
              
            System.out.print("Class represented by c2: ");
              
            // toString method on c2
            System.out.println(c2.toString());
              
            System.out.print("Class represented by c3: ");
              
            // toString method on c3
            System.out.println(c3.toString());
        }
    }

    Producción:

    Class represented by c1: class java.lang.String
    Class represented by c2: int
    Class represented by c3: void
    
  2. Class<?> forName(String className) : como se discutió anteriormente, este método devuelve el objeto Class asociado con la clase o interfaz con el nombre de string dado. La otra variante de este método se discute a continuación.
    Syntax : 
    public static Class<?> forName(String className) throws ClassNotFoundException
    Parameters : 
    className - the fully qualified name of the desired class.
    Returns :
    return the Class object for the class with the specified name.
    Throws :
    LinkageError : if the linkage fails
    ExceptionInInitializerError - if the initialization provoked by this method fails
    ClassNotFoundException - if the class cannot be located
    

    // Java program to demonstrate forName() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // forName method
            // it returns the Class object for the class 
            // with the specified name 
            Class c = Class.forName("java.lang.String");
              
            System.out.print("Class represented by c : " + c.toString());
        }
    }

    Producción:

    Class represented by c : class java.lang.String
    
  3. Class<?> forName(String className,boolean initialize, ClassLoader loader) : este método también devuelve el objeto Class asociado con la clase o interfaz con el nombre de la string dado usando el cargador de clases dado.

    El cargador de clases especificado se utiliza para cargar la clase o la interfaz. Si el cargador de parámetros es nulo, la clase se carga a través del cargador de clases de arranque. La clase se inicializa solo si el parámetro de inicialización es verdadero y si no se ha inicializado antes.

    Syntax : 
    public static Class<?> forName(String className,boolean initialize, ClassLoader loader) 
    throws ClassNotFoundException
    Parameters : 
    className - the fully qualified name of the desired class
    initialize - whether the class must be initialized
    loader - class loader from which the class must be loaded
    Returns :
    return the Class object for the class with the specified name.
    Throws :
    LinkageError : if the linkage fails
    ExceptionInInitializerError - if the initialization provoked by this method fails
    ClassNotFoundException - if the class cannot be located
    

    // Java program to demonstrate forName() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // returns the Class object for this class
            Class myClass = Class.forName("Test");
          
            ClassLoader loader = myClass.getClassLoader();
              
            // forName method
            // it returns the Class object for the class 
            // with the specified name using the given class loader
            Class c = Class.forName("java.lang.String",true,loader);
              
            System.out.print("Class represented by c : " + c.toString());
        }
    }

    Producción:

    Class represented by c : class java.lang.String
    
  4. T newInstance() : este método crea una nueva instancia de la clase representada por este objeto Class. La clase se crea como si fuera una nueva expresión con una lista de argumentos vacía. La clase se inicializa si aún no se ha inicializado.
    Syntax : 
    public T newInstance() throws InstantiationException,IllegalAccessException
    TypeParameters : 
    T - The class type whose instance is to be returned
    Parameters : 
    NA
    Returns :
    a newly allocated instance of the class represented by this object.
    Throws :
    IllegalAccessException - if the class or its nullary constructor is not accessible.
    InstantiationException - if this Class represents an abstract class, an interface,
    an array class, a primitive type, or void
    or if the class has no nullary constructor; 
    or if the instantiation fails for some other reason.
    ExceptionInInitializerError - if the initialization provoked by this method fails.
    SecurityException - If a security manager, s, is present
    

    // Java program to demonstrate newInstance() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException, InstantiationException,
                             IllegalAccessException
        {
            // returns the Class object for this class
            Class myClass = Class.forName("Test");
              
            // creating new instance of this class
            // newInstance method
            Object obj = myClass.newInstance();
              
            // returns the runtime class of obj
            System.out.println("Class of obj : " + obj.getClass());
        }
    }

    Producción:

    Class of obj : class Test
    
  5. boolean isInstance(Object obj) : este método determina si el objeto especificado es compatible con la asignación del objeto representado por esta clase. Es equivalente al operador instanceof en java.
    Syntax : 
    public boolean isInstance(Object obj)
    Parameters : 
    obj - the object to check
    Returns :
    true if obj is an instance of this class else return false
    

    // Java program to demonstrate isInstance() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c = Class.forName("java.lang.String");
      
            String s = "GeeksForGeeks";
            int i = 10;
              
              
            // checking for Class instance
            // isInstance method
            boolean b1 = c.isInstance(s);
            boolean b2 = c.isInstance(i);
              
            System.out.println("is s instance of String : " + b1);
            System.out.println("is i instance of String : " + b1);
              
        }
    }

    Producción:

    is s instance of String : true
    is i instance of String : false
    
  6. boolean isAssignableFrom(Class<?> cls) : este método determina si la clase o interfaz representada por este objeto Class es la misma o es una superclase o superinterfaz de la clase o interfaz representada por el parámetro Class especificado.
    Syntax : 
    public boolean isAssignableFrom(Class<?> cls)
    Parameters : 
    cls - the Class object to be checked
    Returns :
    true if objects of the type cls can be assigned to objects of this class
    Throws:
    NullPointerException - if the specified Class parameter is null.
    

    // Java program to demonstrate isAssignableFrom() method
    public class Test extends Thread
    {
        public static void main(String[] args)
                             throws ClassNotFoundException, InstantiationException,
                             IllegalAccessException
        {
            // returns the Class object for this class
            Class myClass = Class.forName("Test");
              
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Thread");
            Class c2 = Class.forName("java.lang.String");
              
           // isAssignableFrom method on c1
           // it checks whether Thread class is assignable from Test
           boolean b1 = c1.isAssignableFrom(myClass);
             
           // isAssignableFrom method on c2
           // it checks whether String class is assignable from Test
           boolean b2 = c2.isAssignableFrom(myClass);
             
           System.out.println("is Thread class Assignable from Test : " + b1);
           System.out.println("is String class Assignable from Test : " + b2);
             
        }
    }

    Producción:

    is Thread class Assignable from Test : true
    is String class Assignable from Test : false
    
  7. boolean isInterface() : este método determina si el objeto Class especificado representa un tipo de interfaz .
    Syntax : 
    public boolean isInterface()
    Parameters : 
    NA
    Returns :
    return true if and only if this class represents an interface type else return false
    

    // Java program to demonstrate isInterface() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.String");
            Class c2 = Class.forName("java.lang.Runnable");
              
            // checking for interface type
      
            // isInterface method on c1
            boolean b1 = c1.isInterface();
      
            // is Interface method on c2
            boolean b2 = c2.isInterface();
              
            System.out.println("is java.lang.String an interface : " + b1);
            System.out.println("is java.lang.Runnable an interface : " + b2);
        }
    }

    Producción:

    is java.lang.String an interface : false
    is java.lang.Runnable an interface : true
    
  8. boolean isPrimitive() : este método determina si el objeto Class especificado representa un tipo primitivo.
    Syntax : 
    public boolean isPrimitive() 
    Parameters : 
    NA
    Returns :
    return true if and only if this class represents a primitive type else return false
    

    // Java program to demonstrate isPrimitive method
    public class Test
    {
        public static void main(String[] args) 
        {
            // returns the Class object associated with an integer;
            Class c1 = int.class;
              
           // returns the Class object associated with Test class
            Class c2 = Test.class;
             
            // checking for primitive type
      
            // isPrimitive method on c1
            boolean b1 = c1.isPrimitive();
      
            // isPrimitive method on c2
            boolean b2 = c2.isPrimitive();
              
            System.out.println("is "+c1.toString()+" primitive : " + b1);
            System.out.println("is "+c2.toString()+" primitive : " + b2);
        }
    }

    Producción:

    is int primitive : true
    is class Test primitive : false
    
  9. boolean isArray() : este método determina si el objeto Class especificado representa una clase de array.
    Syntax : 
    public boolean isArray() 
    Parameters : 
    NA
    Returns :
    return true if and only if this class represents an array type else return false
    

    // Java program to demonstrate isArray method
    public class Test
    {
        public static void main(String[] args)
        {
            int a[] = new int[2];
              
            // returns the Class object for array class
            Class c1 = a.getClass();
              
            // returns the Class object for Test class
            Class c2 = Test.class;
              
            // checking for array type
      
            // isArray method on c1
            boolean b1 = c1.isArray();
      
            // is Array method on c2
            boolean b2 = c2.isArray();
              
            System.out.println("is "+c1.toString()+" an array : " + b1);
            System.out.println("is "+c2.toString()+" an array : " + b2);
              
        }
    }

    Producción:

    is class [I an array : true
    is class Test an array : false
    
  10. boolean isAnonymousClass() : este método devuelve verdadero si y solo si esta clase es una clase anónima. Una clase anónima es como una clase local excepto que no tienen nombre.
    Syntax : 
    public boolean isAnonymousClass() 
    Parameters : 
    NA
    Returns :
    true if and only if this class is an anonymous class.
    false,otherwise.
    
  11. boolean isLocalClass() : este método devuelve verdadero si y solo si esta clase es una clase local. Una clase local es una clase que se declara localmente dentro de un bloque de código Java, en lugar de como miembro de una clase.
    Syntax : 
    public boolean isLocalClass()
    Parameters : 
    NA
    Returns :
    true if and only if this class is a local class.
    false,otherwise.
    
  12. boolean isMemberClass() : este método devuelve verdadero si y solo si esta clase es una clase miembro. Una clase miembro es una clase que se declara como miembro no estático de una clase contenedora.
    Syntax : 
    public boolean isMemberClass() 
    Parameters : 
    NA
    Returns :
    true if and only if this class is a Member class.
    false,otherwise.
    
  13. A continuación se muestra el programa Java que explica los usos de los métodos isAnonymousClass(), isLocalClass e isMemberClass().

    // Java program to demonstrate isAnonymousClass() ,isLocalClass 
    // and isMemberClass() method
      
    public class Test
    {
        // any Member class of Test
        class A{}
          
        public static void main(String[] args) 
        {
            // declaring an anonymous class
            Test t1 = new Test()
            {
                //  class definition of anonymous class
            };
              
            // returns the Class object associated with t1 object
            Class c1 = t1.getClass();
              
            // returns the Class object associated with Test class
            Class c2 = Test.class;
              
            // returns the Class object associated with A class
            Class c3 = A.class;
              
            // checking for Anonymous class
            // isAnonymousClass method
            boolean b1 = c1.isAnonymousClass();
            System.out.println("is "+c1.toString()+" an anonymous class : "+b1);
                  
            // checking for Local class
            // isLocalClass method
            boolean b2 = c2.isLocalClass();
            System.out.println("is "+c2.toString()+" a local class : " + b2);
              
            // checking for Member class
            // isMemberClass method
            boolean b3 = c3.isMemberClass();
            System.out.println("is "+c3.toString()+" a member class : " + b3);
             
        }
    }

    Producción:

    is class Test$1 an anonymous class : true
    is class Test a local class : false
    is class Test$A a member class : true
    
  14. boolean isEnum() : este método devuelve verdadero si y solo si esta clase se declaró como una enumeración en el código fuente.
    Syntax : 
    public boolean isEnum() 
    Parameters : 
    NA
    Returns :
    true iff this class was declared as an enum in the source code.
    false,otherwise.
    

    // Java program to demonstrate isEnum() method
      
    enum Color
    {
        RED, GREEN, BLUE;
    }
       
    public class Test
    {
        public static void main(String[] args) 
        {   
            // returns the Class object associated with Color(an enum class)
            Class c1 = Color.class;
              
            // returns the Class object associated with Test class
            Class c2 = Test.class;
              
            // checking for Enum class
            // isEnum method
            boolean b1 = c1.isEnum();
            boolean b2 = c2.isEnum();
              
            System.out.println("is "+c1.toString()+" an Enum class : " + b1);
            System.out.println("is "+c2.toString()+" an Enum class : " + b2);
        }
    }

    Producción:

    is class Color an Enum class : true
    is class Test an Enum class : false
    
  15. boolean isAnnotation() : este método determina si este objeto Class representa un tipo de anotación. Tenga en cuenta que si este método devuelve verdadero, el método isInterface() también devolverá verdadero, ya que todos los tipos de anotaciones también son interfaces.
    Syntax : 
    public boolean isAnnotation() 
    Parameters : 
    NA
    Returns :
    return true if and only if this class represents an annotation type else return false
    

    // Java program to demonstrate isAnnotation() method
      
    // declaring an Annotation Type
    @interface A
    {
         // Annotation element definitions
    }
      
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // returns the Class object associated with A  annotation
            Class c1 = A.class;
      
            // returns the Class object associated with Test class
            Class c2 = Test.class;
              
            // checking for annotation type
            // isAnnotation method
            boolean b1 = c1.isAnnotation();
            boolean b2 = c2.isAnnotation();
              
            System.out.println("is "+c1.toString()+" an annotation  : " + b1);
            System.out.println("is "+c2.toString()+" an annotation : " + b2);
              
        }
    }

    Producción:

    is interface A an annotation  : true
    is class Test an annotation : false
    
  16. String getName() : este método devuelve el nombre de la entidad (clase, interfaz, clase de array, tipo primitivo o vacío) representada por este objeto Class, como una string.
    Syntax : 
    public String getName()
    Parameters : 
    NA
    Returns :
    returns the name of the name of the entity 
    represented by this object.
    

    // Java program to demonstrate getName() method
    public class Test
    {
        public static void main(String[] args) 
        {
            // returns the Class object associated with Test class
            Class c = Test.class;
              
            System.out.print("Class Name associated with c : ");
      
            // returns the name of the class
            // getName method
            System.out.println(c.getName());
        }
    }

    Producción:

    Class Name associated with c : Test
    
  17. String getSimpleName() : este método devuelve el nombre de la clase subyacente tal como se indica en el código fuente. Devuelve una string vacía si la clase subyacente es una clase anónima.

    El nombre simple de una array es el nombre simple del tipo de componente con «[]» adjunto. En particular, el nombre simple de una array cuyo tipo de componente es anónimo es «[]».

    Syntax : 
    public String getSimpleName()
    Parameters : 
    NA
    Returns :
    the simple name of the underlying class
    

    // Java program to demonstrate getSimpleName() method
    public class Test
    {
        public static void main(String[] args) 
                throws ClassNotFoundException 
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.String");
      
            System.out.print("Class Name associated with c : ");
              
            // returns the name of the class
            // getName method
            System.out.println(c1.getName());
      
            System.out.print("Simple class Name associated with c : ");
              
            // returns the simple name of the class
            // getSimpleName method
            System.out.println(c1.getSimpleName());
        }
    }

    Producción:

    Class Name associated with c : java.lang.String
    Simple class Name associated with c : String
    
  18. ClassLoader getClassLoader() : este método devuelve el cargador de clases para esta clase. Si el cargador de clases es un cargador de clases de arranque, este método devolvió un valor nulo, ya que el cargador de clases de arranque se implementa en lenguajes nativos como C, C++.
    Si este objeto representa un tipo primitivo o vacío, también se devuelve nulo.
    Syntax : 
    public ClassLoader getClassLoader()
    Parameters : 
    NA
    Returns :
    the class loader that loaded the class or interface represented by this object
    represented by this object.
    Throws :
    SecurityException - If a security manager and its checkPermission method 
    denies access to the class loader for the class.
    

    // Java program to demonstrate getClassLoader() method
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // returns the Class object for this class
            Class myClass = Class.forName("Test");
              
              
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.String");
              
            // returns the Class object for primitive int
            Class c2 = int.class;
              
            System.out.print("Test class loader : ");
              
            // getting the class loader for Test class
            // getClassLoader method on myClass
            System.out.println(myClass.getClassLoader());
              
            System.out.print("String class loader : ");
              
            // getting the class loader for String class
            // we will get null as String class is loaded
            // by BootStrap class loader
            // getClassLoader method on c1
            System.out.println(c1.getClassLoader());     
              
            System.out.print("primitive int loader : ");
              
            // getting the class loader for primitive int
            // getClassLoader method on c2
            System.out.println(c2.getClassLoader());
        }
    }

    Producción:

    Test class loader : sun.misc.Launcher$AppClassLoader@73d16e93
    String class loader : null
    primitive int loader : null
    
  19. TypeVariable<Class<T>>[ ] getTypeParameters() : este método devuelve una array de objetos TypeVariable que representan las variables de tipo declaradas por la declaración genérica representada por este objeto GenericDeclaration , en orden de declaración
    Syntax : 
    public TypeVariable<Class<T>>[] getTypeParameters()
    Specified by:
    getTypeParameters in interface GenericDeclaration
    Parameters : 
    NA
    Returns :
    an array of TypeVariable objects that represent the type variables declared 
    by this generic declaration represented by this object.
    Throws :
    GenericSignatureFormatError - if the generic signature of this generic declaration 
    does not conform to the format specified in JVM.
    

    // Java program to demonstrate getTypeParameters() method
      
    import java.lang.reflect.TypeVariable;
      
    public class Test
    {
        public static void main(String[] args)
                             throws ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c = Class.forName("java.util.Set");
              
            // getting array of TypeVariable for myClass object
            // getTypeParameters method
            TypeVariable[] tv = c.getTypeParameters();
              
            System.out.println("TypeVariables in "+c.getName()+" class : ");
              
            // iterating through all TypeVariables
            for (TypeVariable typeVariable : tv)
            {
                System.out.println(typeVariable);
            }
              
        }
    }

    Producción:

    TypeVariables in java.util.Set class : 
    E
    
  20. Clase<? super T> getSuperclass() : Este método devuelve la Clase que representa la superclase de la entidad (clase, interfaz, tipo primitivo o vacío) representada por esta Clase.
    Si esta clase representa la clase de objeto, una interfaz, un tipo primitivo o un vacío, se devuelve un valor nulo.
    Si este objeto representa una clase de array, se devuelve el objeto Class que representa la clase Object.
    Syntax : 
    public Class<? super T> getSuperclass() 
    Parameters : 
    NA
    Returns :
    the superclass of the class represented by this object
    

    // Java program to demonstrate getSuperclass() method
      
    // base class
    class A
    {
        // methods and fields
    }
      
    // derived class
    class B extends A
    {
          
    }
      
    // Driver class
    public class Test
    {
        public static void main(String[] args) 
                throws ClassNotFoundException 
          
        {
            // returns the Class object associated with Test class
            Class myClass = Test.class;
              
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("A");
            Class c2 = Class.forName("B");
            Class c3 = Class.forName("java.lang.Object");
              
            // getSuperclass method returns the superclass of the class represented 
            // by this class object 
              
            System.out.print("Test superclass : ");
              
            // getSuperclass method on myClass
            System.out.println(myClass.getSuperclass());
              
            System.out.print("A superclass : ");
              
            // getSuperclass method on c1
            System.out.println(c1.getSuperclass());
              
            System.out.print("B superclass : ");
              
            // getSuperclass method on c2
            System.out.println(c2.getSuperclass());
              
            System.out.print("Object superclass : ");
              
            // getSuperclass method on c3
            System.out.println(c3.getSuperclass());
        }
    }

    Producción:

    Test superclass : class java.lang.Object
    A superclass : class java.lang.Object
    B superclass : class A
    Object superclass : null
    
  21. Type getGenericSuperclass() : este método devuelve el tipo que representa la superclase directa de la entidad (clase, interfaz, tipo primitivo o vacío) representada por esta clase.

    Si esta clase representa la clase de objeto, una interfaz, un tipo primitivo o un vacío, se devuelve un valor nulo. Si este objeto representa una clase de array, se devuelve el objeto Class que representa la clase Object.

    Syntax : 
    public Type getGenericSuperclass()
    Parameters : 
    NA
    Returns :
    the superclass of the class represented by this object
    Throws:
    GenericSignatureFormatError - if the generic class signature does not conform to the format 
    specified in JVM
    TypeNotPresentException - if the generic superclass refers to a non-existent 
    type declaration MalformedParameterizedTypeException - if the generic 
    superclass refers to a parameterized type
    that cannot be instantiated for any reason
    

    // Java program to demonstrate 
    // getGenericSuperclass() method
    public class Test
    {
        public static void main(String[] args) 
                throws ClassNotFoundException 
          
        {
            // returns the Class object associated with Test class
            Class myClass = Test.class;
              
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.util.ArrayList");
            Class c3 = Class.forName("java.lang.Object");
              
            // getGenericSuperclass method returns the generic 
            // superclass of the class represented 
            // by this class object 
              
            System.out.print("Test superclass : ");
              
            // getGenericSuperclass method on myClass
            System.out.println(myClass.getGenericSuperclass());
              
            System.out.print("ArrayList superclass : ");
              
            // getGenericSuperclass method on c1
            System.out.println(c1.getGenericSuperclass());
              
            System.out.print("Object superclass : ");
              
            // getGenericSuperclass method on c3
            System.out.println(c3.getGenericSuperclass());
        }
    }

    Producción:

    Test superclass : class java.lang.Object
    Set superclass : java.util.AbstractList<E>
    Object superclass : null
    
  22. Class<?>[] getInterfaces() : este método devuelve las interfaces implementadas por la clase o interfaz representada por este objeto.

    Si este objeto representa una clase o interfaz que no implementa interfaces, el método devuelve una array de longitud 0.
    Si este objeto representa un tipo primitivo o vacío, el método devuelve una array de longitud 0.

    Syntax : 
    public Class<?>[] getInterfaces()
    Parameters : 
    NA
    Returns :
    an array of interfaces implemented by this class.
    

    // Java program to demonstrate getInterfaces() method
      
    // base interface
    interface A
    {
        // methods and constant declarations
    }
      
    // derived class
    class B implements A
    {
        // methods implementations that were declared in A
    }
      
    // Driver class
    public class Test
    {
        public static void main(String[] args) 
                throws ClassNotFoundException 
          
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("B");
            Class c2 = Class.forName("java.lang.String");
              
            // getInterface method on c1
            // it returns the interfaces implemented by B class
            Class c1Interfaces[] = c1.getInterfaces();
              
            // getInterface method on c2
            // returns the interfaces implemented by String class
            Class c2Interfaces[] = c2.getInterfaces();
              
              
            System.out.println("interfaces implemented by B class : ");
              
            // iterating through B class interfaces
            for (Class class1 : c1Interfaces) 
            {
                System.out.println(class1);
            }
              
              
            System.out.println("interfaces implemented by String class : ");
              
            // iterating through String class interfaces
            for (Class class1 : c2Interfaces) 
            {
                System.out.println(class1);
            }
        }
    }

    Producción:

    interfaces implemented by B class : 
    interface A
    interfaces implemented by String class : 
    interface java.io.Serializable
    interface java.lang.Comparable
    interface java.lang.CharSequence
    
  23. Type[] getGenericInterfaces() : este método devuelve los tipos que representan las interfaces implementadas directamente por la clase o interfaz representada por este objeto.

    Si este objeto representa una clase o interfaz que no implementa interfaces, el método devuelve una array de longitud 0.
    Si este objeto representa un tipo primitivo o vacío, el método devuelve una array de longitud 0.

    Syntax : 
    public Type[] getGenericInterfaces()
    Parameters : 
    NA
    Returns :
    an array of interfaces implemented by this class
    Throws:
    GenericSignatureFormatError - if the generic class signature does not conform to the format 
    specified in JVM
    TypeNotPresentException - if the generic superinterfaces refers to 
    a non-existent type declaration MalformedParameterizedTypeException - if the
    generic superinterfaces refers to a parameterized type
    that cannot be instantiated for any reason
    

    // Java program to demonstrate getGenericInterfaces() method
      
    import java.lang.reflect.Type;
      
    public class Test
    {
        public static void main(String[] args) 
                throws ClassNotFoundException 
          
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.util.Set");
              
            // getGenericInterfaces() on c1
            // it returns the interfaces implemented by Set interface
            Type c1GenericInterfaces[] = c1.getGenericInterfaces();
              
            System.out.println("interfaces implemented by Set interface : ");
              
            // iterating through Set class interfaces
            for (Type type : c1GenericInterfaces)
            {
                System.out.println(type);
            }
        }
    }

    Producción:

    interfaces implemented by Set interface : 
    java.util.Collection<E>
    
  24. Package getPackage() : este método devuelve el paquete para esta clase. El subsistema del cargador de clases en JVM Architecture usó este método para encontrar el paquete de una clase o interfaz.
    Syntax : 
    public Package getPackage()
    Parameters : 
    NA
    Returns :
    the package of the class, 
    or null if no package information is available
    from the archive or codebase. 
    

    // Java program to demonstrate getPackage() method
    public class Test
    {
        public static void main(String[] args) throws ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.String");
            Class c2 = Class.forName("java.util.ArrayList");
              
            // getting package of class
      
            // getPackage method on c1
            System.out.println(c1.getPackage());
      
            // getPackage method on c2
            System.out.println(c2.getPackage());
      
        }
    }

    Producción:

    package java.lang, Java Platform API Specification, version 1.8
    package java.util, Java Platform API Specification, version 1.8
    
  25. Field[] getFields() : este método devuelve una array de objetos Field que reflejan todos los campos públicos accesibles de la clase (y de todas sus superclases) o interfaz (y de todas sus superclases) representados por este objeto Class.
    Syntax : 
    public Field[] getFields()  throws SecurityException
    Parameters : 
    NA
    Returns :
    the array of Field objects representing the public fields
    and  array of length 0 if the class or interface has no accessible public fields
    or if this Class object represents a primitive type or void.
    Throws :
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate getFields() method
      
    import java.lang.reflect.Field;
      
    public class Test
    {
        public static void main(String[] args) 
                throws SecurityException,ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Integer");
              
            // getFields method on c1
            // it array of fields of Integer class
            Field F[] = c1.getFields();
              
            System.out.println("Below are the fields of Integer class : ");
              
            // iterating through all fields of  String class
            for (Field field : F) 
            {
                    System.out.println(field);
            
        }
    }

    Producción :

    Below are the fields of Integer class :
    public static final int java.lang.Integer.MIN_VALUE
    public static final int java.lang.Integer.MAX_VALUE
    public static final java.lang.Class java.lang.Integer.TYPE
    public static final int java.lang.Integer.SIZE
    public static final int java.lang.Integer.BYTES
    
  26. Class<?>[ ] getClasses() : este método devuelve una array que contiene objetos Class que representan todas las clases e interfaces públicas que son miembros de la clase representada por este objeto Class. La array contiene miembros de clase pública e interfaz heredados de superclases y miembros de clase pública e interfaz declarados por la clase.

    Este método devuelve una array de longitud 0 si este objeto Class no tiene interfaces ni clases de miembros públicos.
    Este método también devuelve una array de longitud 0 si este objeto Class representa un tipo primitivo, una clase de array o un vacío.

    Syntax : 
    Class<?>[ ] getClasses()
    Parameters : 
    NA
    Returns :
    the array of Class objects representing the public members of this class
    Throws :
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate getClasses() method
      
    public class Test
    {
        // base interface
        public interface A
        {
            // methods and constant declarations
        }
      
        // derived class
        public class B implements A
        {
            // methods implementations that were declared in A
        }
          
        public static void main(String[] args) 
                throws ClassNotFoundException 
          
        {
            // returns the Class object associated with Test class
            Class c1 = Test.class;
              
            // getClasses method on c1
            // it returns the array of Class objects containing the all 
            // public classes and interfaces  represented by Test class
            Class[] c1Classes = c1.getClasses();
              
            System.out.println("public members of Test class : ");
              
            // iterating through all public members of Test class
            for (Class class1 : c1Classes)
            {
                System.out.println(class1);
            }
              
        }
    }

    Producción:

    public members of Test class : 
    interface Test$A
    class Test$B
    
  27. Method[] getMethods() : este método devuelve una array de objetos Method que reflejan todos los métodos públicos accesibles de la clase o interfaz y los heredados de superclases y superinterfaces representados por este objeto Class.
    Syntax : 
    public Method[] getMethods() throws SecurityException
    Parameters : 
    NA
    Returns :
    the array of Method objects representing the public methods
    and  array of length 0 if the class or interface has no accessible public method
    or if this Class object represents a primitive type or void.
    Throws :
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate getMethods() method
      
    import java.lang.reflect.Method;
      
    public class Test
    {
        public static void main(String[] args) 
                throws SecurityException,ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Object");
              
            // getMethods method on c1
            // it returns array of methods of Object class
            Method M[] = c1.getMethods();
              
            System.out.println("Below are the methods of Object class : ");
              
            // iterating through all methods of Object class
            for (Method method : M) 
            {
            System.out.println(method);
            }
        }
    }

    Producción:

    Below are the methods of Object class : 
    public final void java.lang.Object.wait() throws java.lang.InterruptedException
    public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
    public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
    public boolean java.lang.Object.equals(java.lang.Object)
    public java.lang.String java.lang.Object.toString()
    public native int java.lang.Object.hashCode()
    public final native java.lang.Class java.lang.Object.getClass()
    public final native void java.lang.Object.notify()
    public final native void java.lang.Object.notifyAll()
    
  28. Constructor<?>[] getConstructors() : este método devuelve una array de objetos Constructor que refleja todos los constructores públicos de la clase representada por este objeto Class.
    Syntax : 
    public Constructor<?>[] getConstructors() throws SecurityException
    Parameters : 
    NA
    Returns :
    the array of Constructor objects representing the public constructors of this class
    and  array of length 0 if the class or interface has no accessible public constructor
    or if this Class object represents a primitive type or void.
    Throws :
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate getConstructors() method
      
    import java.lang.reflect.Constructor;
      
    public class Test
    {
        public static void main(String[] args) 
                throws SecurityException,ClassNotFoundException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Boolean");
              
            // getConstructor method on c1
            // it returns an array of constructors of Boolean class
            Constructor C[] = c1.getConstructors();
              
            System.out.println("Below are the constructors of Boolean class :");
              
            // iterating through all constructors
            for (Constructor constructor : C) 
            {
            System.out.println(constructor);
            }
        }
    }

    Producción:

    Below are the constructors of Boolean class :
    public java.lang.Boolean(boolean)
    public java.lang.Boolean(java.lang.String)
    
  29. Field getField(String fieldName) : este método devuelve un objeto Field que refleja el campo miembro público especificado de la clase o interfaz representada por este objeto Class.
    Syntax : 
    public Field getField(String fieldName) throws NoSuchFieldException,SecurityException
    Parameters : 
    fieldName -  the field name
    Returns :
    the Field object of this class specified by name
    Throws :
    NoSuchFieldException - if a field with the specified name is not found.
    NullPointerException - if fieldName is null
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate getField() method
      
    import java.lang.reflect.Field;
      
    public class Test
    {
        public static void main(String[] args) 
                throws SecurityException,ClassNotFoundException,
                       NoSuchFieldException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Integer");
              
            // getField method on c1
            // it checks a public field in Integer class with specified parameter
            Field f = c1.getField("MIN_VALUE");
              
            System.out.println("public field in Integer class with MIN_VALUE name :");
            System.out.println(f);
        }
    }

    Producción:

    public field in Integer class with MIN_VALUE name :
    public static final int java.lang.Integer.MIN_VALUE
    
  30. Método getMethod(String nombreMétodo,Clase… tipos deparámetros) : Este método devuelve un objeto Método que refleja el método de miembro público especificado de la clase o interfaz representada por este objeto Clase.
    Syntax : 
    public Method getMethod(String methodName,Class... parameterTypes) throws 
    NoSuchFieldException,SecurityException
    Parameters : 
    methodName -  the method name
    parameterTypes - the list of parameters
    Returns :
    the method object of this class specified by name
    Throws :
    NoSuchMethodException - if a method with the specified name is not found.
    NullPointerException - if methodName is null
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate getMethod() method
      
    import java.lang.reflect.Method;
      
    public class Test
    {
        public static void main(String[] args) 
                throws SecurityException,ClassNotFoundException,
                       NoSuchMethodException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Integer");
            Class c2 = Class.forName("java.lang.String");
              
            // getMethod method on c1
            // it checks for a public Method in Integer class
            Method m = c1.getMethod("parseInt",c2);
              
            System.out.println("method in Integer class specified by parseInt : ");
            System.out.println(m);
        }
    }

    Producción:

    public method in Integer class specified by parseInt : 
    public static int java.lang.Integer.parseInt(java.lang.String) 
    throws java.lang.NumberFormatException
    
  31. Constructor<?> getConstructor(Class<?>… ParameterTypes) : este método devuelve un objeto Constructor que refleja el constructor público especificado de la clase representada por este objeto Class. El parámetro ParameterTypes es una array de objetos Class que identifican el parámetro formal del constructor. tipos, en orden declarado.
    Syntax : 
    public Constructor<?> getConstructor(Class<?>... parameterTypes) 
    throws NoSuchMethodException,SecurityException
    Parameters : 
    parameterTypes - the list of parameters
    Returns :
    the Constructor object of the public constructor that matches the specified parameterTypes
    Throws :
    NoSuchMethodException - if a Constructor with the specified parameterTypes is not found.
    SecurityException - If a security manager, s, is present.
    

    // Java program to demonstrate 
    // getConstructor() Constructor
      
    import java.lang.reflect.Constructor;
      
    public class Test
    {
        public static void main(String[] args) 
                throws SecurityException,ClassNotFoundException,
                    NoSuchMethodException
        {
            // returns the Class object for the class 
            // with the specified name 
            Class c1 = Class.forName("java.lang.Integer");
            Class c2 = Class.forName("java.lang.String");
              
            // getConstructor method on c1
            // it checks a public Constructor in Integer class
            // with specified parameterTypes
            Constructor c = c1.getConstructor(c2);
              
            System.out.println("Constructor in Integer class & String parameterType:");
            System.out.println(c);
        }
    }

    Producción:

    public Constructor in Integer class with String parameterType : 
    public java.lang.Integer(java.lang.String) throws java.lang.NumberFormatException
    
  32. Nota: Los métodos getFields(), getMethods(), getConstructors(), getField(), getMethod(), getConstructor() son ampliamente utilizados en Reflection (Consulte esto por ejemplo)

  33. T cast(Object obj) : este método se usa para convertir un objeto a la clase o interfaz representada por este objeto Class.
    Syntax : 
    public T cast(Object obj)
    TypeParameters : 
    T - The class type whose object is to be cast
    Parameters : 
    obj - the object to be cast
    Returns :
    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. 
    

    // Java program to demonstrate cast() method
    class A
    {
       // methods and fields
    }
      
    class B extends
    {
        // methods and fields
    }
      
    // Driver Class
    public class Test
    {
        public static void main(String[] args) 
        {
            A a = new A();   
              
            System.out.println(a.getClass());
              
            B b = new B();
              
            // casting b to a
            // cast method
            a = A.class.cast(b);
         
            System.out.println(a.getClass());
          
        }
    }

    Producción:

    class A
    class B
    
  34. <U> Clase<? extends U> asSubclass(Class<U> clazz) : este método se usa para convertir este objeto de clase para representar una subclase de la clase representada por el objeto de clase especificado. Siempre devuelve una referencia a este objeto de clase.
    Syntax : 
    public <U> Class<? extends U> asSubclass(Class<U> class)
    TypeParameters : 
    U - The superclass type whose object is to be cast
    Parameters : 
    clazz - the superclass object to be cast
    Returns :
    this Class object, cast to represent a subclass of the specified class object.
    Throws :
    ClassCastException - if this Class object does not represent a 
    subclass of the specified class
    (here "subclass" includes the class itself).
    

    // Java program to demonstrate asSubclass() method
    class A
    {
       // methods and fields
    }
      
    class B extends
    {
        // methods and fields
    }
      
    // Driver Class
    public class Test
    {
        public static void main(String[] args) 
        {
            A a = new A();   
              
            // returns the Class object for super class(A)
            Class superClass = a.getClass();
              
            B b = new B();
              
            // returns the Class object for subclass(B)
            Class subClass = b.getClass();
              
            // asSubclass method
            // it represent a subclass of the specified  class object
            Class cast = subClass.asSubclass(superClass);
              
            System.out.println(cast);
          
        }
    }

    Producción:

    class B
    
  35. Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

    Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *