菜鸡的Java笔记 实践

讲解一个继承的实现思路
        
        要求定义一个数组操作类（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.总结
        面向对象继承关系的设计思路：
            父类的设计很重要，父类中的方法必须要有意义
            子类定义的时候就应该已经可以明确该类的功能是什么
            如果子类在进行操作中发现父类的方法不好用了，优先考虑的是覆写，而不是建立新的方法