教你从实战中领悟继承（下） | 带你学《Java面向对象编程》之四十四

上一篇：教你从实战中领悟继承（中） | 带你学《Java面向对象编程》之四十三

【本节目标】

通过阅读本节内容，你将进一步熟悉数组的概念与其相关操作，并对继承有更加深入的理解，甚至熟练掌握这一概念。

案例分析四（数组操作）

建立一个可以实现整型数组的操作类(Array),而后在里面可以操作的数组的大小由外部来决定,而后在Array类里面需要提供有数组的如下处理: 进行数据的增加(如果数据满了则无法增加)、可以实现数组的容量扩充、取得数组全部内容。

完成之后在此基础上再派生出两个子类:

• 数组排序类:返回的数据必须是排序后的结果;
• 数组反转类: 可以实现内容的首尾交换。

对于本程序而言，首先要考虑的是父类如何定义完善。

第一步：实现基本的数组操作类定义

class Array {        //数组的操作类
    private int [] data ;      //整型数组
    private int foot ;      //进行数组索引控制
    public Array(int len) {
        if (len > 0) {
          this.data = new int [len] ;    //开辟数组
        } else {
            this.data = new int [1] ;     //开辟一个空间
        }
    }
//实现数组的容量扩充，给出的是扩充大小，实际大小：已有大小+扩充大小
    public void increament (int num) {
        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) {    //有位置
          this.data[this.foot ++] = num ;
          return true ;
        }
        return false ;
    }
    public int[] getData () {
        return this.data ;
    }
}
public class JavaDemo{
    public static void main(String args[]) {
        Array arr = new Array(5) ;
        System.out.println(arr.add(10)) ;
        System.out.println(arr.add(5)) ;   
        System.out.println(arr.add(20)) ;
        System.out.println(arr.add(3)) ;
        System.out.println(arr.add(6)) ;
        arr.increament(3) ;
        System.out.println(arr.add(1)) ;
        System.out.println(arr.add(7)) ;
        System.out.println(arr.add(0)) ;
    }         
}           

第二步：进行排序子类定义

class Array {        //数组的操作类
    private int [] data ;      //整型数组
    private int foot ;      //进行数组索引控制
    public Array(int len) {
         if (len > 0) {
              this.data = new int [len] ;    //开辟数组
         } else {
              this.data = new int [1] ;     //开辟一个空间
         }
     }
//实现数组的容量扩充，给出的是扩充大小，实际大小：已有大小+扩充大小
     public void increament (int num) {
         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) {    //有位置
           this.data[this.foot ++] = num ;
           return true ;
        }
        return false ;
     }
     public int[] getData () {
         return this.data ;
     }
}
class SortArray extends Array {      //定义排序子类
    public SortArray(int len) {
        super(len) ;
    }
    public int [] getData() {           //获得排序结果 
        java.util.Array.sort(super.getData()) ;      //排序
        return super.getData() ;
    }
}
public class JavaDemo{
    public static void main(String args[]) {
        SortArray arr = new SortArray (5) ;
        System.out.println(arr.add(10)) ;
        System.out.println(arr.add(5)) ;   
        System.out.println(arr.add(20)) ;
        System.out.println(arr.add(3)) ;
        System.out.println(arr.add(6)) ;
        arr.increament(3) ;
        System.out.println(arr.add(1)) ;
        System.out.println(arr.add(7)) ;
        System.out.println(arr.add(0)) ;
        int result [] = arr.getData() ; 
        for (int temp : result) {
            System.out.println(temp + “、”) ;
        }
    }         
}           

第三步：定义反转子类

class Array {        //数组的操作类
    private int [] data ;      //整型数组
    private int foot ;      //进行数组索引控制
    public Array(int len) {
        if (len > 0) {
           this.data = new int [len] ;    //开辟数组
        } else {
           this.data = new int [1] ;     //开辟一个空间
        }
    }
//实现数组的容量扩充，给出的是扩充大小，实际大小：已有大小+扩充大小
    public void increament (int num) {
        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) {    //有位置
           this.data[this.foot ++] = num ;
           return true ;
        }
        return false ;
    }
    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() [tail];
          super.getData() [tail] = temp ;
          head ++ ;
          tail -- ; 
       }
       return super.getData() ;
    }
}
public class JavaDemo{
    public static void main(String args[]) {
        SortArray arr = new SortArray (5) ;
        System.out.println(arr.add(10)) ;
        System.out.println(arr.add(5)) ;   
        System.out.println(arr.add(20)) ;
        System.out.println(arr.add(3)) ;
        System.out.println(arr.add(6)) ;
        arr.increament(3) ;
        System.out.println(arr.add(1)) ;
        System.out.println(arr.add(7)) ;
        System.out.println(arr.add(0)) ;
        int result [] = arr.getData() ; 
        for (int temp : result) {
            System.out.println(temp + “、”) ;
        }
    }         
}           

图一 执行结果一

父类之中定义的方法名称往往都很重要，如果功能相同的时候子类应该以覆写父类的方法为优先考虑。

想学习更多的Java的课程吗？从小白到大神，从入门到精通，更多精彩不容错过！免费为您提供更多的学习资源。

本内容视频来源于

阿里云大学 下一篇：三分钟带你认识注解 | 带你学《Java面向对象编程》之四十五 更多Java面向对象编程文章查看此处