数组操作

现在定义一个数组（整形数组）的操作类，在这个类中有几个要求：

• 数组的大小由类创建对象的时候动态决定；
• 可以通过类向数组中进行数组的保存，保存的时候需要考虑到数组的大小问题；
• 如果发现数组空间不足，则可以进行数组长度的动态扩充；
• 可以取得数组的全部数据（增加顺序）。

而后在这一基础上要求继续扩展两个派生类：

• 可以进行数组的排序处理；
• 可以进行数组的反转处理。

定义Array类

在Array类的定义只需要根据自己的需求完成所需要的功能即可，按照标准做。

class Array { //定义一个专门进行数组的操作类
	private int[] data; //定义一个整形数组，大小由外部决定
	private int foot = 0; //进行数组数据的脚表操作
	public Array(int len) { //如果要想使用Array类必须设置数组大小
		if(len > 0) {
			this.data = new int[len];
		} else {
			this.data = new int[1];
		}
	}
	public void inc(int num) {//动态扩展，如果此时传入一个7，则表示在已有的基础上，数组长度追加3
		int[] newData = new int[this.data.length + num];
		System.arraycopy(this.data, 0, newData, 0, this.data.length);
		this.data = newData;
	}
	public boolean add(int num) { //向数组进行数据的保存
		if(this.foot  >= this.data.length) { //超出空间
			return false;
		}
		//先进性数组的数据保存，而后foot值加1
		this.data[this.foot++] = num;
		return true;
	}
	public int[] getData() {//取得全部数组内容
		return this.data;
	}
}
public class TestDemo {
	public static void main(String[] args) {
		Array arr = new Array(5);
		System.out.println(arr.add(1));
		System.out.println(arr.add(2));
		System.out.println(arr.add(3));
		System.out.println(arr.add(4));
		System.out.println(arr.add(5));
		arr.inc(3); //扩充数组
		System.out.println(arr.add(6));
		System.out.println(arr.add(10));
		System.out.println(arr.add(20));
		int[] result = arr.getData();
		for(int x = 0; x < result.length; x++) {
			System.out.print(result[x] + "、");
	}
	}
} 

定义排序扩展类：SortArray

如果要进行排序的处理操作，那么肯定在取得了全部数据的时候里面的内容应该是排序好的，同时在该类的操作过程之中应该具备：数据追加、数组扩充、取得全部数据（父类中的getDate()方法作为一个获取数据的标准，应该保留）。

范例： 定义排序子类

class Array { //定义一个专门进行数组的操作类
	private int[] data; //定义一个整形数组，大小由外部决定
	private int foot = 0; //进行数组数据的脚表操作
	public Array(int len) { //如果要想使用Array类必须设置数组大小
		if(len > 0) {
			this.data = new int[len];
		} else {
			this.data = new int[1];
		}
	}
	public void inc(int num) {//动态扩展，如果此时传入一个7，则表示在已有的基础上，数组长度追加3
		int[] newData = new int[this.data.length + num];
		System.arraycopy(this.data, 0, newData, 0, this.data.length);
		this.data = newData;
	}
	public boolean add(int num) { //向数组进行数据的保存
		if(this.foot  >= this.data.length) { //超出空间
			return false;
		}
		//先进性数组的数据保存，而后foot值加1
		this.data[this.foot++] = num;
		return true;
	}
	public int[] getData() {//取得全部数组内容
		return this.data;
	}
}
class SortArray extends Array { //这样可以直接继承父类中的所有已经存在的操作方法
	public SortArray(int num) {//父类中没有无参构造方法，所以此时子类中必须明确的调用父类中的构造方法
		super(num);  //父类中过支持数组创建
	}
	//父类中取数据的方法名称很标准，但是功能不足，
	//又希望继续使用这个方法名称，那么就需要对方法进行扩充，
	//扩充这个方法就是方法覆写的核心作用
	public int[] getData() {
		java.util.Arrays.sort(super.getData());
		return super.getData();
	}
}
public class TestDemo {
	public static void main(String[] args) {
		Array arr = new SortArray(5);
		System.out.println(arr.add(1));
		System.out.println(arr.add(2));
		System.out.println(arr.add(3));
		System.out.println(arr.add(4));
		System.out.println(arr.add(5));
		arr.inc(3); //扩充数组
		System.out.println(arr.add(6));
		System.out.println(arr.add(10));
		System.out.println(arr.add(20));
		int[] result = arr.getData();
		for(int x = 0; x < result.length; x++) {
			System.out.print(result[x] + "、");
	}
	}
} 

也就是说不同的子类一可能要针对方法进行部分的扩展。

定义反转子类：ReverseArray

反转子类的最大特点在于：取得的数据是其保存顺序的相反内容。整体的风格实际上和排序数组子类是一样的。

范例： 定义反转子类

 class Array { //定义一个专门进行数组的操作类
	private int[] data; //定义一个整形数组，大小由外部决定
	private int foot = 0; //进行数组数据的脚表操作
	public Array(int len) { //如果要想使用Array类必须设置数组大小
		if(len > 0) {
			this.data = new int[len];
		} else {
			this.data = new int[1];
		}
	}
	public void inc(int num) {//动态扩展，如果此时传入一个7，则表示在已有的基础上，数组长度追加3
		int[] newData = new int[this.data.length + num];
		System.arraycopy(this.data, 0, newData, 0, this.data.length);
		this.data = newData;
	}
	public boolean add(int num) { //向数组进行数据的保存
		if(this.foot  >= this.data.length) { //超出空间
			return false;
		}
		//先进性数组的数据保存，而后foot值加1
		this.data[this.foot++] = num;
		return true;
	}
	public int[] getData() {//取得全部数组内容
		return this.data;
	}
}
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;
			tail--;
			head++;
		}
		return super.getData();
	}
}
public class TestDemo {
	public static void main(String[] args) {
		Array arr = new ReverseArray(5);
		System.out.println(arr.add(1));
		System.out.println(arr.add(2));
		System.out.println(arr.add(3));
		System.out.println(arr.add(4));
		System.out.println(arr.add(5));
		arr.inc(3); //扩充数组
		System.out.println(arr.add(6));
		System.out.println(arr.add(10));
		System.out.println(arr.add(20));
		int[] result = arr.getData();
		for(int x = 0; x < result.length; x++) {
			System.out.print(result[x] + "、");
	}
	}
} 

本程序很完美表现出对继承的概念和覆写的核心意义