继承案例

   现在要求定义一个整型数组的操作类，数组的大小由外部决定，用户可以向数组之中增加数据，以及取得数组中的全部数据。随后在原本的数组之上扩充指定的容量，另外，在此类上派生两个子类：

     Ø  排序类：取得的数组内容是经过排序出来的结果；

     Ø  反转类：取得的数组内容是反转出来的结果；

      本程序要求数组实现动态的内存分配，也就是说里面的数组的大小是由程序外部决定的，则在本类的构造方法中应该为类中的数组进行初始化操作，之后的每次增加数据的时候都应该判断数组的内容是否已经是满的，如果不是满的，则可以向里面增加，如果是满的，则不能增加，另外如果要增加数据的时候则肯定需要有一个指向可以插入的下标，用于记录插入的位置

开发数组的父类

class Array {				// 定义数组操作类
	private int data[]; 	// 定义一个数组对象，此数组由外部设置长度
	private int foot; 		// 表示数组的操作脚标
	/**
	 * 构造本类对象时需要设置大小，如果设置的长度小于0则维持一个大小
	 * @param len 数组开辟时的长度
	 */
	public Array(int len) {
		if (len > 0) { 		// 设置的长度大于0
			this.data = new int[len]; 	// 开辟一个数组
		} else {			// 设置的长度小于等于0
			this.data = new int[1]; 	// 维持一个元素的大小
		}
	}
	/**
	 * 向数组中增加元素
	 * @param num 要增加的数据
	 * @return 如果数据增加成功返回true，如果数组中保存数据已满则返回false
	 */
	public boolean add(int num) {
		if (this.foot < this.data.length) { 		// 有空间保存
			this.data[this.foot++] = num; // 保存数据，修改脚标
			return true; 			// 保存成功
		}
		return false; 		// 保存失败
	}
	/**
	 * 取得所有的数组内容
	 * @return 数组对象引用
	 */
	public int[] getData() {
		return this.data;
	}

开发排序类

class SortArray extends Array {	// 定义排序子类
	public SortArray(int len) {	// Array类里面现在没有无参构造方法
		super(len); 							// 明确调用父类的有参构造，为父类中的data属性初始化
	}
	/**
	 * 因为父类中getData()方法不能满足排序的操作要求，但为了保存这个方法名称，所以进行覆写
	 * 在本方法中要使用java.util.Arrays.sort()来实现数组的排序操作
	 * @return 排序后的数据
	 */
	public int[] getData() {
		java.util.Arrays.sort(super.getData()); // 排序
		return super.getData();// 返回排序后的数据
	}
}

开发反转类

class ReverseArray extends Array {				// 数组反转类
	public ReverseArray(int len) {// Array类里面现在没有无参构造方法
		super(len);		// 调用父类有参构造
	}
	/**
	 * 取得反转后的数组数据，在本方法中会将数据进行首尾交换
	 * @return 反转后的数据
	 */
	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();	// 返回反转后的数据
	}
}