2022-07-23 第五组 赖哲栋 学习笔记

目录

• 2. 注解
• 3. Object类
• 4. 案例(superArray)

---

个人心得：今日知识点收获不错，继续努力；但是前几天的学的还有一些不明白，还得多加练习。

---

#### 1. final关键字

final可以修饰的结构

1、类 public final class

1. final修饰的类叫做最终类、终极类
2. 修饰后不能被继承

2、属性 private final String name

1. final修饰的变量为常量，常量不能重新赋值
2. 常量不能只声明，不赋值
3. 常量的命名规则：单词的所有字母大写，如果有多个单词用_隔开

3、方法 private final void show

1. final修饰的方法不能被重写

2. 注解

@Override 方法重写的注释

3. Object类

祖先类：Object(最顶级父类)

如果一个类没有明确的写出它的父类是谁，那它的父类是Object

Object类中有11个方法

1. hashCode(); 它的返回值实际上就是对象运行时的内存地址
   hash算法：一般翻译"散列"，把任意长度的输入，通过一个散列算法变换成固定长度的输出，其结果就是散列数据
   密码加密MD5加密 不可逆

2. equals(); 和==没区别，比地址，为了让子类重写

3. toString(); 转换成字符串，当我们直接使用对象时，会默认调用toString()方法 为了让子类重写

4. finalize(); 垃圾回收的方法

5. clone(); 克隆，必须实现cloneable接口

6. com.jsoft.morning.Person全类名

4. 案例(superArray)

1. 工具类

import java.util.function.Supplier;

//超级数组
public class SuperArray {

    //维护一个数组，考虑怎么存
    private Integer[] arrays;

    //超级数组的长度
    private int size;

    //数组当前的容量
    private int capacity;

    public SuperArray() {
//        arrays =  new Integer[10];
//        capacity = 10;
        this(10);
    }

    public SuperArray(int capacity) {
        arrays = new Integer[capacity];
        this.capacity = capacity;
    }

    //添加数据，默认添加，在数组的尾部添加
    public void add(Integer data) {
        //添加时要确保容量足够，如果不够，就需要扩容
        ensureCapacity(size + 1);
        //真正的添加数据
        arrays[size++] = data;
    }

    //添加数据，传入两个参数
    //在指定位置添加
    public void add(int index, Integer data) {
        if (index >= 0 && index < size) {
            ensureCapacity(size + 1);
            System.arraycopy(arrays, index, arrays, index + 1, size - index);
            arrays[index] = data;
            size++;
        }
    }

    //删除数据
    public void del(Integer data) {
        int index = 0;
        for (int i = 0; i < size; i++) {
            if (arrays[i] == data) {
                index = i;
                System.arraycopy(arrays, index + 1, arrays, index, size - index - 1);
                i--;
                size--;
            }
        }
    }

    //删除指定位置的数据
    public void del(int index) {
        if (index >= 0 && index < size) {
            System.arraycopy(arrays, index + 1, arrays, index, size - index - 1);
            size--;

        }
    }

    //修改数据
    public void change(int index, Integer data) {
        if (index >= 0 && index < size) {
            arrays[index] = data;
        }
    }

    //获取超级数组的长度
    public int size() {
        return size;
    }

    //获取指定下标的元素
    public Integer get(int index) {
        if (index >= 0 && index < size) {
            return arrays[index];
        }
        return null;
    }

    // 这个方法只在当前类使用，所以声明成private
    public void ensureCapacity(int needCapacity) {
        if (needCapacity > capacity) {
            capacity = capacity + 1;
            //  创建一个新的扩容好的数组
            Integer[] newArray = new Integer[capacity];
            // 把原数组的数据拷贝过来
            /*
                src：原数组
                srcPos：拷贝原始数组的起始位置
                dest：目标数组
                destPos：目标数组的起始位置
                length：拷贝数据的长度
             */
            System.arraycopy(arrays, 0, newArray, 0, arrays.length);
            arrays = newArray;
        }
    }
}

2. 测试类

import java.util.Scanner;

/*
    数组：扩容
    一旦声明，长度固定
    添加删除修改获取指定位置的数据
    获取数组长度

    封装一个超级数组
    创建一个超级数组。很多方法
    创建超级数组的时候不需要给定长度
 */
public class Test {
    public static void main(String[] args) {
        //创建一个超级数组的对象
        SuperArray superArray = new SuperArray(5);
        superArray.add(10);
        superArray.add(5);
        superArray.add(15);
        superArray.add(25);
        superArray.add(55);
        superArray.add(45);
        superArray.add(45);
//        superArray.add(2,45);
//        superArray.del((Integer)45);
        superArray.del(2);
//        superArray.change(1,20);
        for (int i = 0; i <superArray.size() ; i++) {
            System.out.println(superArray.get(i));
        }
    }
}

标签：index,07,23,arrays,数组,第五组,superArray,public,size
来源： https://www.cnblogs.com/laizhedong/p/16513077.html