Is it possible to gather multiple exceptions into one custom exception?

I have recurring exceptions that need to be thrown due to using the reflect API for refactoring reasons:

throws ApiException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException

These exceptions are always present in the method where I use the refactored methods, Is it possible to do
something like this instead:

throws CustomException

to handle all of the exceptions mentioned above?
Thanks

Yes. There are two ways to do this:

Class hierarchies

This one only applies if you are the one designing the exceptions. If that doesn't describe this case, move on to the next chapter.

If you have, say, a user authentication API, you would presumably want to create a whole bevy of exceptions such as UserNotFoundException, IncorrectPasswordException, UserFrozenException, IpBlockedException, and more.

If you make sure all those exceptions extend a single exception type (AuthenticationException), like so:

public class AuthenticationException extends Exception {
    public AuthenticationException(String msg, Throwable cause) {
        super(msg, cause);
    }

    public AuthenticationException(String msg) {
        super(msg);
    }
}

public class UserNotFoundException extends AuthenticationException {
    public UserNotFoundException(String username) {
        super(username);
    }
}

// and so on

then a caller can choose, which is why this makes for such a great API design.

IF a caller needs to have custom reactions depending on what kind of authentication problem occurs, they can catch, say, UserNotFoundException. But if they don't particularly care, they can catch AuthenticationException.

Note that java itself does this, too. GeneralSecurityException is the common superclass, and yet most security-related methods throw a sizable list of subclasses of this, so that callers know exactly what kind of errors can occur, and can write handlers for specific errors, without forcing them to write a ton of catch blocks if they don't want to.

rethrow

An alternate solution is that you bundle up exceptions into your own custom type.

To do this, first write an exception (or use an existing one, but that's rarely stylistically the right move). Then, write a catch block and wrap all those weird, unrelated exceptions into this newly created one, making sure to use the 'cause' system:

public class CustomException { // find a better name
    public CustomException(String msg, Throwable cause) {
        super(msg, cause);
    }

    public CustomException(String msg) {
        super(msg);
    }

    public CustomException(Throwable cause) {
        super(cause);
    }
}

public void myMethod() throws CustomException {
    try {
        // code here
    } catch (ApiException | ClassNotFoundException | NoSuchMethodException | IllegalAccessException e) {
        throw new CustomException(e);
    } catch (InvocationTargetException e) {
        throw new CustomException(e.getCause();
    }
}

but note how your suggestion that you just want to fire-and-forget is causing your API design to be problematic. For example, wrapping an InvocationTargetException like this is rather hostile to your API consumers; InvocationTargetException is itself a wrapper, so now you've got wrappers-in-wrappers-in-wrappers and that's just ugly and makes it real hard for calling code to even try to deal with problems in a pinpoint fashion. There really is no easy way around reading the APIs you use and understanding why it throws the various exceptions that it throws.

NB: If you can, the class hierarchies solution is a much better way to do this; but it does require that you are in control of the code that's throwing them.

Suppose you have:

void myMethod() throws ApiException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
          /// Your code here;
}

You can change it with:

void myMethod() throws CustomException {
       try {
          /// Your code here;
       } catch (ApiException | ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
         throw new CustomException(e);   // Make sure to have constructor initialized with cause.
       }
    }

E.g. CustomException class:

public class CustomException {
   CustomException(Throwable cause) {
      super(cause);
   }
}

ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException are all subclasses of ReflectiveOperationException, so you can simply reduce the exception list:

throws ApiException, ReflectiveOperationException

If you want to combine those 2 into a CustomException, just create one and use it:

public class CustomException extends Exception {
	private static final long serialVersionUID = -1006015659738896046L;

	public CustomException(Exception e) {
		super(e);
	}
	public CustomException(String msg, Exception e) {
		super(msg, e);
	}
}

void foo() throws CustomException {
	try {
		// your code here
	} catch (ApiException | ReflectiveOperationException e) {
		throw new CustomException(e);
	}
}

If you don't even want the throws CustomException, because you know the caller will never specifically catch it, change exception class to CustomException extends RuntimeException.