CODEWITHSUNDEEP
javaexception
user866190
user866190

Reputation: 863

High Level Overview Of Throwing Exceptions In Java

I am a little bit confused with exceptions in Java and when to use which particular style of implementation.

I used IllegalArgumentException as an example, but the main point I would like to address is when does one throw, extends or throw new exception?

Also as an additional point I have an assignment where I have to create a java class and the spec vaguely states that the constructor should throw an IllegalArgumentException so which one would be the best to use?

public class Test{

    //when does one use this type of exception
    public Test(String yourName) throws IllegalArgumentException{
      //code implemented
    }

    //when does one use this type of exception
    public Test(String yourName) extends IllegalArgumentException{
      //code implemented
    }

    public Test(String yourName){

         if(yourName.length() <= 0){
             //why not use this type of exception instead 
             //and what happens when I use this type of exception
             throw new IllegalArgumentException("Please Enter Your Name..!");
         }
    }

}

Thanks in advance.

Upvotes: 1

Views: 1183

Answers (3)

scadge
scadge

Reputation: 9723

When some Exception occurs, you have two ways of handling it: doing throws from the method or doing try-catch. The first one looks like this:

public class MyClass {
    public void myMethod() throws IllegalArgumentException {
        someOtherMethod();
    }
}

In this case you know that someOtherMethod() can throw an exception and you don't want to handle it - you just pass it further. After that, the invoker of myMethod() should take care of the Exception.

But the second way is when you handle it by yourself:

public void myMethod()  {
    try {
        someOtherMethod();
    } catch (Exception e) {
        System.out.println("You've got an exception!");
    }
}

About throwing exceptions manually - you may suppose that you do it in someOtherMethod(). When you do throw new IllegalArgumentException("Please Enter Your Name..!"); the program stops with a message about this exception (unless you handle it in a try-catch way).

And at last, you extend some exception, when you create your own Exception class:

class MyException extends IllegalArgumentException {
    ...
}

In this case you may do throw new MyException(); in your code.

I'd advise you to read more about exceptions in Java to understand what is going on. You may start with this lesson.

Upvotes: 1

Peter Lawrey
Peter Lawrey

Reputation: 533492

I would only create a new exception type when you need to. You need a new type when you expect the caller to have catch clause for your new exception.

you can create new exceptions just to be more descriptive but that is what I use the message for.

Upvotes: 0

Sanjay T. Sharma
Sanjay T. Sharma

Reputation: 23208

To ensure that you don't end up creating exceptions which already have equivalent in the standard library, I normally have a peek at the documentation before creating new exceptions. Also, it's very easy to go crazy with really big exception hierarchies if you are not careful. Don't create new exceptions just because you think you need to throw one somehow; create one because a code somewhere down the call stack would be doing something useful/different with that exception.

public Test(String yourName) throws IllegalArgumentException

You normally never specify runtime exception in the throws clause though it might be helpful if you need this information to be part of the public API.

public Test(String yourName) extends IllegalArgumentException

This doesn't look right and isn't valid Java.

Upvotes: 0

Related Questions