排序，反转类继承简单数组类

class Array {
	private int data[];
	private int foot;

	public Array(int ten) {
		if (ten > 0) {
			this.data = new int [ten];
		} else {
			this.data = new int [1];
		}
	}
	public boolean add(int num) {
		if ((this.foot) < (this.data.length)) {
			this.data[this.foot++] = num;
			return true;
		}
		return false;
	}
	public int [] getData() {
		return this.data;
	}
}
 //开发排序子类
class SortArray extends Array {
	public SortArray(int ten) {
		super(ten);//父类中没有无参构造，所以用super关键字让父类调用有参构造首先进行实例化
	}
	//由于父类取得数组的方法无法满足子类取得数组方法的要求
	//所以利用方法的覆写
	public int [] getData() {
		java.util.Arrays.sort(super.getData());
		return super.getData();
	}
}

//开发反转子类
class ReverseArray extends Array {
	public ReverseArray(int ten) {
		super(ten);
	}
	public int [] getData() {
		int ten = super.getData().length / 2;
		int head = 0;
		int tail = super.getData().length - 1;
		for (int x = 0; x < ten; x++) {
			int temp = super.getData()[head];
			super.getData()[head] = super.getData()[tail];
			super.getData()[tail] = temp;
			head++;
			tail--;
		}
		return super.getData();
	}
}
	



public class TestDemo {
	public static void main(String[] args) {

		Array arr = new Array(3);
		SortArray arra = new SortArray(3);
		ReverseArray arrb = new ReverseArray(3);
		
		arr.add(10);
		arr.add(6);
		arr.add(7);
		int tempA[] = arr.getData();
		System.out.println("顺序输出");
		for (int x = 0; x < tempA.length; x++) {
			System.out.println(tempA[x] + ",");
		}

		arra.add(10);
		arra.add(6);
		arra.add(7);
		int tempB[] = arra.getData();
		System.out.println("排序输出");
		for (int x = 0; x < tempB.length; x++) {
			System.out.println(tempB[x] + ",");
		}

		arrb.add(10);
		arrb.add(6);
		arrb.add(7);
		int tempC[] = arrb.getData();
		System.out.println("转置输出");
		for (int x = 0; x < tempC.length; x++) {
			System.out.println(tempC[x] + ",");
		}

	}
}