Programmer vs. JVM thrown Exceptions (Java OCA 8 Programmer I Study Guide, Sybex)

[Aleksandra Pestova]

In the study guide Chapter 6 is said that:
1. ArithmeticException, ArrayIndexOutOfBoundsException, ClassCastException, NullPointerException are thrown by the JVM and
2. IllegalArgumentException, NumberFormatException are thrown by programmer.

I don't quite understand this distinction.

I wrote following example:

 public class Example {
   public static void main(String[] args){
      String name = "abc";
      int x = Integer.parseInt(name);
   }
}

I think in this case the JVM throws an exception and not a programmer.

Could someone explain it to me please or provide a good link explaining this distinction?

Thank you very much in advance,
Aleksandra

[Aleksandra Pestova]

Forgot to mention about the above example - it throws a NumberFormatException and the book says that it's thrown by programmer.

[Ganesh Patekar]

Aleksandra Pestova wrote:I think in this case the JVM throws an exception and not a programmer.

I think, all the runtime exceptions are thrown by JVM but here when she says exception thrown by JVM and thrown by programmer doesn't meant technically who actually throws it. Technically always JVM throws it but IMO here rather than technically she meant by It's use.

When says ArithmeticException, ArrayIndexOutOfBoundsException, ClassCastException, NullPointerException are thrown by the JVM means those are thrown when there is logical error in programmer's code, It is problem at programmer's side.

When says IllegalArgumentException, NumberFormatException are thrown by programmer means It is problem or exception generated because of user's invalid input that programmer can throw by generating these exception.

• Example of runtime exceptions thrown by programmer:

package timepass;

import java.util.Scanner;

public class Test {
	/*
	 * Method which accepts only positive and non zero amount else throws
	 * IllegalArgumentException
	 */
	private void creditAmount(double amount) {
		if (amount <= 0) {
			throw new IllegalArgumentException("Amount can't be zero or negative");
		}
		// code to do something with amount
	}

	/*
	 * Method which accepts only an integer value else throws
	 * NumberFormatException
	 */
	private void getJTxtFieldAgeValue(String ageValue) {
		/*
		 * Just assume you are getting input value from JTextFiled using
		 * .getText() method. You mentioned next to JTextFiled enter age in
		 * integer only example: 20, 35 , 50 but not 23.5 in that case Or user
		 * enters non integer like string.
		 * 
		 * It might also be used when user asked to input values from command
		 * line argument i.e. as parameter of main method.
		 */

		Scanner reader = new Scanner(ageValue);
		int wordCounter = 0;
		while (reader.hasNext()) {
			wordCounter++;
			reader.next();
		}

		if (wordCounter != 1) {
			throw new NumberFormatException("Only one integer value is allowed for age");
		}
		if (!isString(ageValue.trim())) {
			throw new NumberFormatException("Only integer value is allowed for age");
		}
		int ageInt = Integer.parseInt(ageValue);
		System.out.println("User Age is: " + ageInt);
		// code to do something with int age

	}

	private boolean isString(String eachWord) {
		char[] charArray = eachWord.toCharArray();
		for (char eachChar : charArray) {
			if (!(Character.isDigit(eachChar))) {
				return false;
			}
		}
		return true;
	}

	public static void main(String args[]) {
		Test tstObj1 = new Test();
		/*
		 * Only one of them can be invoked as they raise run time exception.
		 */
		tstObj1.creditAmount(-10);// Or 0 Invalid examples

		/*
		 * Below value will be in String only while using JTextField Or passed
		 * as argument while invoking main method.
		 */
		tstObj1.getJTxtFieldAgeValue("30 year");// Or 30.50 Or 30 50 are invalid examples

	}
}

If still not satisfied, we should wait for someone who may answer...

Edit:Apology, If your unable to view program properly because of long line mesages in code, you can hide categories by clicking on button at top left side to see in full screen mode.

[Roel De Nijs]

Aleksandra Pestova wrote:Could someone explain it to me please or provide a good link explaining this distinction?

The distinction between JVM and programmer thrown exceptions is very subtle and debatable, so it can be very confusing. In this topic I tried to explain the distinction to the best of my ability. Although it's just my (humble) opinion and I am not one of the official exam creators, it might be worth reading.

If you would still have some doubts, just click the reply-button and let us know

Hope it helps!
Kind regards,
Roel

[Ganesh Patekar]

Thank you Roel  for the link which led to another link, both were really helpful.  

[Roel De Nijs]

Ganesh Patekar wrote:When says ArithmeticException, ArrayIndexOutOfBoundsException, ClassCastException, NullPointerException are thrown by the JVM means those are thrown when there is logical error in programmer's code, It is problem at programmer's side.

I do not completely agree with this. Although I am not a fan, you as a programmer can write code like this

public int length(String str) {
  if (str == null) {
    throw new NullPointerException("[str] is required");
  }
  return str.length();
}

In this scenario I prefer to use IllegalArgumentException, but it seems the JDK uses NullPointerException as well in these situations (e.g. in Java 7 a new class Objects was introduced (in the java.util package), its (static) method requireNonNull throws a NullPointerException if the object is null). And the same applies to (Array)IndexOutOfBoundsException.

Ganesh Patekar wrote:When says IllegalArgumentException, NumberFormatException are thrown by programmer means It is problem or exception generated because of user's invalid input that programmer can throw by generating these exception.

I don't agree with this statement. As a developer you can perfectly use e.g. the IllegalArgumentException to force correct usage of the library/API/application/class you have developed. So another developer will immediately know he/she is using your code incorrectly (if you provide a meaningful error message). For example (recycling one of your own examples )

private void creditAmount(double amount) {
    if (amount < 0) {
        throw new IllegalArgumentException("Amount can't be negative");
    }
    // code to do something with amount
}

If you expect from a user some input, you should validate this user input. In your example you expect a valid integral number. So you should write code which prevents the NumberFormatException from being thrown at runtime. Regular expressions (not on the OCAJP exam) are a very strong technique for data validation. Let's rewrite your age example

private void getJTxtFieldAgeValue(String ageValue) {
  if (ageValue == null) {
    throw new IllegalArgumentException("[ageValue] is required");
  }
  if (!str.matches("\\d+")) {
    // handle incorrect age value
  }
  // process correct age value
}

I would not throw a runtime exception in this case. I would throw a checked exception (e.g. InvalidValueException), because it is an invalid value from the user and thus it's not a programming error/bug (made by the developer). Thus the application can recover from this and if the user enters a valid value, he/she can continue with the application. And the checked exception forces the application to handle this exception (whereas an unchecked/runtime exception) might go unnoticed (and result in a stack trace in the logs which nobody will ever look at )

Hope it helps!
Kind regards,
Roel

[Ganesh Patekar]

Indeed helped me, It will be much helpful because I'm going to revise exception topic.

[Aleksandra Pestova]

Thank you very much Roel and Ganesh for your discussion!

In my opinion this distinction is very confusing, so seems it's better just to memorize it for the exam.