IllegalArgumentException(非法参数异常)和其子类异常NumberFormatException，以及异常类之间的继承关系和产生原因

                java.lang.Object

                        java.lang.Throwable

                                java.lang.Exception

                                        java.lang.RuntimeException

                                                java.lang.IllegalArgumentException

                                                        java.lang.NumberFormatException

public class Main {
    public static void main(String[] args) {
        String str = "a123";
        //在下述代码中会因为将非纯数字的字符串作为参数传给Integer的parseInt静态方法而产生NumberFormatException异常
        //该异常是运行时异常，继承自IllegalArgumentException，运行时异常可以处理也可以不处理
        int num = Integer.parseInt(str);    //Exception in thread "main" java.lang.NumberFormatException: For input string: "a123"
                                            //at Main.main(Main.java:4)
        System.out.println(num);

        
    }

这时有小伙伴好奇了，在上述代码中调用Integer类的parseInt静态方法传递了一个字符串参数"a123"为什么就报错了呢？ 

        这是因为我们调用的是Integer类中下述的构造方法：

    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

然后该parseInt静态方法又调用了本类中重载的另外一个同名两参数的静态方法： 

    public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
        

        if (s == null) {
            throw new NumberFormatException("null");
        }

        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }

        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        int result = 0;
        boolean negative = false;
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;

        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Integer.MIN_VALUE;
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }

                java.lang.Object

                        java.lang.Throwable

                                java.lang.Exception

                                        java.lang.RuntimeException

                                                java.lang.IllegalArgumentException

import java.util.ArrayList;


public class Main {
    public static void main(String[] args) {
        int num1 = 666;
        int num2 = -666;
        //参数正常
        ArrayList arrayList = new ArrayList(num1);

        //在下述代码中会出现IllegalArgumentException异常因为参数为num2,及-666
        //该异常是运行时异常，继承自IllegalArgumentException，运行时异常可以处理也可以不处理
        ArrayList arrayList1 = new ArrayList(num2); //Exception in thread "main" java.lang.IllegalArgumentException: Illegal Capacity: -666
                                                                    //	at Main.main(Main.java:13)
        

    }
}

        肯定有小伙伴好奇，在上述代码中调用ArrayList的构造方法传递了一个负参数为什么就报错了呢？ 

        这是因为我们调用的是ArrayList类中下述的构造方法：

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

        当参数小于0时，该构造方法就会抛出IllegalArgumentException还有产生该异常的原因是Illegal Capacity: -666。