这会导致堆栈溢出错误吗？

Question

增加对象的实例变量是否会导致堆栈溢出错误？

例如：

此方法（java）将导致堆栈溢出错误：

class StackOverflow {
    public static void StackOverflow (int x) 
    {
        System.out.println (x) ; 
        StackOverflow(x+1) ; 
    } 

    public static void main (String[]arg) { StackOverflow (0) ; 
} 

但这会吗？：（.....是我为了缩短代码而放入的间隙。它已经足够长了。）

import java.util.*;
class Dice 
{ 
    String name ; 
    int x ; 
    int[] sum ;  

.. ..

public Dice (String name) 
{ 
    this.name = name ; 
    this.x = 0 ; 
    this.sum = new int[7] ; 
}

....

public static void main (String[] arg) 
{
    Dice a1 = new Dice ("a1") ; 
    for (int i = 0; i<6000000; i++) 
    {
        a1.roll () ;
        printDice(a1) ; 
    } 
}

....

    public void roll () 
    {
        this.x = randNum(1, this.sum.length) ; 
        this.sum[x] ++ ;
    }

    public static int randNum (int a, int b) 
    {
        Random random = new Random() ;
        int c = (b-a) ;
        int randomNumber = ((random.nextInt(c)) + a) ;
        return randomNumber ;
    }

    public static void printDice (Dice Dice) 
    { 
        System.out.println (Dice.name) ; 
        System.out.println ("value: "+Dice.x) ; 
        printValues (Dice) ; 
    } 

    public static void printValues (Dice Dice) 
    { 
        for (int i = 0; i<Dice.sum.length; i++) 
        System.out.println ("#of "+i+"'s: "+Dice.sum[i]) ; 
    } 

}

以上目前不会导致堆栈溢出错误，但如果我在 main 中更改此行，我也能得到它吗： for (int i = 0; i<6000000; i++ ) 这样一来，不是有 600 万足够高的东西了吗？

Answer 1

堆栈溢出？不，但它可能会导致整数溢出，这是一个非常不同的事情。

堆栈溢出意味着方法调用堆栈上的空间已耗尽（可能是由于失控的递归调用）。如果增量超出其最大值，则整数溢出将导致 int 循环到其最低值。

Answer 2

在Java中，堆栈溢出错误来自于过度的递归。这是函数直接或间接调用自身的地方。

在第一个示例中，StackOverflow 函数直接调用自身而不受限制。

在您的 Dice 示例中，没有函数调用自身的实例，因此您不太可能遇到堆栈溢出错误。

Answer 3

堆栈溢出错误是由无限递归（即方法调用自身次数过多）引起的。您的第二个代码示例似乎根本没有使用递归，因此我认为不可能出现堆栈溢出错误。

Answer 4

这会导致堆栈吗
溢出错误？

• yes

简单地说：

当应用程序递归太深而发生堆栈溢出时，就会抛出堆栈溢出。
这意味着您的行 StackOverflow(x+1) ; 可能会引发堆栈溢出错误，具体取决于堆栈有多大。除此之外，代码将开始获取意外的 int 值。

Answer 5

那么，您可以使用 -Xss 开关更改 java 中堆栈的最大大小。最小的堆栈约为 1KB，因此您不需要无限（甚至非常多）递归来获得所需的堆栈溢出，但您肯定需要比示例中给出的更多的堆栈。我想我的观点是，递归足以导致堆栈溢出，但不是必需的；使用任意小的调用堆栈，您可以通过任意少量的方法调用使其溢出。

Answer 6

这将导致整数溢出，因为 int 类型从大约开始。 -2E7至2E7