Create Java Exception subclass to present custom message

I have security package in which the class files share the common Exceptions:

	catch (InvalidKeyException | NoSuchAlgorithmException e) {
      		System.err.println("Key Exception: Invalid key is detected to sign or verify signature." + " \n");
      	} catch (UnrecoverableKeyException e) {
      		System.err.println("Key Exception: Faulty key can not be used to sign signature." + " \n");
      	} catch (KeyStoreException e) {
	        System.err.println("KeyStore Exception: key Store may be faulty." + " \n");
……………

I attempt the DSCoreException which can throw back custom descriptive messages based on the object's getLocalizedMessage() result, excluding the exception class name.
The gist of the implementation is:

catch (Exception e) {
  throw new DSCoreException(e);
} 
…………………..
class DSCoreException extends Exception {
  DSCoreException(Exception s) { 
    	super(s.getLocalizedMessage());
    	if (super.getLocalizedMessage().contains("Signature not available")) {
    		System.err.println("Key Exception: Invalid key algorithm is used to sign signature." + " \n");
    	}
}

It produces:

Key Exception: Invalid key algorithm is used to sign signature. 

Exception in thread "main" com.fc.security.DSCoreException: SHA512withDSA Signature not available
	at com.fc.security.TestException.main(TestException.java:91)

My expectation is:

Key Exception: Invalid key algorithm is used to sign signature. 

How can I display only my custom message? (There will be else-if following the if)

You have an Exception that prints messages. That is not the job of an Exception.

An Exception is supposed to provide enough information to describe the exception it's reporting. For example, it will typically have a message string.

If some code catches that Exception, it can (if it chooses) display the message string. But the Exception class never should.

Your exception class should look like:

 class DSCoreException extends Exception {
      DSCoreException(String msg) {
          super(msg);
      }
      ... more needed here ...
 }

and then maybe you have an exception handler to replace particular exceptions by your own exception.

  try {
      do_something_here();
  } 
  catch (Exception ex) {  // NOTE really ought to be a narrower class
      if (ex.getLocalizedMessage().contains("Signature not available"))             
          ex = new DSCoreException("Key Exception: Invalid key algorithm is used to sign signature."); 
      throw ex;
  }

You catch the exception, examine it to see what it is, and optionally replace it with a better exception before re-throwing it.

A slightly different twist, depending on your overall needs:

  try {
      do_something_here();
  } 
  catch (Exception ex) {  // NOTE really ought to be a narrower class
      String msg = ex.getLocalizedMessage();
      if (msg.contains("Signature not available"))             
          msg = "Key Exception: Invalid key algorithm is used to sign signature."; 
      throw new DSCoreException(msg);
  }

That one always throws a DSCoreException but possibly replaces the message. This converts all exceptions into 'your' class, which may have benefits to whoever is calling your code.

The underlying lesson here is that an exception is a control-flow device, not just a thing that prints errors. Even in the simple case where you intend to display the message, the exception is a way to get the error condition info to the code that is going to display it; the exception should not itself do the displaying.

An objection raised, in a comment now deleted, was that the catcher of an exception could obtain a stack trace and thereby reveal information such as package names. The OP apparently wants to prevent this, though I don't see why. That boils down to wanting an Exception to not behave like an Exception. You can't control this in any reasonable way.