这个问题的很多答案都是好的。但是，我想采取稍微不同的方法，并对内存的工作原理和(简化的)可视化更好地理解StackOverflow错误给出一些更深入的见解。这种理解不仅适用于Java，而且适用于所有进程。

在现代系统中，所有新进程都有自己的虚拟地址空间(VAS)。从本质上讲，VAS是操作系统在物理内存之上提供的抽象层，目的是确保进程之间不相互干扰内存。内核的任务是将虚拟地址映射到实际的物理地址。

VAS可以分为几个部分:

为了让CPU知道它应该做什么，机器指令必须加载到内存中。这通常被称为代码或文本段，具有静态大小。

在此之上，可以找到数据段和堆。数据段大小固定，包含全局变量或静态变量。 当程序遇到特殊情况时，它可能需要额外分配数据，这就是堆发挥作用的地方，因此它能够动态地增长大小。

堆栈位于虚拟地址空间的另一侧，并使用后进先出(LIFO)数据结构跟踪所有函数调用。与堆类似，程序在运行时可能需要额外的空间来跟踪正在调用的新函数调用。由于堆栈位于VAS的另一侧，它正向相反的方向增长，即朝着堆的方向增长。

博士TL;

这就是StackOverflow错误发挥作用的地方。

由于堆栈向下增长(朝向堆)，可能会发生在某个时间点它不能继续增长，因为它会与堆地址空间重叠。一旦发生这种情况，就会发生StackOverflow错误。

发生这种情况最常见的原因是由于程序中的一个错误导致递归调用不能正确终止。

请注意，在某些系统上，VAS的行为可能略有不同，甚至可以分为更多的部分，但是，这种一般理解适用于所有UNIX系统。

参数和局部变量分配在堆栈上(对于引用类型，对象位于堆上，堆栈中的变量引用堆上的对象)。堆栈通常位于地址空间的上端，当它被用完时，它会朝向地址空间的底部(即朝向零)。

你的进程也有一个堆，它位于你的进程的底部。当您分配内存时，这个堆可以向地址空间的顶端增长。正如您所看到的，堆有可能与堆栈“碰撞”(有点像构造板块!!)。

导致堆栈溢出的常见原因是错误的递归调用。通常，这是当递归函数没有正确的终止条件时引起的，因此它最终永远调用自己。或者当终止条件良好时，可能是由于在实现终止条件之前需要太多的递归调用而导致的。

但是，使用GUI编程，可以生成间接递归。例如，你的应用程序可能正在处理paint消息，在处理它们的同时，它可能会调用一个函数，导致系统发送另一个paint消息。这里您没有显式地调用自己，但是OS/VM已经为您完成了。

To deal with them, you'll need to examine your code. If you've got functions that call themselves then check that you've got a terminating condition. If you have, then check that when calling the function you have at least modified one of the arguments, otherwise there'll be no visible change for the recursively called function and the terminating condition is useless. Also mind that your stack space can run out of memory before reaching a valid terminating condition, thus make sure your method can handle input values requiring more recursive calls.

如果没有明显的递归函数，则检查是否调用了间接导致函数被调用的库函数(如上面的隐式情况)。

堆栈溢出通常是由于嵌套函数调用太深(在使用递归时尤其容易，即函数调用自身)或在堆栈上分配大量内存而使用堆更合适。

在紧急情况下，以下情况将导致堆栈溢出错误。

public class Example3 {

    public static void main(String[] args) {

        main(new String[1]);
    }

}

StackOverflowError之于堆栈，就像OutOfMemoryError之于堆。

无界递归调用会导致堆栈空间被用完。

产生StackOverflowError的示例如下:

class  StackOverflowDemo
{
    public static void unboundedRecursiveCall() {
     unboundedRecursiveCall();
    }

    public static void main(String[] args) 
    {
        unboundedRecursiveCall();
    }
}

如果对递归调用进行了限制，以防止内存中不完整调用的总和(以字节为单位)超过堆栈大小(以字节为单位)，则可以避免StackOverflowError。

这是一个典型的java.lang.StackOverflowError…该方法递归地调用自身，在doubleValue()、floatValue()等中没有出口。

文件Rational.java

public class Rational extends Number implements Comparable<Rational> {
    private int num;
    private int denom;

    public Rational(int num, int denom) {
        this.num = num;
        this.denom = denom;
    }

    public int compareTo(Rational r) {
        if ((num / denom) - (r.num / r.denom) > 0) {
            return +1;
        } else if ((num / denom) - (r.num / r.denom) < 0) {
            return -1;
        }
        return 0;
    }

    public Rational add(Rational r) {
        return new Rational(num + r.num, denom + r.denom);
    }

    public Rational sub(Rational r) {
        return new Rational(num - r.num, denom - r.denom);
    }

    public Rational mul(Rational r) {
        return new Rational(num * r.num, denom * r.denom);
    }

    public Rational div(Rational r) {
        return new Rational(num * r.denom, denom * r.num);
    }

    public int gcd(Rational r) {
        int i = 1;
        while (i != 0) {
            i = denom % r.denom;
            denom = r.denom;
            r.denom = i;
        }
        return denom;
    }

    public String toString() {
        String a = num + "/" + denom;
        return a;
    }

    public double doubleValue() {
        return (double) doubleValue();
    }

    public float floatValue() {
        return (float) floatValue();
    }

    public int intValue() {
        return (int) intValue();
    }

    public long longValue() {
        return (long) longValue();
    }
}

文件Main.java

public class Main {

    public static void main(String[] args) {

        Rational a = new Rational(2, 4);
        Rational b = new Rational(2, 6);

        System.out.println(a + " + " + b + " = " + a.add(b));
        System.out.println(a + " - " + b + " = " + a.sub(b));
        System.out.println(a + " * " + b + " = " + a.mul(b));
        System.out.println(a + " / " + b + " = " + a.div(b));

        Rational[] arr = {new Rational(7, 1), new Rational(6, 1),
                new Rational(5, 1), new Rational(4, 1),
                new Rational(3, 1), new Rational(2, 1),
                new Rational(1, 1), new Rational(1, 2),
                new Rational(1, 3), new Rational(1, 4),
                new Rational(1, 5), new Rational(1, 6),
                new Rational(1, 7), new Rational(1, 8),
                new Rational(1, 9), new Rational(0, 1)};

        selectSort(arr);

        for (int i = 0; i < arr.length - 1; ++i) {
            if (arr[i].compareTo(arr[i + 1]) > 0) {
                System.exit(1);
            }
        }


        Number n = new Rational(3, 2);

        System.out.println(n.doubleValue());
        System.out.println(n.floatValue());
        System.out.println(n.intValue());
        System.out.println(n.longValue());
    }

    public static <T extends Comparable<? super T>> void selectSort(T[] array) {

        T temp;
        int mini;

        for (int i = 0; i < array.length - 1; ++i) {

            mini = i;

            for (int j = i + 1; j < array.length; ++j) {
                if (array[j].compareTo(array[mini]) < 0) {
                    mini = j;
                }
            }

            if (i != mini) {
                temp = array[i];
                array[i] = array[mini];
                array[mini] = temp;
            }
        }
    }
}

结果

2/4 + 2/6 = 4/10
Exception in thread "main" java.lang.StackOverflowError
2/4 - 2/6 = 0/-2
    at com.xetrasu.Rational.doubleValue(Rational.java:64)
2/4 * 2/6 = 4/24
    at com.xetrasu.Rational.doubleValue(Rational.java:64)
2/4 / 2/6 = 12/8
    at com.xetrasu.Rational.doubleValue(Rational.java:64)
    at com.xetrasu.Rational.doubleValue(Rational.java:64)
    at com.xetrasu.Rational.doubleValue(Rational.java:64)
    at com.xetrasu.Rational.doubleValue(Rational.java:64)
    at com.xetrasu.Rational.doubleValue(Rational.java:64)

下面是OpenJDK 7中StackOverflowError的源代码。