protected 关键字
在使用继承的时候，方法使用protected可以被使用
但是默认的default不可以被使用
父类代码
public class Ch01 {
protected void show() {
System.out.println("在protected下才可以访问到");
}
void info() {
}
}子类代码
public class Demo extends Ch01{
public static void main(String[] args) {
Demo demo = new Demo();
demo.show();
}
}final 关键字
意思：最终的、终极的
final可以修饰什么结构？
- 类：public final class (终极类，最终类，其他的类无法继承于他)
- 属性：private final String name （修饰的是常量，不可以改变值）
- 方法：private final void showInfo (类可以被继承，但是某一个方法无法被重写)
final 修饰的常量需要有初始值，即使是null
常量的所有单词大写，多个单词使用下划线分隔 例如USER_NAME
建议在方法的重写出表明重新的注释 @Override
Object 类
最顶级的父类，祖先类
如果有一个类没有明确的写出它的父类是谁，那它的父类就是Object
Object类一共11个方法 (暂时记录5个)
hashcode();它的返回值实际上是对象运行时的内存地址。hash算法：一般翻译“散列”，把任意长度的输入，通过一个散列算法变换成固定长度的输出，输出结果为一个散列值(可以进行密码的保存)。密码MD5加密，SHA加密。equals();和==没区别,比地址，为了让子类重写。toString();转换成字符串，当直接使用对象时，会默调用toString();，为了让子类重写。finaLize();垃圾回收的方法。clone();克隆。（必须实现Cloneable接口）
Integer 的比较问题
在使用Integer定义变量时，如果值在-127 ~ 128范围内
会默认先调用缓存内的数值，如果超出范围就需要用到Object.equals();
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 400;
Integer i4 = 300;
System.out.println(i1 == i2);
// 结果为 true
System.out.println(i3 == i4);
// 结果为 false
// 内部有一个缓冲区，把byte范围内的数，缓存在byte数组内
System.out.println(i3.equals(i4));
System.out.println(i3.compareTo(i4));
// 如果i3 < i4 结果为负的
// i3 > i4 结果为正
// i3 == i4 结果为0手动创建一个超级数组
对数组需要进行的操作
- 添加数据
- 在指定位置添加数据
- 删除数据
- 删除指定位置的数据
- 修改数据
- 获取指定位置的数据
- 获取数组的长度
- 判断是否超出边界
- 扩容
Test类
public class Test {
public static void main(String[] args) {
// 创建一个超级数组的对象
SuperArray superArray = new SuperArray(5);
superArray.add(20);
superArray.add(10);
superArray.add(70);
superArray.add(90);
superArray.add(50);
superArray.add(1,100);
superArray.remove((Integer) 20);
superArray.remove((Integer)70);
superArray.remove(1);
superArray.change(1,20);
for (int i = 0; i < superArray.size(); i++) {
System.out.print(superArray.get(i)+" ");
}
}
}SuperArray类
public class SuperArray {
// 维护一个数组，要考虑的是怎么存
private Integer [] array;
// 超级数组的长度
private int size;
// 数组当前的容量
private int capacity;
public SuperArray(){
// array = new Integer[10];
this(10);
// capacity = 10;
}
public SuperArray(int capacity){
array = new Integer[capacity];
this.capacity = capacity;
}
public void remove(Integer data) {
int index = 0;
for (int i = 0; i < array.length; i++) {
if (array[i].equals(data)) {
index = i;
break;
}
}
while (index < array.length -1) {
array[index] = array[index+1];
index++;
}
size--;
ensureCapacity(size);
}
public void remove(int index) {
while (index < array.length -1) {
array[index] = array[index+1];
index++;
}
size--;
ensureCapacity(size);
}
// 添加数据，默认添加，在数组的尾部添加
public void add(Integer data) {
// 添加时要确保容量足够，如果不够，就需要扩容
ensureCapacity(size + 1);
// 真正的添加数据
array[size++] = data;
}
// 添加数据，传入两个参数
// 在指定位置添加
public void add(int index,Integer data){
if(rangeCheck(index)){
ensureCapacity(size + 1);
System.arraycopy(array,index,array,index + 1,size - index);
// 真正的添加数据
array[index] = data;
size++;
}
}
public void change(int index,Integer data) {
array[index] = data;
}
// 获取超级数组的长度
public int size(){
return size;
}
// 获取指定下标的元素
public Integer get(int index) {
// 判断一下index和合法性
if(rangeCheck(index)){
return array[index];
}
return null;
}
private boolean rangeCheck(int index) {
// index >= 0
// index <= size - 1
return (index >=0 && index <= size - 1);
}
// 这个方法只在当前类使用，所以声明成private
private void ensureCapacity(int needCapacity) {
if(needCapacity > capacity){
// 1.5倍
capacity = capacity + (capacity >> 1);
// 创建一个新的扩容好的数组
Integer [] newArray = new Integer[capacity];
// 把原数组的数据拷贝过来
/*
src：原数组
srcPos：拷贝原始数组的起始位置
dest：目标数组
destPos：目标数组的起始位置
length：拷贝数据的长度
*/
System.arraycopy(array,0,newArray,0,array.length);
array = newArray;
}
}
}