建立一个可以实现整型数组的操作类（Array），而后在里面可以操作的数组的大小由外部来决定，而后在Array类里面需要提供有数组的如下处理：进行数据的增加（如果数据满了则无法增加）、可以实现数组的容量扩充、取得数组全部内容。完成之后在此基础上再派生出两个子类： · 数组排序类：返回的数据必须是排序后的结果； · 数组反转类：可以实现内容的首尾交换。 （2）定义测试类，在主方法中将两个子类上转型对象Array ，调用两个子类的继承方法。通过下转型对象，转换为两个子类对象，调用他们独有方法。

下面是Array类的实现：

public class Array {
    private int[] arr;
    private int size;

    public Array(int capacity) {
        arr = new int[capacity];
        size = 0;
    }

    public void add(int val) {
        if (size == arr.length) {
            throw new IndexOutOfBoundsException("Array is full!");
        }
        arr[size++] = val;
    }

    public void resize(int capacity) {
        int[] newArr = new int[capacity];
        System.arraycopy(arr, 0, newArr, 0, size);
        arr = newArr;
    }

    public int[] toArray() {
        return Arrays.copyOf(arr, size);
    }

    public int size() {
        return size;
    }
}

接下来是数组排序类：

public class SortedArray extends Array {
    public SortedArray(int capacity) {
        super(capacity);
    }

    @Override
    public void add(int val) {
        if (size == arr.length) {
            resize(arr.length * 2);
        }
        int i = size - 1;
        while (i >= 0 && arr[i] > val) {
            arr[i + 1] = arr[i];
            i--;
        }
        arr[i + 1] = val;
        size++;
    }
}

最后是数组反转类：

public class ReversedArray extends Array {
    public ReversedArray(int capacity) {
        super(capacity);
    }

    public void reverse() {
        for (int i = 0; i < size / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[size - i - 1];
            arr[size - i - 1] = temp;
        }
    }
}

下面是测试类：

public class TestArray {
    public static void main(String[] args) {
        Array array = new Array(5);
        array.add(3);
        array.add(2);
        array.add(5);
        int[] arr1 = array.toArray();
        System.out.println(Arrays.toString(arr1)); // [3, 2, 5]

        SortedArray sortedArray = new SortedArray(5);
        sortedArray.add(3);
        sortedArray.add(2);
        sortedArray.add(5);
        int[] arr2 = sortedArray.toArray();
        System.out.println(Arrays.toString(arr2)); // [2, 3, 5]

        ReversedArray reversedArray = new ReversedArray(5);
        reversedArray.add(3);
        reversedArray.add(2);
        reversedArray.add(5);
        reversedArray.reverse();
        int[] arr3 = reversedArray.toArray();
        System.out.println(Arrays.toString(arr3)); // [5, 2, 3]
    }
}

在测试类中，我们创建了三个不同的对象：Array、SortedArray和ReversedArray。我们首先向Array对象中添加了三个元素，然后调用toArray()方法将它们转换为数组并打印出来。接着，我们创建了SortedArray对象，并向其中添加了三个元素。由于SortedArray是按照元素值升序排列的，所以toArray()方法返回的数组也是升序排列的。最后，我们创建了ReversedArray对象，并向其中添加了三个元素。然后，我们调用了ReversedArray对象的reverse()方法，将内容反转之后再次打印出来。