Exception not being thrown in try statement

Question

I am trying to write a small program to handle exceptions. However, the program will not compile because it is giving me an error saying the exception InvalidDocumentCodeException will never be thrown in body of coresponding try statement. Here are the two programs:
public class InvalidDocumentCodeException extends Exception {
InvalidDocumentCodeException (String message) {
super(message);
and
import java.util.Scanner;
public class Main2 {
// Creates an exception object and possibly throws it.
public static void main (String[] args) {
char designation;
String input = null;
int valid = 0;
Scanner scan = new Scanner (System.in);
System.out.print ("Enter a 2-digit designation starting " + "\n" +
"with U, C, or P, standing for unclassified, " + "\n" +
"confidential, or proprietary: ");
input = scan.nextLine();
try {
designation = input.charAt(0);
if(designation == 'U')
valid++;
else if(designation == 'C')
valid++;
else if(designation == 'P')
valid++;
else if(designation == 'u')
valid++;
else if(designation == 'c')
valid++;
else if(designation == 'p')
valid++;
catch (InvalidDocumentCodeException problem) {
System.out.println("Invalid designation entered " +
problem);
System.out.println ("End of main method.");
can anyone tell me what I am doing wrong here?

Answer 1

kenporic wrote:
Forgive me, This is the first time I have used this sight and I should have been more precise. Thanks for all the help, but this is an excercise in how to handle exceptions in Java. One way is to "throw" the exception to another class to be handled. The other is to handle the exception within the running class. The throws program That I have works. The problem that I am having is handling the exception within the class without coding the "throws" statement. I am supposed to use the try-catch method in doing this. In the example I was given to follow, the code did not specifically throw the exception. If the input was not handled in the processing code then the catch statement is supposed to call to the exception class somehow?Okay, there are two families of exceptions--checked and unchecked.
Checked: These are for things that are not part of the "happy path" of your code, but that your code may reasonably be expected to deal with. They're not necessarily signs of a bug in your code, nor do they indicate a problem in the JVM that's beyond your control. They're for things like when a file you're looking for doesn't exist (so maybe you handle it by asking the user to pick a different file), or a network connection being lost (so maybe you handle it by waiting a few seconds and trying again).
When a checked exception occurs, since it's an expected and recoverable occurrence, you're expected to deal with it. So, when one of these exceptions can occur in your method, your method is required to either a) handle it (with catch) or b) let the caller know that HE might be asked to deal with it.
We must either handle it:
void doFileStuff(String path) {
  try {
    do file stuff
  catch (IOException exc) {
    retry--which means the whole try catch would be in a loop
    or maybe just substitute some default values that don't have to come from a file
}Or let our caller know that he's going to have to handle it (or pass it on to his own caller):
void doFileStuff(String path) throws IOException) {
  // this might throw an exception, but it's not this method's job to handle is, so it bubbles up to our caller
  do file stuff;
Unchecked: These are things that are either bugs in your code (like a NullPointerException) or serious problems with the JVM that are beyond our control (like OutOfMemoryEror). These can occur anywhere, and it's not generally our code's job or our caller's job to deal with them, so they don't need to be caught or declared like checked exceptions do. You can catch them, and there are some places where it's appropriate to do so, but leave that aside for now.
Unchecked exceptions are RuntimeException, Error, and every class that descends from them. Checked exceptions are everything else under Throwable, and Throwable itself.
Now, when you do
void foo() throws SomeException {You're telling the compiler that this method might throw that exception.\
If SomeException is a checked exception, the compiler is able to tell whether your claim that you might throw it is true. Since it's checked, every method that might throw it must declare it. So the compiler can look at all the methods you call and see if they throw SomeException. If none of them do, and you don't explicitly put throw new SomeException(...); in your foo() method, then the compiler can be absolutely sure that there's no way foo() will throw SomeException. So it won't let you claim to throw it.
On the other hand, is SomeException is unchecked, then since methods aren't required to report the unchecked exceptions they can throw, the compiler has no way of knowing whether some method you call might throw SomeException, so it always lets you declare it (and never requries you to).