继承的应用实例

定义一个整型数组类，要求包含构造方法，增加数据及输出数据成员方法，并利用数组实现动态内存分配。在此基础上定义以下两个子类：

（1）排序类：对整型数组元素实现排序

（2）反转类：对整型数组元素实现反向存放

 提示：数组的2种定义：

1、 int arr[] = new int[5]        //声明数组并分配内存

2、 int arr[] = { 1,2,3,4,5 }     //数组静态初始化，赋初始值

 代码如下：

class Array{    //整型数组类
    private int temp[];
    private int foot;
    public Array(int len){  //构造方法
        if(len>0){    //判断传入长度则开辟空间
            this.temp = new int[len];
        }else{
            this.temp = new int[1];
        }
    }
    public boolean add(int i) {   //添加元素，开辟空间是否成功
        if(this.foot<this.temp.length){
            this.temp[foot] = i;
            foot++;
            return true;
        }else{
            return false;
        }
    }
    public int[] getArray() {  //获取数组
        return this.temp;
    }

}

class ReverseArray extends Array {  //反转类
    public ReverseArray(int len) {  //调用父类构造方法
        super(len);
    }
    public int[] getArray() {    //覆写父类的方法，将数组进行反转操作
        int t[] = new int[super.getArray().length];
        int count = t.length - 1;
        for(int x=0; x<t.length; x++){
            t[count] = super.getArray()[x];
            count--;
        }
        return t;
    }
}

class SortArray extends Array {  //排序类
    public SortArray(int len) {
        super(len);           //调用父类构造方法
    }
    public int[] getArray() {   //覆写父类的方法，将数组进行排序操作
        java.util.Arrays.sort(super.getArray());
        return super.getArray();
    }
}

public class ExtendsApplication {
    public static void main(String[] args) {
        System.out.println("------测试数组反转------");
        ReverseArray rever = new ReverseArray(5);  //声明并实例化反转类对象，开辟5个空间
        //输出开辟空间是否成功
        System.out.print(rever.add(2) + "\t");
        System.out.print(rever.add(43) + "\t");
        System.out.print(rever.add(25) + "\t");
        System.out.print(rever.add(8) + "\t");
        System.out.print(rever.add(16) + "\t");
        System.out.print(rever.add(34) + "\t");  //第6个空间，开辟空间失败，返回false
        print(rever.getArray());
        System.out.println();
        System.out.println("------测试数组排序------");
        SortArray sort = new SortArray(6);  //声明并实例化排序类对象，开辟6个空间
        System.out.print(sort.add(2) + "\t");
        System.out.print(sort.add(10) + "\t");
        System.out.print(sort.add(9) + "\t");
        System.out.print(sort.add(32) + "\t");
        System.out.print(sort.add(16) + "\t");
        System.out.print(sort.add(7) + "\t");
        print(sort.getArray());
    }
    public static void print(int i[]) {  //输出打印数组
        for (int x=0; x<i.length; x++){
            System.out.print(i[x] + " 、");
        }
    }
}

程序运行结果：

本实例应用了继承的各个概念，包括方法覆写，子类实例化过程，可以发现继承能够提高代码的复用性