【阿里云】Java面向对象开发课程笔记（十四）——综合案例：数组操作

综合案例：数组操作

定义一个数组（整型数据）操作类，有如下要求：

• 该数组的大小由类创建对象的时候动态决定；
• 可以通过类向数组中进行数据的保存，保存的时候需要考虑数组的大小问题；
• 如果发现数组空间不足，可以进行数组的动态扩充；
• 可以取得数组的全部数据（升序）。

而后在这个基础上继续扩展两个派生类：

• 可以进行数组的排序处理；
• 可以进行数组的反转处理。

1 定义Array父类

代码

class Array {         //定义一个专门进行数组的操作类
      private int data [] ;  // 定义一个整型数组，大小由外部决定
      private int foot = 0; // 进行数组的脚标操作
      public Array(int len){ // 如果想要使用Array类必须设置数组大小
          if (len > 0){  // 一个正常的数组大小
              this.data = new int [len]; // 开辟新数组
          } else {
              this.data = new int [1];  // 开辟一个空间
          }
      }
    // 该方法主要功能是向数组里面进行数据的保存
    public boolean add(int num){
        if (this.foot >= this.data.length){ // 没空间了
            return false;
        }
        // 先进行数组的数据保存，而后foot的内容加1
        this.data[this.foot ++] = num;
        return true;
    }
    public int [] getData(){
          return this.data;
    }
     // 动态扩展，如果此时传入了一个3，则表示在已有的基础上数组长度追加3（5+3=8）
    public void inc(int num){
          int newData [] = new int [this.data.length + num];
          System.arraycopy(this.data,0,newData,0,this.data.length);
          this.data = newData; // 改变原始数组指向
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Array arr = new Array(5);
        arr.add(3);
        arr.add(1);
        arr.add(2);
        arr.add(8);
        arr.add(6);
        arr.inc(3);  // 扩充数组长度
        arr.add(10);
        arr.add(20);
        arr.add(30);
        int result [] = arr.getData(); // 接受数组全部内容
        for (int x = 0 ; x < result.length ; x++){
            System.out.print(result[x] + " ");
        }

    }
}

输出结果

3 1 2 8 6 10 20 30

内存分析：

2 SortArray排序子类

进行排序操作，在取得全部数据的时候里面的数据应该是全部排序好的，同时在该类操作的过程之中应继续具备：数据追加、数组扩充、取得全部数据（父类中getData()方法作为一个获取数据的标准）。

代码

class Array {         //定义一个专门进行数组的操作类
      private int data [] ;  // 定义一个整型数组，大小由外部决定
      private int foot = 0; // 进行数组的脚标操作
      public Array(int len){ // 如果想要使用Array类必须设置数组大小
          if (len > 0){  // 一个正常的数组大小
              this.data = new int [len]; // 开辟新数组
          } else {
              this.data = new int [1];  // 开辟一个空间
          }
      }
    // 该方法主要功能是向数组里面进行数据的保存
    public boolean add(int num){
        if (this.foot >= this.data.length){ // 没空间了
            return false;
        }
        // 先进行数组的数据保存，而后foot的内容加1
        this.data[this.foot ++] = num;
        return true;
    }
    public int [] getData(){
          return this.data;
    }
     // 动态扩展，如果此时传入了一个3，则表示在已有的基础上数组长度追加3（5+3=8）
    public void inc(int num){
          int newData [] = new int [this.data.length + num];
          System.arraycopy(this.data,0,newData,0,this.data.length);
          this.data = newData; // 改变原始数组指向
    }
}

// 这样可以直接继承父类中所有已经存在的操作方法
class SortArray extends Array{
    // 父类中没有无参构造方法，所以此时的子类必须明确的调用父类中的构造方法
    public SortArray(int num) {
        super(num); // 父类中支持数组创建
    }
    // 父类中取得数据的方法名称很标准，但是功能不足，有希望继续使用这个方法名称，那么就需要对方法进行扩充，即：覆写
    public int [] getData(){
        java.util.Arrays.sort(super.getData());
        return super.getData();  // 引用传递
    }

}

public class TestDemo {
    public static void main(String[] args) {
        SortArray arr = new SortArray(5);
        arr.add(3);
        arr.add(1);
        arr.add(2);
        arr.add(8);
        arr.add(6);
        arr.inc(3);  // 扩充数组长度
        arr.add(10);
        arr.add(20);
        arr.add(30);
        int result [] = arr.getData(); // 接受数组全部内容
        for (int x = 0 ; x < result.length ; x++){
            System.out.print(result[x] + " ");
        }

    }
} 

输出结果

1 2 3 6 8 10 20 30 

不通的子类可能要针对于方法进行部分扩展，这就是方法覆写最大的应用范畴。

3 ReverseArray反转子类

取得的数据是其保存数据的相反内容。

代码

class Array {         //定义一个专门进行数组的操作类
      private int data [] ;  // 定义一个整型数组，大小由外部决定
      private int foot = 0; // 进行数组的脚标操作
      public Array(int len){ // 如果想要使用Array类必须设置数组大小
          if (len > 0){  // 一个正常的数组大小
              this.data = new int [len]; // 开辟新数组
          } else {
              this.data = new int [1];  // 开辟一个空间
          }
      }
    // 该方法主要功能是向数组里面进行数据的保存
    public boolean add(int num){
        if (this.foot >= this.data.length){ // 没空间了
            return false;
        }
        // 先进行数组的数据保存，而后foot的内容加1
        this.data[this.foot ++] = num;
        return true;
    }
    public int [] getData(){
          return this.data;
    }
     // 动态扩展，如果此时传入了一个3，则表示在已有的基础上数组长度追加3（5+3=8）
    public void inc(int num){
          int newData [] = new int [this.data.length + num];
          System.arraycopy(this.data,0,newData,0,this.data.length);
          this.data = newData; // 改变原始数组指向
    }
}
// 这样可以直接继承父类中所有已经存在的操作方法
class SortArray extends Array{
    // 父类中没有无参构造方法，所以此时的子类必须明确的调用父类中的构造方法
    public SortArray(int num) {
        super(num); // 父类中支持数组创建
    }
    // 父类中取得数据的方法名称很标准，但是功能不足，有希望继续使用这个方法名称，那么就需要对方法进行扩充，即：覆写
    public int [] getData(){
        java.util.Arrays.sort(super.getData());
        return super.getData();  // 引用传递
    }

}

class ReverseArray extends Array{
    // 必须明确知道数组大小
    // 父类中没有无参构造方法，所以此时的子类必须明确的调用父类中的构造方法
    public ReverseArray(int len) {
        super(len); // 父类中支持数组创建
    }
    public int [] getData(){
        int temp;
        for ( int x = 0 , y= super.getData().length-1  ; x < y; x++ ,y--){
            temp = super.getData()[y];
            super.getData()[y] = super.getData() [x];
            super.getData() [x] = temp;

        }
        return super.getData();  // 引用传递
    }
}

public class TestDemo {
    public static void main(String[] args) {
        ReverseArray arr = new ReverseArray(5);
        arr.add(3);
        arr.add(1);
        arr.add(2);
        arr.add(8);
        arr.add(6);
        arr.inc(3);  // 扩充数组长度
        arr.add(10);
        arr.add(20);
        arr.add(30);
        int result [] = arr.getData(); // 接受数组全部内容
        for (int x = 0 ; x < result.length ; x++){
            System.out.print(result[x] + " ");
        }

    }
}

输出结果

30 20 10 6 8 2 1 3