El método getGenericExceptionTypes() de la clase de método java.lang.reflect devuelve una array de objetos de tipo que representan excepciones lanzadas por el objeto de método para manejar la excepción. Todas las excepciones manejadas por el método que usa la cláusula throw se devuelven como una array de objetos Type usando este método. Este método devuelve una array de longitud 0, si el método en el que se aplica este método no declara excepciones en su cláusula throws .
Ejemplo:
Code:
public class demo{
public void setValue(String value)
throws ClassNotFoundException, ArrayIndexOutOfBoundsException,
ArithmeticException {}
}
Explanation:
In the above method when we going to apply getGenericExceptionTypes() method
it is going to return array of the exception types.
Array = {
java.lang.ClassNotFoundException,
java.lang.ArrayIndexOutOfBoundsException,
java.lang.ArithmeticException,
}
Sintaxis:
public Type[] getGenericExceptionTypes()
Valor devuelto: Devuelve una array de los tipos de excepción lanzados por el objeto de este método
Excepción: este método arroja las siguientes excepciones:
- GenericSignatureFormatError : si la firma del método genérico no es la misma que el formato especificado en la especificación JVM.
- TypeNotPresentException : si los tipos de excepción especificados por la cláusula throws hacen referencia a una declaración de tipo inexistente.
- MalformedParameterizedTypeException : si la cláusula throws del ejecutable subyacente hace referencia a un tipo parametrizado del que no se puede crear una instancia por ningún motivo.
Los siguientes programas ilustran el método getGenericExceptionTypes() de la clase Method:
Programa 1: imprima todos los tipos de excepción lanzados por un método con la ayuda de getGenericExceptionTypes()
/*
* Program Demonstrate how to apply
* getGenericExceptionTypes() method
*/
import java.lang.reflect.Method;
import java.lang.reflect.Type;
public class GFG {
// Main method
public static void main(String[] args)
{
try {
// create class object
Class classobj = demoClass.class;
// create parameter type of string
Class[] parameterTypes = { String.class };
// get list of method objects
Method[] methods = classobj.getMethods();
// loop through all methods
for (Method m : methods) {
if (m.getName().equals("setValue")
|| m.getName().equals("getValue")) {
// apply getGenericExceptionTypes() method
Type[] genericExceptions = m.getGenericExceptionTypes();
// print exception Types thrown by method Object
System.out.println("Generic Exception Thrown by Method: "
+ m.getName());
System.out.println("Generic Exception Type Array length: "
+ genericExceptions.length);
// If method has Exception then print
if (genericExceptions.length > 0) {
System.out.println("Exception class object details:");
for (Type type : genericExceptions) {
System.out.println(type.getTypeName());
}
}
System.out.println();
}
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
// a simple class
class demoClass {
String value;
// throw some exception by method
public void setValue(String value)
throws ClassNotFoundException,
ArrayIndexOutOfBoundsException,
ArithmeticException
{
this.value = value;
}
// method throwing no exception
public String getValue()
{
return this.value;
}
}
Generic Exception Thrown by Method: getValue Generic Exception Type Array length: 0 Generic Exception Thrown by Method: setValue Generic Exception Type Array length: 3 Exception class object details: java.lang.ClassNotFoundException java.lang.ArrayIndexOutOfBoundsException java.lang.ArithmeticException
Programa 2: buscar una excepción específica
/*
* Program Demonstrate how to
* apply getGenericExceptionTypes() method
*/
import java.lang.reflect.Method;
import java.lang.reflect.Type;
public class GFG {
// a simple class
class GFGSampleClass {
String value;
// throw some exception by method
public void setValue(String value)
throws ClassNotFoundException,
ArrayIndexOutOfBoundsException,
ArithmeticException
{
this.value = value;
}
}
// Main method
public static void main(String[] args)
{
try {
// create class object
Class classobj = GFGSampleClass.class;
// get list of method objects
Method[] methods = classobj.getMethods();
// get Method Object for setValue
Method method = null;
for (Method m : methods) {
if (m.getName().equals("setValue"))
method = m;
}
// check whether method throw
// ArithmeticException Exception
Type airthmeticExClassobj = ArithmeticException.class;
boolean response = isCertainExceptionIsThrown(method,
airthmeticExClassobj);
System.out.println("ArithmeticException"
+ " is thrown by setValue(): " + response);
// check whether method throw
// IndexOutOfBoundsException Exception
Type exceptionObj = IndexOutOfBoundsException.class;
response = isCertainExceptionIsThrown(method,
exceptionObj);
System.out.println("IndexOutOfBoundsException"
+ " is thrown by setValue(): " + response);
}
catch (Exception e) {
e.printStackTrace();
}
}
/*
* Return true if the given method throws the
* exception passed AS Parameter.
*/
private static boolean
isCertainExceptionIsThrown(Method method, Type exceptionName)
{
// get all exception list using getGenericExceptionTypes()
Type exceptions[] = method.getGenericExceptionTypes();
for (int i = 0; i < exceptions.length; i++) {
// check exception thrown or not
if (exceptions[i] == exceptionName) {
return true;
}
}
return false;
}
}
ArithmeticException is thrown by setValue(): true IndexOutOfBoundsException is thrown by setValue(): false
Referencia:
https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#getGenericExceptionTypes–
Publicación traducida automáticamente
Artículo escrito por AmanSingh2210 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA