We Keep Coding

Make unhandled exception in Java break a program

Suppose we have a function that is deep in the call stack. This function does multiple operations and it calls 5 different functions that throw exceptions.
In C# I could leave these exceptions and be sure that if any of them is thrown then the program breaks. This is what I was hoping for here - these exceptions should stop the program. In Java I get errors at compile time. As far as I know I have 2 options:
Handle all of them and keep the program running. But as I said - I do want to break program and handling all of the exceptions might only make a mess in the code.
Make a function rethrow these exceptions. However if I did that so deep in the call stack I would need to make rethrows on every other level. That sounds like a really bad design.
To clear things out - I don't mean that I want to ignore every single exception. Many of them are logged etc. but ability to just leave an exception and be sure to get detailed error when a program breaks is very convenient in C#.
What can I do about that in Java?

In Java, you must handle checked exceptions, which is why you are seeing errors. This is enforced by the compiler. How you handle checked exceptions depends on the use-case.
The intention at the language level was probably that these exceptions could be recovered from. For instance, IO APIs typically throw checked exceptions.
If you want the application to crash, you need to catch and rethrow these exceptions or declare them with a throws. e.g.
void doStuff(String name) throws FileNotFoundException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(name));
.... do stuff
}
Alternately, you can re-throw the exception and wrap it in an unchecked exception:
void doStuff(String name) {
BufferedInputStream bis;
try {
bis = new BufferedInputStream(new FileInputStream(name));
} catch(FileNotFoundException e) {
throw new RuntimeException(e);
}
.... do stuff
}
As I said earlier, however, this is enforced by the compiler and, as a result, there is another way around it.
Lombok has a #SneakyThrows annotation which bypasses the compiler check.

This question was asked in 2020, so the OP has probably figured out what to do by now, but for future generations:
When a function that you call throws an exception, and you do not want to handle it, your only other option is not to rethrow it. Actually, rethrowing it would not buy you anything, because you would still get those "errors at compile time" that you spoke of.
So, here is what is happening:
In Java, there are two kinds of exceptions:
"checked" exceptions
"unchecked" exceptions
Unchecked exceptions work exactly as they do in C#: if some function in the call tree throws one, no other function in the call tree needs to be concerned about it until some function high up the tree that catches it and does something meaningful with it. (Remember, "Computer Science" trees are upside down, so "high up the tree" means "near the root".) Obviously, these are not the kind of exceptions that are giving you trouble.
Checked exceptions were a novelty that Java introduced back in the early nineties, and they were admittedly an interesting concept, but looking back now after a few decades we can say with certainty that they did not survive the test of time. Checked exceptions were already being seen by most programmers as an unnecessary hassle even before functional programming started gaining ground, and with the introduction of lambdas into the language, checked exceptions became nothing but an annoying relic of the past, since they are largely incompatible with lambdas. (For more on this, see the top 5 answers to this question: The case against checked exceptions) However, lots of classes that are built into the JDK throw these checked exceptions, so you need to know how to treat them. (I cannot say "how to handle them", because that word already has a very specific meaning in this discussion, and this is not the meaning I want here.)
Checked exceptions are essentially declared exceptions. This means that if a function may throw a certain checked exception, then the function must declare that it does so, in its signature, like this:
void myCoolFunction() throws MyCheckedException { ... }
The Java compiler prohibits checked exceptions from being thrown, or propagating through, functions that do not declare them. In other words:
If your method may potentially throw a checked exception, then your method must declare in its signature that it does so.
If your method invokes another method which may potentially throw a checked exception, and your method does not catch and handle that exception, then this is as good as your method potentially also throwing that checked exception, so your method must also declare in its signature that it may throw that exception.
This means that if myCoolerFunction() invokes myCoolFunction(), then myCoolerFunction() has to either catch and handle the exception, or also be declared with throws MyCheckedException. Note, however, that it does not need to catch it and rethrow it. As a matter of fact, if myCoolerFunction() rethrows the exception, then it is still obliged to declare in its signature that it throws that exception.
So, finally, the solution to the problem:
Your functions do not have to handle the checked exceptions thrown by functions they call, nor do they have to catch and rethrow anything; all they need to do is declare in their signatures that they also throw such exceptions.
If you find that to be too bureaucratic, you might find it as a consolation to hear that this is the Java way of doing things.
If you still find it too bureaucratic, then the solution you are looking for is conversion of checked exceptions to unchecked exceptions, which is essentially catching and rethrowing that actually works. It is done like this:
void myMethodWithoutCheckedExceptions()
{
try
{
myMethodThatThrowsACheckedException();
}
catch( MyCheckedException e )
{
throw new RuntimeException( e );
}
}
This wraps the checked exception inside a RuntimeException, which is not a checked exception, and therefore does not need to be declared in the signature of the method.
As Johannes Kuhn hinted at in a comment, it is even possible to avoid the wrapping, but this is really advanced, some would even say hacky stuff: Instead of throw new RuntimeException( e ); you can do throw sneakyException( e ); and then you can have the following method:
#SuppressWarnings( "unchecked" )
public static <T extends Throwable> RuntimeException sneakyException( Throwable t )
throws T
{
throw (T)t;
}
This trick leverages an unchecked type cast to fool the compiler into believing that the exception being thrown is not a checked exception. It works, because checked exceptions are a purely syntactic feature of the Java language, while the runtime does not know anything about them.
Note that my sneakyException() method which is declared to return a RuntimeException is better than the void-returning sneakyThrow() method suggested by Johannes Kuhn because sneakyException() allows you to use the throw keyword at the call site, thus indicating to the compiler that program flow will not proceed past that point, whereas sneakyThrow() does not return an exception that you can throw, therefore you cannot use the throw keyword at the call site, therefore the compiler might have no knowledge of the fact that sneakyThrow() never returns.

Why we can not add unchecked exceptions in the same way as checked exceptions [duplicate]

Joshua Bloch in "Effective Java" said that
Use checked exceptions for
recoverable conditions and runtime
exceptions for programming errors
(Item 58 in 2nd edition)
Let's see if I understand this correctly.
Here is my understanding of a checked exception:
try{
String userInput = //read in user input
Long id = Long.parseLong(userInput);
}catch(NumberFormatException e){
id = 0; //recover the situation by setting the id to 0
}
1. Is the above considered a checked exception?
2. Is RuntimeException an unchecked exception?
Here is my understanding of an unchecked exception:
try{
File file = new File("my/file/path");
FileInputStream fis = new FileInputStream(file);
}catch(FileNotFoundException e){
//3. What should I do here?
//Should I "throw new FileNotFoundException("File not found");"?
//Should I log?
//Or should I System.exit(0);?
}
4. Now, couldn't the above code also be a checked exception? I can try to recover the situation like this? Can I? (Note: my 3rd question is inside the catch above)
try{
String filePath = //read in from user input file path
File file = new File(filePath);
FileInputStream fis = new FileInputStream(file);
}catch(FileNotFoundException e){
//Kindly prompt the user an error message
//Somehow ask the user to re-enter the file path.
}
5. Why do people do this?
public void someMethod throws Exception{
}
Why do they let the exception bubble up? Isn't handling the error sooner better? Why bubble up?
6. Should I bubble up the exact exception or mask it using Exception?
Below are my readings
In Java, when should I create a checked exception, and when should it be a runtime exception?
When to choose checked and unchecked exceptions

Many people say that checked exceptions (i.e. these that you should explicitly catch or rethrow) should not be used at all. They were eliminated in C# for example, and most languages don't have them. So you can always throw a subclass of RuntimeException (unchecked exception)
However, I think checked exceptions are useful - they are used when you want to force the user of your API to think how to handle the exceptional situation (if it is recoverable). It's just that checked exceptions are overused in the Java platform, which makes people hate them.
Here's my extended view on the topic.
As for the particular questions:
Is the NumberFormatException consider a checked exception?
No. NumberFormatException is unchecked (= is subclass of RuntimeException). Why? I don't know. (but there should have been a method isValidInteger(..))
Is RuntimeException an unchecked exception?
Yes, exactly.
What should I do here?
It depends on where this code is and what you want to happen. If it is in the UI layer - catch it and show a warning; if it's in the service layer - don't catch it at all - let it bubble. Just don't swallow the exception. If an exception occurs in most of the cases you should choose one of these:
log it and return
rethrow it (declare it to be thrown by the method)
construct a new exception by passing the current one in constructor
Now, couldn't the above code also be a checked exception? I can try to recover the situation like this? Can I?
It could've been. But nothing stops you from catching the unchecked exception as well
Why do people add class Exception in the throws clause?
Most often because people are lazy to consider what to catch and what to rethrow. Throwing Exception is a bad practice and should be avoided.
Alas, there is no single rule to let you determine when to catch, when to rethrow, when to use checked and when to use unchecked exceptions. I agree this causes much confusion and a lot of bad code. The general principle is stated by Bloch (you quoted a part of it). And the general principle is to rethrow an exception to the layer where you can handle it.

Whether something is a "checked exception" has nothing to do with whether you catch it or what you do in the catch block. It's a property of exception classes. Anything that is a subclass of Exception except for RuntimeException and its subclasses is a checked exception.
The Java compiler forces you to either catch checked exceptions or declare them in the method signature. It was supposed to improve program safety, but the majority opinion seems to be that it's not worth the design problems it creates.
Why do they let the exception bubble
up? Isnt handle error the sooner the
better? Why bubble up?
Because that's the entire point of exceptions. Without this possibility, you would not need exceptions. They enable you to handle errors at a level you choose, rather than forcing you to deal with them in low-level methods where they originally occur.

Is the above considered to be a checked exception?
No
The fact that you are handling an exception does not make it a Checked Exception if it is a RuntimeException.
Is RuntimeException an unchecked exception?
Yes
Checked Exceptions are subclasses of java.lang.Exception
Unchecked Exceptions are subclasses of java.lang.RuntimeException
Calls throwing checked exceptions need to be enclosed in a try{} block or handled in a level above in the caller of the method. In that case the current method must declare that it throws said exceptions so that the callers can make appropriate arrangements to handle the exception.
Hope this helps.
Q: should I bubble up the exact
exception or mask it using Exception?
A: Yes this is a very good question and important design consideration. The class Exception is a very general exception class and can be used to wrap internal low level exceptions. You would better create a custom exception and wrap inside it. But, and a big one - Never ever obscure in underlying original root cause. For ex, Don't ever do following -
try {
attemptLogin(userCredentials);
} catch (SQLException sqle) {
throw new LoginFailureException("Cannot login!!"); //<-- Eat away original root cause, thus obscuring underlying problem.
}
Instead do following:
try {
attemptLogin(userCredentials);
} catch (SQLException sqle) {
throw new LoginFailureException(sqle); //<-- Wrap original exception to pass on root cause upstairs!.
}
Eating away original root cause buries the actual cause beyond recovery is a nightmare for production support teams where all they are given access to is application logs and error messages.
Although the latter is a better design but many people don't use it often because developers just fail to pass on the underlying message to caller. So make a firm note: Always pass on the actual exception back whether or not wrapped in any application specific exception.
On try-catching RuntimeExceptions
RuntimeExceptions as a general rule should not be try-catched. They generally signal a programming error and should be left alone. Instead the programmer should check the error condition before invoking some code which might result in a RuntimeException. For ex:
try {
setStatusMessage("Hello Mr. " + userObject.getName() + ", Welcome to my site!);
} catch (NullPointerException npe) {
sendError("Sorry, your userObject was null. Please contact customer care.");
}
This is a bad programming practice. Instead a null-check should have been done like -
if (userObject != null) {
setStatusMessage("Hello Mr. " + userObject.getName() + ", Welome to my site!);
} else {
sendError("Sorry, your userObject was null. Please contact customer care.");
}
But there are times when such error checking is expensive such as number formatting, consider this -
try {
String userAge = (String)request.getParameter("age");
userObject.setAge(Integer.parseInt(strUserAge));
} catch (NumberFormatException npe) {
sendError("Sorry, Age is supposed to be an Integer. Please try again.");
}
Here pre-invocation error checking is not worth the effort because it essentially means to duplicate all the string-to-integer conversion code inside parseInt() method - and is error prone if implemented by a developer. So it is better to just do away with try-catch.
So NullPointerException and NumberFormatException are both RuntimeExceptions, catching a NullPointerException should replaced with a graceful null-check while I recommend catching a NumberFormatException explicitly to avoid possible introduction of error prone code.

1 . If you are unsure about an exception, check the API:
java.lang.Object
extended by java.lang.Throwable
extended by java.lang.Exception
extended by java.lang.RuntimeException //<-NumberFormatException is a RuntimeException
extended by java.lang.IllegalArgumentException
extended by java.lang.NumberFormatException
2 . Yes, and every exception that extends it.
3 . There is no need to catch and throw the same exception. You can show a new File Dialog in this case.
4 . FileNotFoundException is already a checked exception.
5 . If it is expected that the method calling someMethod to catch the exception, the latter can be thrown. It just "passes the ball". An example of it usage would be if you want to throw it in your own private methods, and handle the exception in your public method instead.
A good reading is the Oracle doc itself: http://download.oracle.com/javase/tutorial/essential/exceptions/runtime.html
Why did the designers decide to force a method to specify all uncaught checked exceptions that can be thrown within its scope? Any Exception that can be thrown by a method is part of the method's public programming interface. Those who call a method must know about the exceptions that a method can throw so that they can decide what to do about them. These exceptions are as much a part of that method's programming interface as its parameters and return value.
The next question might be: "If it's so good to document a method's API, including the exceptions it can throw, why not specify runtime exceptions too?" Runtime exceptions represent problems that are the result of a programming problem, and as such, the API client code cannot reasonably be expected to recover from them or to handle them in any way. Such problems include arithmetic exceptions, such as dividing by zero; pointer exceptions, such as trying to access an object through a null reference; and indexing exceptions, such as attempting to access an array element through an index that is too large or too small.
There's also an important bit of information in the Java Language Specification:
The checked exception classes named in the throws clause are part of the contract between the implementor and user of the method or constructor.
The bottom line IMHO is that you can catch any RuntimeException, but you are not required to and, in fact the implementation is not required to maintain the same non-checked exceptions thrown, as those are not part of the contract.

1) No, a NumberFormatException is an unchecked Exception. Even though you caught it (you aren't required to) because it's unchecked. This is because it is a subclass of IllegalArgumentException which is a subclass of RuntimeException.
2) RuntimeException is the root of all unchecked Exceptions. Every subclass of RuntimeException is unchecked. All other Exceptions and Throwable are checked except for Errors ( Which comes under Throwable).
3/4) You could alert the user that they picked a non-existent file and ask for a new one. Or just quit informing the user that they entered something invalid.
5) Throwing and catching 'Exception' is bad practice. But more generally, you might throw other exceptions so the caller can decide how to deal with it. For example, if you wrote a library to handle reading some file input and your method was passed a non-existent file, you have no idea how to handle that. Does the caller want to ask again or quit? So you throw the Exception up the chain back to the caller.
In many cases, an unchecked Exception occurs because the programmer did not verify inputs (in the case of NumberFormatException in your first question). That's why its optional to catch them, because there are more elegant ways to avoid generating those exceptions.

Checked - Prone to happen. Checked in Compile time.
Eg.. FileOperations
UnChecked - Due to Bad data. Checked in Run time.
Eg..
String s = "abc";
Object o = s;
Integer i = (Integer) o;
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
at Sample.main(Sample.java:9)
Here exception is due to bad data and in no way it can be determined during compile time.

Runtime Exceptions :
Runtime exceptions are referring to as unchecked exceptions. All other exceptions
are checked exceptions, and they don't derive from java.lang.RuntimeException.
Checked Exceptions :
A checked exception must be caught somewhere in your code. If you invoke a
method that throws a checked exception but you don't catch the checked exception
somewhere, your code will not compile. That's why they're called checked
exceptions : the compiler checks to make sure that they're handled or declared.
A number of the methods in the Java API throw checked exceptions, so you will often write exception handlers to cope with exceptions generated by methods you didn't write.

Checked exceptions are checked at compile time by the JVM and its related to resources(files/db/stream/socket etc). The motive of checked exception is that at compile time if the resources are not available the application should define an alternative behaviour to handle this in the catch/finally block.
Unchecked exceptions are purely programmatic errors, wrong calculation, null data or even failures in business logic can lead to runtime exceptions. Its absolutely fine to handle/catch unchecked exceptions in code.
Explanation taken from http://coder2design.com/java-interview-questions/

My absolute favorite description of the difference between unchecked and checked exceptions is provided by the Java Tutorial trail article, "Unchecked Exceptions - the Controversy" (sorry to get all elementary on this post - but, hey, the basics are sometimes the best):
Here's the bottom line guideline: If a client can reasonably be
expected to recover from an exception, make it a checked exception. If
a client cannot do anything to recover from the exception, make it an
unchecked exception
The heart of "what type of exception to throw" is semantic (to some degree) and the above quote provides and excellent guideline (hence, I am still blown away by the notion that C# got rid of checked exceptions - particularly as Liskov argues for their usefulness).
The rest then becomes logical: to which exceptions does the compiler expect me to respond, explicitly? The ones from which you expect client to recover.

To answer the final question (the others seem thoroughly answered above), "Should I bubble up the exact exception or mask it using Exception?"
I am assuming you mean something like this:
public void myMethod() throws Exception {
// ... something that throws FileNotFoundException ...
}
No, always declare the most precise exception possible, or a list of such. The exceptions you declare your method as capable of throwing are a part of the contract between your method and the caller. Throwing "FileNotFoundException" means that it is possible the file name isn't valid and the file will not be found; the caller will need to handle that intelligently. Throwing Exception means "Hey, sh*t happens. Deal." Which is a very poor API.
In the comments on the first article there are some examples where "throws Exception" is a valid and reasonable declaration, but that's not the case for most "normal" code you will ever write.

I think that checked exceptions are a good reminder for the developer that uses an external library that things can go wrong with the code from that library in exceptional situations.

Why do they let the exception bubble up? Isn't handling the error sooner better? Why bubble up?
For example let say you have some client-server application and client had made a request for some resource that couldn't be find out or for something else error some might have occurred at the server side while processing the user request then it is the duty of the server to tell the client why he couldn't get the thing he requested for,so to achieve that at server side, code is written to throw the exception using throw keyword instead of swallowing or handling it.if server handles it/swallow it, then there will be no chance of intimating to the client that what error had occurred.
Note:To give a clear description of what the error type has occurred we can create our own Exception object and throw it to the client.

I just want to add some reasoning for not using checked exceptions at all. This is not a full answer, but I feel it does answer part of your question, and complements many other answers.
Whenever checked exceptions are involved, there's a throws CheckedException somewhere in a method signature (CheckedException could be any checked exception). A signature does NOT throw an Exception, throwing Exceptions is an aspect of implementation. Interfaces, method signatures, parent classes, all these things should NOT depend on their implementations. The usage of checked Exceptions here (actually the fact that you have to declare the throws in the method signature) is binding your higher-level interfaces with your implementations of these interfaces.
Let me show you an example.
Let's have a nice and clean interface like this
public interface IFoo {
public void foo();
}
Now we can write many implementations of method foo(), like these
public class Foo implements IFoo {
#Override
public void foo() {
System.out.println("I don't throw and exception");
}
}
Class Foo is perfectly fine. Now let's make a first attempt at class Bar
public class Bar implements IFoo {
#Override
public void foo() {
//I'm using InterruptedExcepton because you probably heard about it somewhere. It's a checked exception. Any checked exception will work the same.
throw new InterruptedException();
}
}
This class Bar won't compile. As InterruptedException is a checked exception, you must either capture it (with a try-catch inside method foo()) or declare that you're throwing it (adding throws InterruptedException to the method signature). As I don't want to capture this exception here (I want it to propagate upwards so I can properly deal with it somewhere else), let's alter the signature.
public class Bar implements IFoo {
#Override
public void foo() throws InterruptedException {
throw new InterruptedException();
}
}
This class Bar won't compile either! Bar's method foo() does NOT override IFoo's method foo() since their signatures are different. I could remove the #Override annotation, but I want to program against interface IFoo like IFoo foo; and later on decide on which implementation I want to use, like foo = new Bar();. If Bar's method foo() doesn't override IFoo's method foo, when I do foo.foo(); it won't call Bar's implementation of foo().
To make Bar's public void foo() throws InterruptedException override IFoo's public void foo() I MUST add throws InterruptedException to IFoo's method signature. This, however, will cause problems with my Foo class, since it's foo() method's signature differs from IFoo's method signature. Furthermore, if I added throws InterruptedException to Foo's method foo() I would get another error stating that Foo's method foo() declares that it throws an InterruptedException yet it never throws an InterruptedException.
As you can see (if I did a decent job at explaining this stuff), the fact that I'm throwing a checked exception like InterruptedException is forcing me to tie my interface IFoo to one of it's implementations, which in turn causes havoc on IFoo's other implementations!
This is one big reason why checked exceptions are BAD. In caps.
One solution is to capture the checked exception, wrap it in an unchecked exception and throw the unchecked exception.

Java distinguishes between two categories of exceptions (checked & unchecked).
Java enforces a catch or declared requirement for checked exceptions.
An exception's type determines whether an exception is checked or unchecked.
All exception types that are direct or indirect subclasses of class RuntimeException
are unchecked exception.
All classes that inherit from class Exception but not RuntimeException are considered to be checked exceptions.
Classes that inherit from class Error are considered to be unchecked.
Compiler checks each method call and deceleration to determine whether the
method throws checked exception.
If so the compiler ensures the exception is caught or is declared in a throws clause.
To satisfy the declare part of the catch-or-declare requirement, the method that generates
the exception must provide a throws clause containing the checked-exception.
Exception classes are defined to be checked when they are considered important enough to catch or declare.

Here is a simple rule that can help you decide. It is related to how interfaces are used in Java.
Take your class and imagine designing an interface for it such that the interface describes the functionality of the class but none of the underlying implementation (as an interface should). Pretend perhaps that you might implement the class in another way.
Look at the methods of the interface and consider the exceptions they might throw:
If an exception can be thrown by a method, regardless of the underlying implementation (in other words, it describes the functionality only) then it should probably be a checked exception in the interface.
If an exception is caused by the underlying implementation, it should not be in the interface. Therefore, it must either be an unchecked exception in your class (since unchecked exceptions need not appear in the interface signature), or you must wrap it and rethrow as a checked exception that is part of the interface method.
To decide if you should wrap and rethrow, you should again consider whether it makes sense for a user of the interface to have to handle the exception condition immediately, or the exception is so general that there is nothing you can do about it and it should propagate up the stack. Does the wrapped exception make sense when expressed as functionality of the new interface you are defining or is it just a carrier for a bag of possible error conditions that could also happen to other methods? If the former, it might still be a checked exception, otherwise it should be unchecked.
You should not usually plan to "bubble-up" exceptions (catch and rethrow). Either an exception should be handled by the caller (in which case it is checked) or it should go all the way up to a high level handler (in which case it is easiest if it is unchecked).

Just to point out that if you throw a checked exception in a code and the catch is few levels above, you need to declare the exception in the signature of each method between you and the catch. So, encapsulation is broken because all functions in the path of throw must know about details of that exception.

In short, exceptions which your module or modules above are supposed to handle during runtime are called checked exceptions; others are unchecked exceptions which are either RuntimeException or Error.
In this video, it explains checked and unchecked exceptions in Java:
https://www.youtube.com/watch?v=ue2pOqLaArw

All of those are checked exceptions. Unchecked exceptions are subclasses of RuntimeException. The decision is not how to handle them, it's should your code throw them. If you don't want the compiler telling you that you haven't handled an exception then you use an unchecked (subclass of RuntimeException) exception. Those should be saved for situations that you can't recover from, like out of memory errors and the like.

Checked Exceptions :
The exceptions which are checked by the compiler for smooth execution of the program at runtime are called Checked Exception.
These occur at compile time.
If these are not handled properly, they will give compile time error (Not Exception).
All subclasses of Exception class except RuntimeException are Checked Exception.
Hypothetical Example - Suppose you are leaving your house for the exam, but if you check whether you took your Hall Ticket at home(compile time) then there won't be any problem at Exam Hall(runtime).
Unchecked Exception :
The exceptions which are not checked by the compiler are called Unchecked Exceptions.
These occur at runtime.
If these exceptions are not handled properly, they don’t give compile time error. But the program will be terminated prematurely at runtime.
All subclasses of RunTimeException and Error are unchecked exceptions.
Hypothetical Example - Suppose you are in your exam hall but somehow your school had a fire accident (means at runtime) where you can't do anything at that time but precautions can be made before (compile time).

If anybody cares for yet another proof to dislike checked exceptions, see the first few paragraphs of the popular JSON library:
"Although this is a checked exception, it is rarely recoverable. Most callers should simply wrap this exception in an unchecked exception and rethrow: "
So why in the world would anyone make developers keep checking the exception, if we should "simply wrap it" instead? lol
http://developer.android.com/reference/org/json/JSONException.html

All exceptions must be checked exceptions.
Unchecked exceptions are unrestricted gotos. And unrestricted gotos are considered a bad thing.
Unchecked exceptions break encapsulation. To process them correctly, all the functions in the call tree between the thrower and the catcher must be known to avoid bugs.
Exceptions are errors in the function that throws them but not errors in the function that processes them. The purpose of exceptions is to give the program a second chance by deferring the decision of whether it's an error or not to another context. It's only in the other context can the correct decision be made.

Checked and unchecked exceptions; what makes them different?

I've been trying to get the hang of exceptions but I've run into some problems. I'm going to explain what I know and add bold text to the parts I'm not sure of:
I understand that there are Checked exceptions and Unchecked exceptions (The latter are all subclasses of RuntimeException?).
In methods where Checked exceptions can be thrown, the method signature NEEDS to state this (At least if I've understood what I've read about exceptions correctly?).
E.g.:
public void m() throws IOException{
...
}
This doesn't need to be done for Unchecked exceptions (It doesn't NEED to, but CAN it?)
I also know that you can "try" a piece of your code and any exceptions that might be thrown there will be caught in the "catch" part (Try-Catch). Does this have to be done for both checked and unchecked exceptions? When do I have to do this?
To clarify the second part of the last question, a class like
public class A
{
private int[] items;
public int first()
{
return items[0];
}
}
Will return a NullPointerException. Yet there's no Try-Catch part, so when do I need to use Try-Catch and when don't I?
Thanks a lot in advance!
P.s. I've already read some answers regarding this topic on StackOverflow but none are really specific to the problems I'm experiencing.

The most important thing to know about exceptions is that you don't need to catch them, at least not directly where they happen. This property of the exception sets it apart from the return value, and makes it a useful language feature to achieve execution flow patterns typically needed for error/exceptional event handling.
The only distracting thing about exceptions in Java are the checked exceptions, which induce a sort of urgency about handling them. Fact is, you don't have to handle a checked exception either, but the complete call path leading from the exception to the handler must be beset with throws declarations. This ranges from very awkward to impossible. The standard workaround for that is catching the checked exception right away, only to throw another, unchecked one, which wraps the original.

To answer this question:
I also know that you can "try" a piece of your code and any exceptions that might be thrown there will be caught in the "catch" part (Try-Catch). Does this have to be done for both checked and unchecked exceptions? When do I have to do this?
The only time you have to do this (in order to make the program legal) is when a your method does something that could throw a checked exception, and you don't want to, or can't, list that exception in a throws clause. (If you're writing a method that overrides a method in a parent class, and the method in the parent class doesn't list an exception in a throws clause, the overriding method in the subclass can't list it either.) Then you have to handle it, by using try..catch. If the Java compiler is convinced that any place the checked exception could be thrown, then it will be caught and handled by a catch, then the program is legal. Otherwise it won't compile.
For unchecked exceptions, you never have to catch the exception to make the program compile.
Of course, you still "have" to catch an exception, even an unchecked one, if it's necessary for your program to behave the way you want. (For example, if not catching the exception means an ugly stack trace appears on your web site and your customers get so freaked out that they never visit it any more.) But I'm just talking about program legality.

can't java unchecked exceptions be handled using try/catch block?

In a tutorial I found that Unchecked Exception can't be handled by your code i.e. we can't use try/catch block and the examples are exceptions like ArrayIndexOutOfBoundsException, NullPointerException. But these exceptions can be handled using try/catch block. I think i am not clear about the concept !!
Also i think throw keyword can be used only with try/catch block.can throw Keyword be used with UncheckedException?

The only difference between checked and unchecked exceptions is that checked ones have to be either caught or declared in the method signature using throws, whereas with unchecked ones this is optional.
Unchecked Exception can't be handled by your code i.e. we can't use try/catch block
Sure we can - but we don't have to.
Also i think throw keyword can be used only with try/catch block.can throw Keyword be used with Unchecked Exception?
Note that there are two keywords:
throw explicitly throws an exception object you created. throw new NullPointerException(); works perfectly fine, though explicitly creating that particular exception is uncommon and most would consider it bad style.
throws declares that a method may throw that exception. With unchecked exceptions this is optional, but can be useful to document the fact (again, one would normally not declared throws NullPointerException because that is pretty much a given).

All the unchecked exceptions can be treated in the same way as the checked ones - if you want, you can let them pass by declaring that the method throws them:
public void m() throws RuntimeException {}
Or you can catch them:
public void m() {
try {
// some code
} catch (RuntimeException re) {
// do something
}
}
It should be noticed, the class RuntimeException acts as a catch-all for the unchecked exceptions (since all the unchecked exceptions extend from it), much in the same way that the Exception class is the catch-all for checked exceptions.
As has been mentioned before, the only real difference is that for checked exceptions you have to handle them (by letting them pass or catching them) and the compiler will make sure of it - on the other hand, the handling of unchecked exceptions is optional.
It all boils down to the expected usage of each exception type - you're supposed do be able to recover from checked exceptions (or at least do something about them, when they occur), whilst for unchecked exceptions, there might not be a reasonable way to recover from them. This of course, is a bit subjective.

They can be handled, but you don't have to. If you don't handle them, they will propagate and climb up the calling methods stack, until one of them catches it. If none does, the program will crash.
Usually, the bottom line is that if a client can reasonably be expected to recover from an exception, then it should be a checked exception. If a client cannot do anything to recover from the exception, then it's ok to have it as an unchecked exception.
Also, checked exceptions are useful to document an API that you expect to be used by 3rd-parties. When they know your method can throw a specific exception, they will code accordingly and handle the case. If you only use unchecked exceptions, all bets are off.
A common pattern (some people don't like it, but in some cases it's ok when you know what you're doing) is to wrap thrown checked exceptions into unchecked ones.
try {
... code that can throw CheckedException ...
} catch (CheckedException oopsSomethingBadHappened) {
throw new RuntimeException("Something bad happened!", oopsSomethingBadHappened);
}

An easy way to think about the difference is to think the checking refers to the compile. If an exception is a checked exception, the compiler will check that your code either throws the exception or handles it in a try/catch block at compile-time. For unchecked exceptions, the compiler won't do such a check. You can handle checked/unchecked exceptions the same way (with try/catch/throws), the difference just lies in the checks the compiler performs. This post has a decent example.

In addition to Guillaume:
unchecked exceptions are usually programming errors, which should not happen at all if implemented correctly (index out of bound, null pointer, class cast,...) and therefore the caller/ user usually cannot do anything about them.
checked exceptions are thrown because it was outside of the control of the programmer (network not availabe, filesystem not available, concurrent modifications such as duplicated primary key,...)
errors are usually thrown by the JVM and the application usually has to stop (out of memory, stack overflow,...)

Yes, you can throw unchecked exceptions with throw. And yes, you can catch unchecked exceptions in a catch block.

Yes you can handle the unchecked exception but not compulsory. Actually it depends on application developer. Below is the possible reason where i think required to handle even unchecked exception.
If your application is large where many developers are calling each other API. It is better to handle the unchecked exception otherwise at the end your program will crash which stop the other functionality. So even the simple NullPointerException can stop your program working.
Imagine you have one scheduler which processing the user data and which is in million size and for the bad data you only want to print the log not to stop working for other good data. In that case if you have not handle the exception one bad data can stop your program

yes we can handle Runtime Exception, plz check below code
public class Demo {
static void m1() {
int a[]=new int [5];
try {
a[12]=2;
}catch(Exception e) {
}
}
public static void main(String[] args) {
m1();
try {
String s=null;
System.out.println(s.length());
}catch(Exception e) {
}
System.out.println("hello world");
}
}

What's the purpose of the 'throws' statement in Java?

I'm just learning java, but it seems that in the end most of the methods in the beginning of the call stack will just have declarations 'throws Exception'. What's the good thing about this statement that I'm missing that makes it useful?
One more example. After writing some code, I decided to refactor one of my classes a bit, using classes from other java libraries; as a result, not only half of the methods of this class gained another 5 exceptions in their declarations, but about half of all my other code, too – until I decided I'd better just write 'throws exception' and don't care about. May be I just use exceptions wrong?
Important edit
My question wasn't about what that statement does – it is pretty obvious from documentation. I was actually wondering why language designers decided to make this statement necessary.

Java's approach to exceptions is to make method caller aware of failure conditions and thus be forced to handle them or acknowledge the fact that the exception isn't handled via a repeated throws statement on the caller's method. Or put another way, knowing what exceptions are thrown is part of method's signature and thus the explicit throws statement.
For failures conditions that are not expected to occur in normal course of operation, there are two special kinds of exceptions: RuntimeException and Error. Subclasses of these exception do not need to be explicitly declared in a throws clause or caught by the caller.
It would also be worth noting that using "throws Exception" is sloppy programming in production code as it doesn't tell the caller of the method anything about the actual failure cases. The only time I would consider using generic "throws Exception" declaration as opposed to enumerating actual exception types is for cases like unit tests where explicit declaration of failure cases serves no purpose.

Although the other answers are right-on, I think they missed the purpose in the way you were asking it.
The throws statement is how you create an exception stack trace. There isn't much magic in java--it's not some underlying system mystery that creates an exception, it is simply a "Throw" statement, and therefore the last few entries in any stack trace will probably be throw.
It's not JUST the last one because in many cases exception handling consists of something like this:
try {
do something that might cause an exception
catch(ExpectedException e) {
throw new DifferetnException(e);
}
This lets you change what type of exception it was or add a better textual description or even handle some of the exceptions while re-throwing the others.
Because of this it is often the last few levels (and maybe some in-between) that are caused by the "Throw" statement.

It indicates to users of the class that an exceptional situation has arisen that they have to deal with. The subject of the throws clause tells the user what those exceptional situations are.
If the exception is a checked exception, the compiler will enforce a try/catch block in the user's code; unchecked exceptions do not require a catch block for handling. In that case the exception will continue to bubble up the call stack until it's either handled or the program is exited.

After a lot of reading about exceptions and best practices, I realized that I made a mistake, using Exception class for handling programming errors – which I check for in literally every method – where as I should've used RuntimeException, which is not required to be checked. After refactoring my code I got 'throws' statements only in places necessary, and now it is neat and clean.

It makes you aware of possible problems that may occur and forces you to either deal with them or explicitly say you are not.

In Java there are Checked Exceptions and Runtime Exceptions.
Checked Exceptions can only occur in Methods that declare them explicitly.
Runtime Exceptions can occur anywhere in the code and don't have to be declared.
The throws IOException clause declares that in this method there will possibly occur an IOException.
Runtime Exception are those that extend the class RuntimeException. All others are Checked Exceptions.
Exceptions are actually thrown by Statements like throw new IOException(...) inside the method.

Throws raise an exception. An exception will be passed backward to the function into the stack until it is caught by a catch block, that can handle it.
When throw keyword is put in a method declaration it indicates that a call to that method could generate an exception. For example:
public void methodFoo (int val) throws IllegalArgumentException {
if (val <0) throw new IllegalArgumentExecption();
}
means that the methodFoo can raise an exception of the type IllegalArgumentException.
When you call such a method you typically use the following try/catch block statement:
try{
methodFoo(int param);
}catch (IllegalArgumentException e){
//if any method call inside methodFoo will raise such exception the execution flow of the program will be interrupted and the execution restart from the first catch block that intercept that execption
}
The "good" of this approach is that, with such feature, you are not forced to check the return value of a method to be sure that your method call succeded. in C language you usually do something like:
int ret = methodFoo();
if (ret == null){
//error
}