讲解一个继承的实现思路
要求定义一个数组操作类(Array类),在这个类里面可以进行整型数组的操作,由外部传入数组的大小
,并且要求实现数据的保存以及数据的输出,同时用户可以在外部调整已有数组大小(只能够扩大数组容量)
随后在这个类上要求派生出两个子类
排序类:通过此类取得数据可以进行排序
反转类:通过此类取得的数组数据要求采用到倒序的方式输出
在整个的开发过程之中暂时不要去考虑子类的问题,只考虑父类自己的设计
数组的核心操作类:Array
分析:
1.类里面可以进行整型数组的操作
里面应该有一个专门的整型数组
class Array{
private int []data;// 数组并不知道具体的长度
}
2.可以通过外部传入数组的大小,需要提供有一个构造方法,并且这个构造方法里面需要接收一个数组大小的参数
public Array(int lan){// 实例化本类对象时必须设置数组大小
if(len <= 0){
this.data = new int[1]; // 至少维持1个大小的数组
}else{
this.data = new int[len];// 根据传人的大小定义数组长度
}
}
3.保存 数据,根据索引保存
private int foot; // 作为保存的脚标
public boolean add(int num){//如果保存成功返回true,否则是false
if(this.foot<this.data.length){//还有空间可以保存数据
this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
return true;
}
return false;
}
4.数据的输出不可能在类中直接完成,一定要返回给被调用处处理
public int[] getData(){ // 返回全部数据
return this.data;
}
5.可以在外部调整已有数组大小(只能够扩大数组容量)
public void inc(int size){ // 扩充数组大小,在已有数据基础上扩充
if(size>0){
int[] newData = new int[this.data.length+size];
System.arraycopy(this.data,0,newData,0,this.data,length);
this.data = newData;// 改变引用
}
}
范例:程序的测试
class Array{
private int []data;
private int foot; // 作为保存的脚标
public Array(int len){// 实例化本类对象时必须设置数组大小
if(len <= 0){
this.data = new int[1]; // 至少维持1个大小的数组
}else{
this.data = new int[len];// 根据传人的大小定义数组长度
}
}
public boolean add(int num){//如果保存成功返回true,否则是false
if(this.foot<this.data.length){//还有空间可以保存数据
this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
return true;
}
return false;
}
public int[] getData(){ // 返回全部数据
return this.data;
}
public void inc(int size){ // 扩充数组大小,在已有数据基础上扩充
if(size>0){
int[] newData = new int[this.data.length+size];
System.arraycopy(this.data,0,newData,0,this.data.length);
this.data = newData;// 改变引用
}
}
}
public class arrayOperation{
public static void main(String args[]){
Array arr = new Array(5);//开始有5个元素
System.out.println(arr.add(90));
System.out.println(arr.add(10));
System.out.println(arr.add(100));
System.out.println(arr.add(60));
System.out.println(arr.add(1));
//if(arr.add(99) == false){
arr.inc(3);// 扩充容量
System.out.println(arr.add(20));
System.out.println(arr.add(30));
System.out.println(arr.add(70));
//}
//int temp [] = arr.getData();
for(int x = 0;x<arr.getData().length;x++){
System.out.println(arr.getData()[x]+",");
}
}
}
2.排序数组类
对于排序的操作从本质上来讲,与数组Array类的操作区别不大,只不过它最后返回的结果应该是排序的
getData()方法负责返回结果,但是这个结果没有排序,不过方法名称好用,利用覆写来解决此类问题
范例:定义排序数组子类
class Array{
private int []data;
private int foot; // 作为保存的脚标
public Array(int len){// 实例化本类对象时必须设置数组大小
if(len <= 0){
this.data = new int[1]; // 至少维持1个大小的数组
}else{
this.data = new int[len];// 根据传人的大小定义数组长度
}
}
public boolean add(int num){//如果保存成功返回true,否则是false
if(this.foot<this.data.length){//还有空间可以保存数据
this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
return true;
}
return false;
}
public int[] getData(){ // 返回全部数据
return this.data;
}
public void inc(int size){ // 扩充数组大小,在已有数据基础上扩充
if(size>0){
int[] newData = new int[this.data.length+size];
System.arraycopy(this.data,0,newData,0,this.data.length);
this.data = newData;// 改变引用
}
}
}
class SortArray extends Array{ // 排序子类
public SortArray(int len){
super(len);
}
public int[] getData(){
java.util.Array.sort(super.getData());
return super.getData();
}
}
public class arrayOperation{
public static void main(String args[]){
SortArray arr = new SortArray(5);//开始有5个元素
System.out.println(arr.add(90));
System.out.println(arr.add(10));
System.out.println(arr.add(100));
System.out.println(arr.add(60));
System.out.println(arr.add(1));
//if(arr.add(99) == false){
arr.inc(3);// 扩充容量
System.out.println(arr.add(20));
System.out.println(arr.add(30));
System.out.println(arr.add(70));
//}
//int temp [] = arr.getData();
for(int x = 0;x<arr.getData().length;x++){
System.out.println(arr.getData()[x]+",");
}
}
}
子类定义过程之中需要继续保留父类已有功能,当发现功能不合适的时候利用覆写解决此类问题
3.反转子类
只是在使用getData()方法的时候返回的是一个反转后的结果
范例:定义排序数组子类
class Array{
private int []data;
private int foot; // 作为保存的脚标
public Array(int len){// 实例化本类对象时必须设置数组大小
if(len <= 0){
this.data = new int[1]; // 至少维持1个大小的数组
}else{
this.data = new int[len];// 根据传人的大小定义数组长度
}
}
public boolean add(int num){//如果保存成功返回true,否则是false
if(this.foot<this.data.length){//还有空间可以保存数据
this.data[this.foot ++] = num; // 保存数据的同时改变foot的内容
return true;
}
return false;
}
public int[] getData(){ // 返回全部数据
return this.data;
}
public void inc(int size){ // 扩充数组大小,在已有数据基础上扩充
if(size>0){
int[] newData = new int[this.data.length+size];
System.arraycopy(this.data,0,newData,0,this.data.length);
this.data = newData;// 改变引用
}
}
}
class SortArray extends Array{ // 排序子类
public SortArray(int len){
super(len);
}
public int[] getData(){
java.util.Array.sort(super.getData());
return super.getData();
}
}
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;
head ++;
tail--;
}
return super.getData();
}
}
public class arrayOperation{
public static void main(String args[]){
ReverseArray arr = new ReverseArray(5);//开始有5个元素
System.out.println(arr.add(90));
System.out.println(arr.add(10));
System.out.println(arr.add(100));
System.out.println(arr.add(60));
System.out.println(arr.add(1));
arr.inc(3);// 扩充容量
System.out.println(arr.add(20));
System.out.println(arr.add(30));
System.out.println(arr.add(70));
int temp[] = arr.getData();
for(int x = 0;x<temp.length;x++){
System.out.println(temp[x]+",");
}
}
}
在以后进行代码设计的时候,实际上你设计的初期环境依然是只考虑单独类
而后在设计子类的时候,如果不是必须的情况下,不用特别多的考虑扩充大量的新方法(优先考虑的是利用覆写这一概念去完善父类的方法)
以后如果考虑类的继承关系的时候:一个类绝对不要去继承一个已经实现好的类,如果非要继承就去继承抽象类或接口
4.总结
面向对象继承关系的设计思路:
父类的设计很重要,父类中的方法必须要有意义
子类定义的时候就应该已经可以明确该类的功能是什么
如果子类在进行操作中发现父类的方法不好用了,优先考虑的是覆写,而不是建立新的方法