定义一个数组类（Array），要求动态分配大小，并在此基础上实现以下的两个子类：？反转类？排序类

要求定义一个数组类（Array），里面定义了一个整型数组， 但是此整型数组属于动态分配大小，即：所有的大小 由程序指定，并在此基础上实现以下的两个子类：

 ? 反转类：可以将数组的内容反转排列

 ?排序类：可以对数组进行排序的操作

Array类

class Array {
	private int[] arr;
	private int index;// 下标

	// 默认初始化
	public Array() {
		arr = new int[10];
	}

	// 给数组长度初始化
	public Array(int len) {
		if (len > 0) {
			arr = new int[len];
		} else {
			arr = new int[1];
		}
	}

	/**
	 * 可以无限添加数据
	 * 
	 */
	public void addData(int num) {
		if (index == arr.length) {// 长度不够的情况下，实例化一个更大的数组，复制过去
			int[] temp = new int[index + 10];
			// 复制
			System.arraycopy(arr, 0, temp, 0, arr.length);
			// 赋值
			arr = temp;
		}
		arr[index++] = num;
	}

	/**
	 * 
	 * 可以一次添加多个元素
	 */
	public void addDatas(int[] as) {
		for (int i = 0; i < as.length; i++) {
			addData(as[i]);
		}
	}

	/**
	 * 获得数组里面的某一个元素
	 */
	public int get(int i) {
		if (i < index) {
			return arr[i];
		} else {
			return -1;
		}
		// 删除和修改
	}

	public int[] getArr() {// 返回里面不为空的数据的数组
		return Arrays.copyOf(arr, index);
	}

	public void setArr(int[] arr) {
		this.arr = arr;
	}

	public int getIndex() {
		return index;
	}

	public void setIndex(int index) {
		this.index = index;
	}

}

反转类

class RevArray extends Array {
	public RevArray(int len) {
		super(len);
	}

	/**
	 * 反转
	 */
	public int[] revser() {
		int[] arr = getArr();
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
		return arr;
	}
}

排序类

class SortArray extends Array {
	public SortArray() {
		super();
	}

	public SortArray(int len) {
		super(len);
	}

	public int[] sort() {
		int[] arr = getArr();
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		return arr;
	}

}

/

测试类

public class D6 {

	public static void main(String[] args) {
//		Array a =new Array(2);
//		a.addData(20);
//		a.addData(30);
//		a.addData(15);
//		a.addData(49);
//		a.addData(88);
//		a.addData(20);
//		a.addData(12);
//		System.out.println(Arrays.toString(a.getArr()));
//		System.out.println(a.get(2));
		
		//反转
//		RevArray revArray = new RevArray(10);
//		revArray.addData(20);
//		revArray.addData(13);
//		revArray.addData(67);
		int[] as = {20,10,23,40,35,4,21};
//		revArray.addDatas(as);
//		revArray.addData(63);
//		revArray.addData(32);
//		System.out.println(Arrays.toString(revArray.getArr()));
//		int[] revAr = revArray.revser();
//		System.out.println(Arrays.toString(revAr));
		//排序
		SortArray sortArray = new SortArray();
		sortArray.addDatas(as);
		sortArray.addData(43);
		sortArray.addData(56);
		System.out.println(Arrays.toString(sortArray.getArr()));
		int[] sortAr = sortArray.sort();
		System.out.println(Arrays.toString(sortAr));
	
		
	}

}