I’d say that it is a really bad idea. A lot of code is implemented on the assumption that if you catch Error and Exception you have caught all possible exceptions. And most tutorials and textbooks will tell you the same thing. By creating a direct subclass of Throwable you are potentially creating all sorts … Read more
There is an assertion: “I’m asserting that this constructor will never be called”. So, indeed, AssertionError is correct here.
The problem was, that the class in which the test was nested was an extension of TestCase. Since this is JUnit 3 style, the annotation didn’t work. Now my test class is a class on its own.
The severe method is only used to log severe messages without associated throwable information. If you need to log throwable information then you should use the log method instead: try { data = new GameData.Builder().enemy(enemy).build(); log.fine(“new data object\t\t” + data.getEnemy()); setChanged(); notifyObservers(data); } catch (NullPointerException npe) { log.log(Level.SEVERE, npe.getMessage(), npe); }
Always throw an Exception (never a Throwable). You generally don’t catch Throwable either, but you can. Throwable is the superclass to Exception and Error, so you would catch Throwable if you wanted to not only catch Exceptions but Errors, that’s the point in having it. The thing is, Errors are generally things which a normal … Read more
You can use instanceof to check it is of NoSessionException or not. Example: if (exp instanceof NoSessionException) { … } Assuming exp is the Throwable reference.
throws : Used when writing methods, to declare that the method in question throws the specified (checked) exception. As opposed to checked exceptions, runtime exceptions (NullPointerExceptions etc) may be thrown without having the method declare throws NullPointerException. throw: Instruction to actually throw the exception. (Or more specifically, the Throwable). The throw keyword is followed by … Read more
You need to be as specific as possible. Otherwise unforeseen bugs might creep away this way. Besides, Throwable covers Error as well and that’s usually no point of return. You don’t want to catch/handle that, you want your program to die immediately so that you can fix it properly.
Errors should not be caught or handled (except in the rarest of cases). Exceptions are the bread and butter of exception handling. The Javadoc explains it well: An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions. Look at … Read more
By catching Throwable it includes things that subclass Error. You should generally not do that, except perhaps at the very highest “catch all” level of a thread where you want to log or otherwise handle absolutely everything that can go wrong. It would be more typical in a framework type application (for example an application … Read more