Java数组作业

我是堆栈溢出新手，我正在努力帮助一位朋友完成编程作业

到目前为止，我们有这个

package range;

import java.util.Arrays;
import java.util.Scanner;

public class Range 
{
    static int[] series = new int[100];
    static int seriesLength = 0;
    public static void main(String[] args) 
    {
        Scanner t  = new Scanner(System.in);
        boolean run = true;

        while(run)
        {
            int option;
            System.out.println("1. Loading a range of up to 100 numbers");
            System.out.println("2. Showing the range of given(loaded) numbers");
            System.out.println("3. Determination of the middle value of the series");
            System.out.println("4. Determination of the biggest element of the series");
            System.out.println("5. Determination of the smallest element of the series\n");
            System.out.println("Enter the number of the option you want (1-5), or 0 to end");
            option = t.nextInt();

            switch(option)
            {
                case 1:
                {
                    System.out.println("Please input a number from 1 -100");
                    seriesLength = t.nextInt();
                    System.out.println(seriesLength);
                    if((seriesLength < 1) || (seriesLength > 100))
                    {
                        System.out.println("Invalid input, series must be between 1 and 100.\nPress any key to try again.\n");
                        break;
                    }
                    for(int i = 0; i < seriesLength; i++)
                    {
                        series[i] = i+1;
                    } 
                    break;
                }
                case 2:
                {
                    System.out.println(seriesLength);
                    if(seriesLength == 0) 
                    {
                        System.out.println("You must first load a series of numbers\n");
                        break;              

                    }
                    showSeries(series, seriesLength);
                    break;
                }
                case 3:
                {
                    if(seriesLength == 0) 
                    {
                        System.out.println("You must first load a series of numbers\n"); 
                        break;      
                    }
                    middleNum(series, seriesLength);
                    break;
                }
                case 4:
                {
                    if(seriesLength == 0) 
                    {
                        System.out.println("You must first load a series of numbers\n"); 
                        break;              

                    }
                    biggestNum(series, seriesLength);
                    break;
                }
                case 5:
                {
                    if(seriesLength == 0) 
                    {
                        System.out.println("You must first load a series of numbers\n"); 
                        break;              

                    }
                    smallestNum(series, seriesLength);
                    break;
                }

                case 0:
                {
                    System.out.println("BYE, DOBRO DOBRO."); 
                    run = false;
                    break;                  
                }
                default:
                {
                    System.out.println("Invalid input"); 
                    break;
                }
            }
        }
    }

    public static void showSeries(int[] input, int range)
    {
        for(int i = 0; i < range; i++)
        {
            System.out.println(input[i]);
        }
    }

    public static void biggestNum(int[] input, int range)
    {
        Arrays.sort(input);
        System.out.println(input[0]);
    }

    public static void middleNum(int[] input, int range)
    {
        int Middle = input.length / 2;
        if ((input.length % 2) > 0)
        {
            System.out.println(input[Middle]);
        }
        else 
        {
            System.out.println((input[Middle-1] + input[Middle]) / 2.0);
        }
    }

    public static void smallestNum(int[] input, int range)
    {
        Arrays.sort(input);
        for(int i = 0; i < range; i++)
        {
            System.out.println(input[i]);
        }
    }
}

包装范围；
导入java.util.array；
导入java.util.Scanner；
公共类范围
{
静态整数[]系列=新整数[100]；
静态int系列长度=0；
公共静态void main（字符串[]args）
{
扫描器t=新扫描器（System.in）；
布尔运行=真；
while（运行）
{
int选项；
System.out.println（“1.加载最多100个数字的范围”）；
System.out.println（“2.显示给定（加载）数字的范围”）；
System.out.println（“3.系列中间值的确定”）；
System.out.println（“4.确定系列中的最大元素”）；
System.out.println（“5.系列中最小元素的测定\n”）；
System.out.println（“输入所需选项的编号（1-5），或0结束”）；
option=t.nextInt（）；
开关（选件）
{
案例1：
{
System.out.println（“请输入1-100之间的数字”）；
seriesLength=t.nextInt（）；
System.out.println（系列长度）；
如果（（序列长度<1）| |（序列长度>100））
{
System.out.println（“无效输入，序列必须介于1和100之间。\n按任意键重试。\n”）；
打破
}
for（int i=0；i0）
{
System.out.println（输入[中间]）；
}
其他的
{
System.out.println（（输入[Middle-1]+输入[Middle]）/2.0）；
}
}
公共静态void smallestNum（int[]输入，int范围）
{
数组。排序（输入）；
对于（int i=0；i

任务是编写一个程序，使用菜单处理一组数字 几乎没有选择。但是每个选项的任务也需要是一个单独的方法，主方法只需要显示菜单并根据所选的数字（选项）调用每个方法。还需要检查用户错误，例如，如果在选项1之前选择了选项2，或者选择的选项不存在等等

---

我对如何进行感到困惑，因为我不是java方面的专家。考虑到任务定义了唯一可以使用的东西，该怎么做呢？

也许您需要类似的东西，其中show series方法实际设置了数组，因此其他方法可以使用该数组

static int[] series = new int[100];
static int seriesLength = 0;
...
// Get the input for range

public static void showSeries(int range)
{
    seriesLength = range;
    series = new int[seriesLength];
    for (int i = 0; i < series.legnth; i++) {
        series[i] = i;
        System.out.print(series[i] + " ");
    }
}

static int[]系列=新int[100]；
静态int系列长度=0；
...
//获取范围的输入
公共静态void showSeries（整数范围）
{
序列长度=范围；
系列=新整数[系列长度]；
对于（int i=0；i

---

因为第一个方法必须是第一个被调用的方法，所以数组将被设置。那么其他方法就不必接受任何参数，因为数组已经设置好了，它们可以只使用静态数组。

那么你是在问如何在Java中编写和使用方法吗？什么是“对如何继续感到困惑”呢？方法是否返回数组？我对如何正确地执行这些方法感到困惑。数组不是动态的，必须具有定义的大小。但我要做的是