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

下面是我写的代码，希望能够帮助你理解：

public class Array {
    private int[] data; // 存储数据的数组
    private int currentIndex; // 当前已存储数据的数量

    public Array(int capacity) {
        data = new int[capacity];
        currentIndex = 0;
    }

    public boolean add(int num) {
        if (currentIndex == data.length) {
            return false;
        }
        data[currentIndex] = num;
        currentIndex++;
        return true;
    }

    public void expand(int newCapacity) {
        int[] newData = new int[newCapacity];
        for (int i = 0; i < currentIndex; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    public int[] getAll() {
        int[] allData = new int[currentIndex];
        for (int i = 0; i < currentIndex; i++) {
            allData[i] = data[i];
        }
        return allData;
    }
}

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

    public int[] getAll() {
        int[] allData = super.getAll();
        Arrays.sort(allData);
        return allData;
    }
}

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

    public void reverse() {
        int left = 0;
        int right = super.currentIndex - 1;
        while (left < right) {
            int temp = super.data[left];
            super.data[left] = super.data[right];
            super.data[right] = temp;
            left++;
            right--;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Array sortedArray = new SortedArray(5);
        sortedArray.add(3);
        sortedArray.add(1);
        sortedArray.add(4);
        sortedArray.add(2);
        sortedArray.add(5);
        int[] sortedData = sortedArray.getAll();
        System.out.println(Arrays.toString(sortedData));

        SortedArray sortedArray2 = (SortedArray) sortedArray;
        int[] sortedData2 = sortedArray2.getAll();
        System.out.println(Arrays.toString(sortedData2));

        Array reversedArray = new ReversedArray(5);
        reversedArray.add(3);
        reversedArray.add(1);
        reversedArray.add(4);
        reversedArray.add(2);
        reversedArray.add(5);
        int[] reversedData = reversedArray.getAll();
        System.out.println(Arrays.toString(reversedData));

        ReversedArray reversedArray2 = (ReversedArray) reversedArray;
        reversedArray2.reverse();
        int[] reversedData2 = reversedArray2.getAll();
        System.out.println(Arrays.toString(reversedData2));
    }
}

在这个代码中，我们首先定义了一个 `Array` 类来实现整型数组的基本操作，包括数据的增加、容量扩充和获取全部数据等。接着我们定义了两个子类 `SortedArray` 和 `ReversedArray`，分别实现了数组排序和反转两种操作。其中 `SortedArray` 重写了 `getAll` 方法来实现数据的排序，而 `ReversedArray` 定义了 `reverse` 方法来实现数据的首尾交换。最后在 `Test` 类中，我们分别创建了一个 `SortedArray` 和一个 `ReversedArray` 对象，并调用它们的继承方法和独有方法来测试它们的功能。注意，在调用独有方法之前我们需要进行下转型操作，将上转型对象转换为子类对象。