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

以下是实现了整型数组操作类(Array)、数组排序类(ArraySort)和数组反转类(ArrayReverse)的代码：

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 num) {
        if (size == capacity) {
            System.out.println("Array is full, cannot add more elements.");
            return;
        }
        arr[size] = num;
        size++;
    }

    public int[] get() {
        return arr;
    }

    public int getSize() {
        return size;
    }

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

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

    public void sort() {
        Arrays.sort(super.get(), 0, super.getSize());
    }
}

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

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

public class Test {
    public static void main(String[] args) {
        Array array1 = new Array(5);
        array1.add(2);
        array1.add(1);
        array1.add(3);
        System.out.println("Original array:");
        int[] arr = array1.get();
        for (int i = 0; i < array1.getSize(); i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        ArraySort arraySort = (ArraySort) array1;
        arraySort.sort();
        System.out.println("Sorted array:");
        arr = arraySort.get();
        for (int i = 0; i < arraySort.getSize(); i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        Array array2 = new Array(5);
        array2.add(4);
        array2.add(5);
        array2.add(6);
        System.out.println("Original array:");
        arr = array2.get();
        for (int i = 0; i < array2.getSize(); i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        ArrayReverse arrayReverse = (ArrayReverse) array2;
        arrayReverse.reverse();
        System.out.println("Reversed array:");
        arr = arrayReverse.get();
        for (int i = 0; i < arrayReverse.getSize(); i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

在主方法中，我们先创建了一个Array对象array1，并添加了三个元素。然后把array1向上转型为ArraySort对象arraySort，调用其sort()方法进行排序。接着，我们创建了另一个Array对象array2，并添加了三个元素。然后把array2向上转型为ArrayReverse对象arrayReverse，调用其reverse()方法进行反转。

最后，我们使用下转型将arraySort转换为ArraySort类型，将arrayReverse转换为ArrayReverse类型，并分别调用它们的独有方法sort()和reverse()。