定义一个数组操作类（Array），里面定义了一个整型数组，由外部传入数组的大小，可以实现数据的保存以及输出

标题定义一个数组操作类（Array），里面定义了一个整型数组，由外部传入数组的大小，可以实现数据的保存以及输出

即：所有的大小由程序指定，并在此基础上实现以下的两个子类：
• 排序类：可以对数组进行排序的显示
• 反转类：可以将数组的内容反转显示

基础类

class Array{
    private int []data;
    private int foot; // 作为保存的脚标
    public Array(int len){// 实例化本类对象时必须设置数组大小
        if(len <= 0){
            this.data = new int[1]; // 至少维持1个大小的数组
        }else{
            this.data = new int[len];// 根据传人的大小定义数组长度
        }
    }
    public boolean add(int num){//如果保存成功返回true，否则是false
        if(this.foot<this.data.length){//还有空间可以保存数据
            this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
            return true;
        }
        return false;
    }
    public int[] getData(){ // 返回全部数据
        return this.data;
    }
    public void inc(int size){ // 扩充数组大小，在已有数据基础上扩充
        if(size>0){
            int[] newData = new int[this.data.length+size];
            System.arraycopy(this.data,0,newData,0,this.data.length);
            this.data = newData;// 改变引用
        }
    }
}
public class arrayOperation{
    public static void main(String args[]){
        Array arr = new Array(5);//开始有5个元素
        System.out.println(arr.add(90));
        System.out.println(arr.add(10));
        System.out.println(arr.add(100));
        System.out.println(arr.add(60));
        System.out.println(arr.add(1));
        //if(arr.add(99) == false){
            arr.inc(3);// 扩充容量
            System.out.println(arr.add(20));
            System.out.println(arr.add(30));
            System.out.println(arr.add(70));
        //}
        //int temp [] = arr.getData();
        for(int x = 0;x<arr.getData().length;x++){
            System.out.println(arr.getData()[x]+",");
        }
    }
}

排序数组类
对于排序的操作从本质上来讲，与数组Array类的操作区别不大，只不过它最后返回的结果应该是排序的
getData()方法负责返回结果，但是这个结果没有排序，不过方法名称好用，利用覆写来解决此类问题
范例：定义排序数组子类

class Array{
    private int []data;
    private int foot; // 作为保存的脚标
    public Array(int len){// 实例化本类对象时必须设置数组大小
        if(len <= 0){
            this.data = new int[1]; // 至少维持1个大小的数组
        }else{
            this.data = new int[len];// 根据传人的大小定义数组长度
        }
    }
    public boolean add(int num){//如果保存成功返回true，否则是false
        if(this.foot<this.data.length){//还有空间可以保存数据
            this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
            return true;
        }
        return false;
    }
    public int[] getData(){ // 返回全部数据
        return this.data;
    }
    public void inc(int size){ // 扩充数组大小，在已有数据基础上扩充
        if(size>0){
            int[] newData = new int[this.data.length+size];
            System.arraycopy(this.data,0,newData,0,this.data.length);
            this.data = newData;// 改变引用
        }
    }
}
class SortArray extends Array{ // 排序子类
    public SortArray(int len){
        super(len);
    }
    public int[] getData(){
        java.util.Array.sort(super.getData());
        return super.getData();
    }
}
public class arrayOperation{
    public static void main(String args[]){
        SortArray arr = new SortArray(5);//开始有5个元素
        System.out.println(arr.add(90));
        System.out.println(arr.add(10));
        System.out.println(arr.add(100));
        System.out.println(arr.add(60));
        System.out.println(arr.add(1));
        //if(arr.add(99) == false){
            arr.inc(3);// 扩充容量
            System.out.println(arr.add(20));
            System.out.println(arr.add(30));
            System.out.println(arr.add(70));
        //}
        //int temp [] = arr.getData();
        for(int x = 0;x<arr.getData().length;x++){
            System.out.println(arr.getData()[x]+",");
        }
    }
}

反转子类
只是在使用getData（）方法的时候返回的是一个反转后的结果
范例：定义排序数组子类

class Array{
    private int []data;
    private int foot; // 作为保存的脚标
    public Array(int len){// 实例化本类对象时必须设置数组大小
        if(len <= 0){
            this.data = new int[1]; // 至少维持1个大小的数组
        }else{
            this.data = new int[len];// 根据传人的大小定义数组长度
        }
    }
    public boolean add(int num){//如果保存成功返回true，否则是false
        if(this.foot<this.data.length){//还有空间可以保存数据
            this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
            return true;
        }
        return false;
    }
    public int[] getData(){ // 返回全部数据
        return this.data;
    }
    public void inc(int size){ // 扩充数组大小，在已有数据基础上扩充
        if(size>0){
            int[] newData = new int[this.data.length+size];
            System.arraycopy(this.data,0,newData,0,this.data.length);
            this.data = newData;// 改变引用
        }
    }
}
class SortArray extends Array{ // 排序子类
    public SortArray(int len){
        super(len);
    }
    public int[] getData(){
        java.util.Array.sort(super.getData());
        return super.getData();
    }
}
class ReverseArray extends Array{
    public ReverseArray(int len){
        super(len);
    }
    public int[] getData(){
        int center = super.getData().length/2;
        int head = 0;
        int tail = super.getData().length-1;
        for(int x = 0;x<center:x++){
            int temp = super.getData()[head];
            super.getData()[head] = super.getData()[tail];
            super.getData()[tail] = temp;
            head ++;
            tail--;
        }
        return super.getData();
    }
}
public class arrayOperation{
    public static void main(String args[]){
        ReverseArray arr = new ReverseArray(5);//开始有5个元素
        System.out.println(arr.add(90));
        System.out.println(arr.add(10));
        System.out.println(arr.add(100));
        System.out.println(arr.add(60));
        System.out.println(arr.add(1));
        arr.inc(3);// 扩充容量
        System.out.println(arr.add(20));
        System.out.println(arr.add(30));
        System.out.println(arr.add(70));
        int temp[] = arr.getData();
        for(int x = 0;x<temp.length;x++){
            System.out.println(temp[x]+",");
        }
    }
}