Java学习笔记之继承应用

定义一个整型数组类，要求包含构造方法，增加数据以及输出数据成员方法，增加数据以及输出数据成员方法，并利用数组实现动态内存分配，在此基础上定义出以下子类：

• 排序类：实现数组排序
• 反转类：实现数组倒序存储

class ArrayBase{
    private int temp[]; // 整型数组
    private int foot;   // 定义新插入数据位置
    public ArrayBase(int len){	// 构造函数，开辟数据空间
        if(len > 0){
            this.temp = new int[len];
        }else{
            this.temp = new int[1];  // 数组空间至少是1
        }
    }

    public boolean add(int i){  // 添加元素
        if(this.foot < this.temp.length){		// 这里foot默认值是 0
            temp[foot] = i;
            this.foot ++;   // 修改脚标
            return true;
        }else{
            return false;
        }
    }

    public int[] getArrayBase(){
        return this.temp;
    }
}

class ArraySort extends ArrayBase{		// 排序类
    public ArraySort(int len){
        super(len);
    }

    public int[] getArrayBase(){    // 覆写方法
        java.util.Arrays.sort(super.getArrayBase()); // 排序操作
        return super.getArrayBase();
    }

}

class ArrayReverse extends ArrayBase{		// 反转数组类
    public ArrayReverse(int len){
        super(len);
    }
    public int[] getArrayBase(){
        int t[] = new int[super.getArrayBase().length];
        int count = t.length - 1;
        for(int i=0;i<t.length;i++){
            t[count] = super.getArrayBase()[i];
            count -- ;
        }
        return t;
    }

}

public class ArrayDemo {
    public static void main(String[] args) {
        ArrayReverse ar = new ArrayReverse(5);  // 实例化大小为5的反转类对象
        System.out.print(ar.add(23) + "\t");
        System.out.print(ar.add(21) + "\t");
        System.out.print(ar.add(2) + "\t");
        System.out.print(ar.add(42) + "\t");
        System.out.print(ar.add(5) + "\t");
        System.out.println(ar.getArrayBase());
        print(ar.getArrayBase());

        System.out.println();
        // 排序输出
        ArraySort as = new ArraySort(5);
        System.out.print(as.add(23) + "\t");
        System.out.print(as.add(21) + "\t");
        System.out.print(as.add(2) + "\t");
        System.out.print(as.add(42) + "\t");
        System.out.print(as.add(5) + "\t");
        System.out.println(as.getArrayBase());
        print(as.getArrayBase());
    }
    public static void print(int t[]){
        for(int i=0;i<t.length;i++){
            System.out.print(t[i] + "、");
        }
    }

}

// 输出结果
true	true	true	true	true	[I@1540e19d
5、42、2、21、23、
true	true	true	true	true	[I@677327b6
2、5、21、23、42、

2、final关键字

可以使用final关键字声明方法、属性、类

• 使用final声明的类不能有子类
• 使用final声明的方法不能被覆写
• 使用final声明的变量称为常量，不能被修改

关于final的重要知识点

• final关键字可以用于成员变量、本地变量、方法以及类。
• final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
• 你不能够对final变量再次赋值。
• 本地变量必须在声明时赋值。
• 在匿名类中所有变量都必须是final变量。
• final方法不能被重写。
• final类不能被继承。
• final关键字不同于finally关键字，后者用于异常处理。
• final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。
• 接口中声明的所有变量本身是final的。
• final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
• final方法在编译阶段绑定，称为静态绑定(static binding)。
• 没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。
• 将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
• 按照Java代码惯例，final变量就是常量，而且通常常量名要大写：

private final int COUNT = 0;