Java基础知识回顾之自定义数组

Java基础知识回顾之数组简介
Java基础知识回顾之数组与方法参数的传递
Java基础知识回顾之自定义数组

说明

了解大致数组的相关操作之后，我们可以尝试自己实现一个数组类，能够具有常用的数组功能。

需求说明

要求定义一个数组操作类（Array类），在这个类里面可以进行整形数组的操作，由外部传入数组的大小来确定数组的长度，并且要求实现数据的保存以及数据的输出。

并且能有两个派生子类：

1. 排序类：通过此类取得的数据可以进行排序；
2. 反转类：通过此类取得的数组数据要求采用倒序的方式输出。

需求拆分

需要定义的类：

按照需求说名，我们需要一个父类（Array类），以及两个子类：排序类（SortArray类） 和 反转类（ReverseArray类）

需要具有的功能：
父类：能接受、保存整形的数据；外部传入数组的长度；能按照数组格式输出。
排序类：对数据进行排序。
反转类：对数据进行倒叙输出。

父类实现

class Array {
	private int data[]; // 定义一个数组，用于保存传入数组的数据
	// 表示数组操作的下标，由于我们需要知道当前操作的是哪个下标，保证不会数组越界
	private int index;

	public Array(int length) { // 构造器，接受传入的数组长度
		if (length == 0) {
			this.data = new int[1]; // 当长度为0 的时候，保证能有一个元素存入
		} else {
			this.data = new int[length];// 根据传入的长度初始化
		}
	}

	/**
	 * 增加数组元素
	 * @param num
	 * @return
	 */
	public boolean add(int num) {
		if( this.index < this.data.length ) {	// 防止数组下标越界
			this.data[index] = num;
			
			index++;	// 保存完数据之后，下标增加
			return true;
		}
		return false;
	}
	
	public int[] getData(){
		return this.data;	// 获取数据
	}

}

public class TestDemo {
	public static void main(String[] args) {
		Array arr = new Array(3);
		System.out.println(arr.add(1));
		System.out.println(arr.add(2));
		System.out.println(arr.add(3));
		System.out.println(arr.add(100));
		int temp[] = arr.getData();
		for (int x = 0; x < temp.length; x++) {
			System.out.println(temp[x]);
		}

	}
}

控制台结果：
可以看到，当添加第四个元素的时候，就添加不进去了。

true
true
true
false
1
2
3

排序类实现

import java.util.Arrays;

//定义一个排序数组子类
class SortArray extends Array{

	// Array类里面现在没有无参构造的方法
	public SortArray(int length) {
		// 通过 super 调用，可以初始化出父类的 data数据
		super(length);	// 调用父类的有参构造方法
	}
	
	// 这里我们方法的重载，来保持和父类中的获取方法一致
	public int[] getData() {
		Arrays.sort(super.getData());
		return super.getData();
	}
	
}

public class TestDemo {
	public static void main(String[] args) {
		SortArray arr = new SortArray(3);
		arr.add(1);
		arr.add(8);
		arr.add(5);
		
		int temp[] = arr.getData();
		for (int x = 0; x < temp.length; x++) {
			System.out.println(temp[x]);	//1 	5	8
		}
	}
}

反转类实现

// 定义一个反转类
class ReverseArray extends Array {

	public ReverseArray(int length) {
		super(length);
	}
	
	// 反转数据的逻辑，同样是保持和父类一样的方法名称，使用方法的重载实现
	public int[] getData() {// 需要得到的是反转数据
		
		int center = super.getData().length / 2;	// 获取数组的中间长度值
		int head = 0;								// 用于计算统计从头开始的数组值
		int tail = super.getData().length - 1;		// 由于数组的下标为0，减一 是为了从后开始计算
		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();
	}
}

public class TestDemo {
	public static void main(String[] args) {
		ReverseArray arr = new ReverseArray(3);	// Array arr = new ReverseArray(3); 也可以通过向下转型的方式实现
		arr.add(1);
		arr.add(8);
		arr.add(5);
		
		int temp[] = arr.getData();
		for (int x = 0; x < temp.length; x++) {
			System.out.println(temp[x]);	//5	8	1
		}
	}
}

最后附上完整的代码

import java.util.Arrays;

class Array {
	private int data[]; // 定义一个数组，用于保存传入数组的数据
	// 表示数组操作的下标，由于我们需要知道当前操作的是哪个下标，保证不会数组越界
	private int index;

	public Array(int length) { // 构造器，接受传入的数组长度
		if (length == 0) {
			this.data = new int[1]; // 当长度为0 的时候，保证能有一个元素存入
		} else {
			this.data = new int[length];// 根据传入的长度初始化
		}
	}

	/**
	 * 增加数组元素
	 * @param num
	 * @return
	 */
	public boolean add(int num) {
		if( this.index < this.data.length ) {	// 防止数组下标越界
			this.data[index] = num;
			
			index++;	// 保存完数据之后，下标增加
			return true;
		}
		return false;
	}
	
	public int[] getData(){
		return this.data;	// 获取数据
	}

}


//定义一个排序数组子类
class SortArray extends Array{

	// Array类里面现在没有无参构造的方法
	public SortArray(int length) {
		// 通过 super 调用，可以初始化出父类的 data数据
		super(length);	// 调用父类的有参构造方法
	}
	
	// 这里我们方法的重载，来保持和父类中的获取方法一致
	public int[] getData() {
		Arrays.sort(super.getData());
		return super.getData();
	}
}

// 定义一个反转类
class ReverseArray extends Array {

	public ReverseArray(int length) {
		super(length);
	}
	
	// 反转数据的逻辑，同样是保持和父类一样的方法名称，使用方法的重载实现
	public int[] getData() {// 需要得到的是反转数据
		
		int center = super.getData().length / 2;	// 获取数组的中间长度值
		int head = 0;								// 用于计算统计从头开始的数组值
		int tail = super.getData().length - 1;		// 由于数组的下标为0，减一 是为了从后开始计算
		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();
	}
}

public class TestDemo {
	public static void main(String[] args) {
		ReverseArray arr = new ReverseArray(3);	// Array arr = new ReverseArray(3); 也可以通过向下转型的方式实现
		arr.add(1);
		arr.add(8);
		arr.add(5);
		
		int temp[] = arr.getData();
		for (int x = 0; x < temp.length; x++) {
			System.out.println(temp[x]);	//5	8	1
		}
	}
}