Java 此代码中接口和类的正确实现？

我有三部分代码

//IntArray = Class
//IntSequence = Interface
//MyClass = Class

IntArray（这里有问题）——

IntSequence（接口）

MyClass

导入java.util.*

public class MyClass extends IntArray {
    public MyClass(int size) {
        super(size);
    }

    public static ArrayList<Integer> subSequence(int a1, int a2, int[] array) {
        ArrayList<Integer> valuelist = new ArrayList<>();
        for(int i = a1; i <= (a2 + a1); i++)
        {
            if(i >= array.length)
                break;
            else
                valuelist.add(array[i]);
        }
        return valuelist;
    }

}

公共类MyClass在阵列中扩展{
公共MyClass（整数大小）{
超级（尺寸）；
}
公共静态ArrayList子序列（int a1、int a2、int[]数组）{
ArrayList valuelist=新的ArrayList（）；
for（int i=a1；i=array.length）
打破
其他的
添加（数组[i]）；
}
返回价值清单；
}
}

我的问题-我真的不知道如何为IntArray的子序列方法生成返回语句

---

我所要做的就是使用IntArray的方法调用MyClass的子序列方法，并获取参数index、size和IntArray中声明的某个数组。有人能提供一个解决方案来解决这个问题吗？

下面是一个利用Java强大泛型的API解决方案：

import java.util.*;


public class Sequence<T>
{
    private List<T> sequence=new ArrayList<T>();

    public int length()
    {
        return sequence.size();
    }

    public T get(int index)
    {
        return sequence.get(index);
    }

    public void set(int index, T value)
    {
        sequence.set(index,value);
    }

    public List<T> subList(int startIndex, int size)
    {
        return sequence.subList(startIndex, startIndex+size);
    }

    public <T> T[] subArray(int startIndex, int size)
    {
        return (T[])subList(startIndex, size).toArray();
    }
}

import java.util.*；
公共类序列
{
私有列表序列=新的ArrayList（）；
公共整数长度（）
{
返回序列.size（）；
}
公共T获取（整数索引）
{
返回序列.get（索引）；
}
公共无效集（整数索引，T值）
{
序列集（索引、值）；
}
公共列表子列表（int startIndex，int size）
{
返回序列。子列表（startIndex，startIndex+大小）；
}
公共T[]子阵列（整数起始索引，整数大小）
{
return（T[]）子列表（startIndex，size.toArray（）；
}
}

您可以像这样使用它：

class MyClient
{
    public static void main(String[] argv)
    {
        Sequence<Integer> intSeq = new Sequence<Integer>();
        intSeq.set(0,0);
        intSeq.set(1,1);
        int intValue = intSeq.get(1);
        // ...
        Integer[] intArray = intSeq.subArray(1,1);

        Sequence<Double>  doubleSeq = new Sequence<Double>();
        doubleSeq.set(0,1.1);
        doubleSeq.set(1,2.2);
        double doubleValue=doubleSeq.get(1);
        // ...
        Double[] doubleArray = doubleSeq.subArray(1,1);
    }        
}

类MyClient
{
公共静态void main（字符串[]argv）
{
序列intSeq=新序列（）；
intSeq.set（0,0）；
内部序列集（1,1）；
intValue=intSeq.get（1）；
// ...
整数[]intArray=intSeq.子数组（1,1）；
序列doubleSeq=新序列（）；
双序列集（0,1.1）；
双序列集（1,2.2）；
double doubleValue=doubleSeq.get（1）；
// ...
Double[]doubleArray=doubleSeq.子阵列（1,1）；
}        
}

return

valueList.toArray（）

请提供IntArray类的代码。另外，由于您要在MyClass中扩展IntArray，因此要重写整个subSequence（）方法。有什么特别的原因让它成为静态的吗？

import java.util.*;


public class Sequence<T>
{
    private List<T> sequence=new ArrayList<T>();

    public int length()
    {
        return sequence.size();
    }

    public T get(int index)
    {
        return sequence.get(index);
    }

    public void set(int index, T value)
    {
        sequence.set(index,value);
    }

    public List<T> subList(int startIndex, int size)
    {
        return sequence.subList(startIndex, startIndex+size);
    }

    public <T> T[] subArray(int startIndex, int size)
    {
        return (T[])subList(startIndex, size).toArray();
    }
}

class MyClient
{
    public static void main(String[] argv)
    {
        Sequence<Integer> intSeq = new Sequence<Integer>();
        intSeq.set(0,0);
        intSeq.set(1,1);
        int intValue = intSeq.get(1);
        // ...
        Integer[] intArray = intSeq.subArray(1,1);

        Sequence<Double>  doubleSeq = new Sequence<Double>();
        doubleSeq.set(0,1.1);
        doubleSeq.set(1,2.2);
        double doubleValue=doubleSeq.get(1);
        // ...
        Double[] doubleArray = doubleSeq.subArray(1,1);
    }        
}