Java 无法将数组值从包含main方法的类传递给其他类

我们的老师要求我们创建一个程序，根据后进先出的原理复制堆栈的工作，并指示堆栈溢出和空堆栈

我创建了三个类。Retrievee类，包含使用字符串[]args从用户获取输入的main方法。其他类Push使用Retrievee中的值。类Push应根据其大小接受值，并检查值是否超过它将要溢出的大小，并声明溢出，然后转到使用类Push中的值而不是Retrievee中的值的类Pop

class Push extends Retrivee
{
  int i;
  Push()
  {
    String push[]= new String[10];
    //int push[]=new int[10];
    for(i=0;i<12;i++)
    {
      //Retrivee ele= new Retrivee();
      push[i]=a[i];
      System.out.print("value in Push["+i+"]="+push[i]);
      if( i == 9 )
         {
           System.out.print("Stack for push has Overflown");
         }
    }
  }
}

class Pop extends Push
{
  int i;
  Pop()
  {
    String pop[]= new String[10];
    //int pop[]= new int[10];
    for(i=10;i>=-1;i--)
    {
      //Push ele1= new Push();
      pop[i]=push[i];
      System.out.print("value in Pop["+i+"]="+pop[i]);
      if(i == -1)
      {
       System.out.print("Stack for pop is empty");
      }
    }
  }
}
public class Retrivee
{
    public static void main(String args[] )
    {
        System.out.println("please enter 12 elements");
        String a[] = new String[13];
        //int a[]=new int [13];
        a[1]=args[1];
        a[2]=args[2];
        a[3]=args[3];
        a[4]=args[4];
        a[5]=args[5];
        a[6]=args[6];
        a[7]=args[7];
        a[8]=args[8];
        a[9]=args[9];
        a[10]=args[10];
        a[11]=args[11];

    /*
        a[0]=Integer.parseInt (args[0]);
        a[1]=Integer.parseInt (args[1]);
        a[2]=Integer.parseInt (args[2]);
        a[3]=Integer.parseInt (args[3]);
        a[4]=Integer.parseInt (args[4]);
        a[5]=Integer.parseInt (args[5]);
        a[6]=Integer.parseInt (args[6]);
        a[7]=Integer.parseInt (args[7]);
        a[8]=Integer.parseInt (args[8]);
        a[9]=Integer.parseInt (args[9]);
        a[10]=Integer.parseInt (args[10]);
        a[11]=Integer.parseInt (args[11]);
     */

     /* Push push1 =new Push();
        Pop pop1 =new Pop();

     */
    }
}

所以我最后想也许从字符串[]args获取的值不能传递给其他类。所以对代码做了一点改进

class Push //extends Retrive
{
    public Push()
    {
        int i;
        String push[]= new String[10];
        //Retrive ele= new Retrive();
        try
        {
            for(i=0;i<13;i++)
            {
                push[i]=Retrive.a[i];
                System.out.println("value in Push["+i+"]="+push[i]);
            }
        }
        catch(Exception e)
        {
            System.out.println("Stack for push has Overflown");
        }
    }
}

class Pop //extends Push
{
    public Pop()
    {
        int j;
        String pop[]= new String[10];
        //Push ele1= new Push();
        try
        {
            for(j=9;j>=-1;j--)
            {
                pop[j]=Pop.push[j];
                System.out.println("value in Pop["+j+"]="+pop[j]);
            }
        }
        catch(Exception ev)
        {
            System.out.println("Stack for pop is empty");
        }
    }
}

public class Retrive 
{
    public static void main(String args[])
    {
        String a[] = new String[13];
        for(int k=0;k<13;k++)
        {
            int d[]=new int[13];
            d[k]=2*k;
            a[k]=Integer.toString(d[k]);
            System.out.println("a["+k+"]= "+a[k]);
        }
    }
}

然后我尝试了这段代码，但只在一个包含main方法的类中进行了尝试

public class Retrivee
{
    public static void main(String args[] )
    {
        String a[] = new String[13];
        for(int k=0;k<13;k++)
        {
            int d[]=new int[13];
            d[k]=2*k;
            a[k]=Integer.toString(d[k]);
            System.out.println("a["+k+"]= "+a[k]);
        }
        int i;
        String push[]= new String[10];
        try
        {
            for(i=0;i<13;i++)
            {
                push[i]=a[i];
                System.out.println("value in Push["+i+"]="+push[i]);
            }
        }
        catch(Exception e)
        {
            System.out.println("Stack for push has Overflown");
        }
        int j;
        String pop[]= new String[10];
        try
        {
            for(j=9;j>=-1;j--)
            {
                pop[j]=push[j];
                System.out.println("value in Pop["+j+"]="+pop[j]);
            }
        }
        catch(Exception ev)
        {
            System.out.println("Stack for pop is empty");
        }
    }
}

根据第一个示例，我编写了一个小代码

import java.util.*;
public class MyScan 
{
    public static void main(String[] args) 
    {
        //String[] args = new String[10];
        String[] in = new String[4];//= {"1 a 10 . 100 1000","12","2112"};
        in[0]= "1"; //args[0];
        in[1]= "2"; //args[1];
        in[2]= "3"; //args[2];
        String accum;
        for(int x = 0; x <3; x++)   
        {
            Scanner s = new Scanner(in[x]);
            accum = s.nextLine();
            System.out.println(accum);
        }
    }
} 

它扔

  Exception in thread"main" java.lang.ArrayIndexOutOfBoundsException:0
  at MyScan.main<MyScan.java:9>

---

你问了不止一个问题，但是

找不到符号

是编译器告诉您对某个浮动变量有未定义的引用的方式。它甚至会告诉你它们是哪些变量。因此，现在，您没有将

a

或

push

定义为任何内容。将它们声明并实例化为相应的值

您不需要设置

args[]

的大小，因为它本质上是无限的<代码>参数[]在命令行上传入参数时使用：

java program1 param1 param2 param3 param4 ... param99

…并且这些参数中的每一个都将位于

args

中

您可以为

main

编写此代码，其含义相同：

public static void main(String... args) { }

---

以上称为。我建议您仔细查看参考资料。

您的问题是什么？我建议您退后一步，编写另一个小程序，说明关键问题。这被称为一个。这样做可以帮助你更清楚地理解问题，甚至可以自己找到解决方案。如果你仍然有问题，通过这个过程可以让你的问题在你自己的头脑中更加清晰，这样你就可以在这里以一种精确的方式写出你的问题，并更快地得到你想要的帮助。

 in[0]= args[0];
 in[1]= args[1];
 in[2]= args[2];

  Exception in thread"main" java.lang.ArrayIndexOutOfBoundsException:0
  at MyScan.main<MyScan.java:9>

    String a= args[0];
    String b= args[1];

java program1 param1 param2 param3 param4 ... param99

public static void main(String... args) { }