数组的使用，内部类 2020.12.16

今日感受

自习两天，老师终于来上课了，上午讲了数组的使用，还有如何操作数组的一些方法围绕复制数组语句System.arraycopy来讲的，老师先讲了数组的特点：

1、数组中的数据的类型相同，所以其所占空间大小也一样，比如int的4字节，数组的地址与首个字节地址相关；

2、数组的数据是有序的，通过下标进行访问；

3、长度是固定的，即数组的长度是final的，一旦确定便无法更改；

而数组的这些特点也让复制一个数组很消耗内存，如果复制一个数组的一部分内容，计算器所做的操作量很大当数组数据多时，所以有了System.arraycopy(a数组，a数组开始点，b数组，b数组开始点，数据的个数)，开始点与下标一致。

老师让我们用这个语句对数组的数据进行以下几个操作，写出方法：

1、向数组中插入元素

//插入元素
    public static int[] insert(int[]a,int index,int value){
        int[]b = new int[a.length+1];
        b[index]=value;
        System.arraycopy(a,0,b,0,index);
        System.arraycopy(a, index, b, index+1, a.length-index);
        return b;
    }

2、删除数组中某个元素

//删除数组某个元素
    public static int[] delete(int[]a,int index){
        int[]b=new int[a.length-1];
        System.arraycopy(a, 0, b, 0, index);
        System.arraycopy(a, index+1, b, index,a.length-index-1 );
        return b;
    }

3、逆转元素

//逆转数组
    public static void res(int[]a){
        for(int i=0;i<a.length/2;i++){
            a[i]=a[a.length-i-1]+a[i];
            a[a.length-i-1]=a[i]-a[a.length-1-i];
            a[i]=a[i]-a[a.length-1-i];
        }
        
    }

4、冒泡排序

//数组冒泡排序
    //优化算法，添加一个布尔值用于判断有没有进行值的交换
    //未经优化的算法一定会进行 n-1 轮比较，经过优化的算法最多进行 n-1 轮比较
    public static void asc(int[]a){
        for(int i=0;i<a.length-1;i++){
            //默认排序已经好了
            boolean is=true;
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    a[j]=a[j]+a[j+1];
                    a[j+1]=a[j]-a[j+1];
                    a[j]=a[j]-a[j+1];
                    //若发生交换则排序未完成
                    is=false;
                }
            }
            if(is){
                break;
            }
            
        }
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]);
        }
        
    }

5、二分法查某个元素

//二分法查找某个元素
    public static int select(int[]a,int value){
        int start=0;
        int end=a.length-1;
        while(end>=start){
            int mid=(start+end)/2;
            if(value<a[mid]){
                end=mid-1;
            }else if(value>a[mid]){
                start=mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }

从中我还了解到了不用借第三个变量将两个不同的变量换一个值的算法。

//    static int i=2;
//    static int j=4;
//    i=i+j;
//    j=i-j;
//    i=i-j;
//    System.out.println(i);
//    System.out.println(j);

下午讲了内部类，有点把我搞晕了，后面我自己看了一篇关于内部类的文章（https://www.cnblogs.com/dolphin0520/p/3811445.html）内部类详解；

总结了点东西，内部类分四种，成员内部类，局部内部类，匿名内部类，静态内部类；

成员内部类：可以访问外部类的所有成员属性与方法，无论私有还是静态，不过要注意一点，当成员内部类与外部类有同名的成员方法或变量时，默认调用的是内部类的值，若需要调用外部类的值需要使用（外部类名.this.成员方法/变量）这是一种隐藏现象；当外部内想访问内部类时会比较麻烦，我老师比喻”一个父亲可以有几个儿子，但儿子只有一个父亲”，所以外部类访问内部类时需要知道是哪个内部类，因此需要创建一个成员内部类的对象，再通过对于指向这个对象的引用来进行访问。成员内部类像成员变量方法一样可以有多种权限修饰符，public，private等，其访问权限就会有所不同，public都可以访问，private只有外部类内部能访问，protected只有同一包下或者继承了外部类可以访问，默认权限是只能在同一包下进行访问。

局部内部类：定义在一个局部方法或者作用域的类，访问仅限于方法与作用域内，与局部变量类似，不能有访问修饰符；

匿名内部类：说实话，这个类是我还没有搞太明白的，文章中的例子用的安卓的代码，对我来说有点难懂，老师是用实现接口时写了一个匿名内部类，它不能被实例化，因为没有名字，唯一一个没有构造器的类，作用范围十分有限，一般用于继承类与实现接口，对其方法的重写或是实现，不需要添加新方法，老师还给了几种代码的表达形式更加简洁，不过不怎么懂。。。

静态内部类：这个较为简单，它不依赖于外部类，可以直接实例化，与静态成员属性类似，它不能访问外部类中的非静态属性，因为非静态属性必须依赖具体的对象，而它可以不用实例化外部类。

关于内部类的用处，最大的应该就是优化多继承的代码了。

文章后面还有其他知识点，还有面试题，暂时没看。