getCause() method

[Suresh KumarPandey]

package com.suresh.blog;

class WrongLengthException extends Exception{
   static String message;
	
	public WrongLengthException(){
		
	}
	
	public WrongLengthException(String message){
		
		
		this.message=message;
	}
	
	public WrongLengthException(Throwable cause){
		super(cause);
	}


public String getMessage(){
	return message;
}

}
class Test  {
	
	int length;
	public static void main(String []args) {
		Test test=new Test();
		
	test.length=20;
	
	if(test.length > 12){
		try {
			
			throw new WrongLengthException("length should be less than 12");
			
		} catch (WrongLengthException e) {
			// TODO Auto-generated catch block
			System.out.println(e.getCause()+" : and reason is "+e.getMessage());
		}
	}

can anybody tell whether it is possible to add cause in this class. Right now getCause() is fetching null.

[Kondwani Chipeta]

Hello Suaresh,

Please Use Code tags when posting on the forum, it makes your post easier to read.


On your query, if you read the javadoc for the Throwable class, you will see that the getCause() method returns null if the cause is nonexistent or unknown.

I recommend that you override the initCause() method from the Throwable class in your WrongLengthException class and return an appropriate Throwable.



Kondwani.

[Matthew Brown]

I wouldn't bother doing that.

getCause() is used for chained exceptions, where you have one wrapped inside another - it represents the exception that was the underlying cause. In this case there is no underlying cause, so it correctly returns null.

What would you want it to return? If you want a description of what has gone wrong, that's what the message is for.

[Chan Ag]

Your Exception has the cause as null. Hence it is printing null. Notice the constructor in the Throwable interface class that takes a Throwable and the one that takes a message and a Throwable. If you do not construct your Exception object by passing it a Throwable argument, the cause will be null.

getCause method is generally helpful when you wrap one exception into another. Like for example-

try
{
   // code that throws some exception say Exception1
}
catch(Exception1 e)
{
 // wrap e in another type of exception say Exception2
 throw new Exception2(e) 
 //throw new Exception2(e.getMessage(), e); // use this if you want to retain this message also.
}

The calling code can have

catch(Exception2 e)
{
 System.out.println(e.getCause()+" : and reason is "+e.getMessage()); 
}

This should now print something like
Exception1 : and the reason is null.

If you want the message also, in the constructor parameters, you need to provide both - the message ( String ) and the Throwable and need to pass both of them as parameter while throwing the new Exception.

However, it is not advisable to wrap one exception into another unless there is a good reason to do so.

Note that you can also make use of the initCause method but for your case I don't think that is necessary.

[Surinder Mehra]

getCause() is used with chained Exceptions as Matthew said. If you want to print the cause modify your main method like below:

	public static void main(String[] args) throws Exception {
		TestException test = new TestException();

		test.length = 20;

		if (test.length > 12) {
			try {

				throw new WrongLengthException("length should be less than 12");

			} catch (WrongLengthException e) {
				throw new Exception(e);
			}
		}
	}

This will print the actual cause of Exception

[Chan Ag]

Whoever has given a thumbs up to my post, please note that Throwable is a class, not an interface.

I have edited my response with a strikethrough.