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

以下是实现整型数组操作类的代码：

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

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

    public void add(int value) {
        if (size == capacity) {
            return; // 数组已满，无法添加
        }
        arr[size] = value;
        size++;
    }

    public void resize(int newCapacity) {
        int[] newArr = new int[newCapacity];
        for (int i = 0; i < size; i++) {
            newArr[i] = arr[i];
        }
        arr = newArr;
        capacity = newCapacity;
    }

    public int[] getAll() {
        int[] result = new int[size];
        for (int i = 0; i < size; i++) {
            result[i] = arr[i];
        }
        return result;
    }
}

以下是派生出的数组排序类的代码：

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

    public void sort() {
        Arrays.sort(getAll());
    }
}

以下是派生出的数组反转类的代码：

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

    public void reverse() {
        int[] all = getAll();
        for (int i = 0, j = size - 1; i < j; i++, j--) {
            int temp = all[i];
            all[i] = all[j];
            all[j] = temp;
        }
    }
}

以下是测试类的代码：

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);
        sortedArray.resize(10);
        sortedArray.sort();
        int[] sortedAll = sortedArray.getAll();
        for (int value : sortedAll) {
            System.out.print(value + " ");
        }
        System.out.println();

        Array reversedArray = new ReversedArray(5);
        reversedArray.add(1);
        reversedArray.add(2);
        reversedArray.add(3);
        reversedArray.add(4);
        reversedArray.add(5);
        reversedArray.resize(10);
        ((ReversedArray) reversedArray).reverse();
        int[] reversedAll = reversedArray.getAll();
        for (int value : reversedAll) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

输出结果为：

1 2 3 4 5 
5 4 3 2 1