JavaSE阶段：易混淆概念全总结（超详细！）-CSDN博客

本文链接：https://blog.csdn.net/2301_79263365/article/details/137342238

📌 String 与 StringBuffer

📌 HashSet 与 HashMap

📌 Collection 与 Collections

📌 final 与 finally

📌 throws 与 throw

📌 ReentrantLock与synchronized

📌 sleep与wait

📌 & 与 &&

○ & 无论左边是真是假，右边表达式都运算.

○ && 当左边表达式为真，右边表达式才运算；若左边为假，那么右边不参与运算.

（ || 和 | 同理，|| 表示左边为真，右边不参与运算）

✎ 实际开发中推荐使用 && ||

📌 this 与 super

this代表当前对象，可以调用当前类的构造方法, 成员变量和成员方法等。

super代表当前对象中从父类的引用的资源，可以调用父类构造方法,成员变量和方法。

✍ 关于 this关键字

○ this在非静态实例方法中：表示调用该方法的对象，即谁在调用，this就代表谁。

○ 当方法的局部变量与当前对象的成员变量重名时，就可以在成员变量前面加this. ，如果没有重名问题，就可以省略this.

○ this.成员变量会先从本类声明的成员变量列表中查找，如果未找到，会去从父类继承的在子类中仍然可见的成员变量列表中查找。

○ this不能出现在静态代码块和静态方法中

✍ 关于 super关键字

○ 在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。

○ 用“super.成员变量名”来引用父类成员变量

○ 用“super.方法名（参数列表）”的方式访问父类的方法。

注意：super和this都不能出现在静态方法和静态代码块中

📌 方法重载与重写

✍ 关于方法的重载

在一个类中有多个名称相同的方法时，在调用时通过方法的重载，即改变方法的参数的个数，类型，顺序，来区分同名的方法。

注意：方法的重载与返回值类型无关

✍ 关于方法的重写

当父类中方法的实现不能满足子类需求时，可以在子类中对父类的方法进行重写 ( 覆盖) , 这样调用时, 就会调用子类中重写的方法。

重写时需要注意：

● 子类重写的方法结构与父类方法的结构必须一致（方法名，参数列表，返回值类型必须一致）

● 子类重写的方法使用的访问权限 不能小于父类被重写方法的访问权。

● 构造方法，静态方法不能重写，成员变量不存在重写。

● 使用 @Override 注解标签

@Override是Java中的一个注解标签，定义在重写的方法上面，表示此方法是从父类重写而来，也可以不用添加，不过建议保留，因为编译器可以进行语法验证，并且阅读代码时可以明确的知道此方法是重写的。

📌 抽象类与接口

✍ 关于抽象类

抽象方法是一种特殊的方法，只有声明没有具体的实现，必须用abstract关键字修饰，没有方法体。

✍ 关于接口

○ 接口可以看做是一种特殊的抽象类，里面可以包含抽象方法，但不能被创建对象；

○ 接口可以被类实现，实现类必须实现接口中定义的所有方法；

○ 接口和抽象类十分的类似，接口内部的方法也是默认抽象的，不可在内部实例化的，只能由接口的调用者去实现。

○ 接口通过关键字 interface定义；类通过implements关键字来实现接口。

📌 "==" 与 equals

✍ 关于 "=="

“ == ” ：比较等号两边是否相等

当==用于基本类型 比较时，比较的是变量的值是否相等。

当==用于引用类型 比较时，比较的是对象的地址是否相等。

public static void main(String[] args) {
        //int属于基本数据类型
        int a = 5;
        int b = 5;
        System.out.println(a == b); //true
        //数组属于引用数据类型
        int[] c={1,2,3};
        int[] d={1,2,3};
        System.out.println(c); //[I@1b6d3586
        System.out.println(d); //[I@4554617c
        System.out.println(c==d);//  false  数组c与数组d的地址不同
        
    }

✍ 关于 equals

equals()方法属于Object类，Object类是所有Java类的祖先；equals方法默认比较的是两个对象的

地址是否相等, 所以我们就以使用 == 代替它；实际使用equals方法时，在其他类中，一般都重写

了equals(), 把它改造为比较对象中的内容是否相等。

public class Test_2 {
    public static void main(String[] args) {
        Person p1 = new Person("小魏",16);
        Person p2 = new Person("小魏",16);
        System.out.println(p1==p2);   // 输出:false 比较的是地址
        System.out.println(p1.equals(p2)); // 输出:true 已经对equals方法进行了重写,使其比较的是两对象内容是否相等
    }
}

● (Object 中的 equals 方法默认使用==比较,比较的是对象地址,这点需要注意 )

● 在Person类中对equals方法进行重写，使其比较的是对象中的内容是否相等

 @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person other =(Person)obj;
            return name.equals(other.name) && age ==other.age;
        }
        return false;
    }

📌 String 与 StringBuffer

✎ String修饰的字符串是一个值不能改变 的字符串，用String声明的字符串对象值一旦给定就不能

改变了，每次拼接都会创建新的字符串对象，耗时且占用空间。

✎ StringBuffer是内容可以改变的字符串,值可以改变且不需要创建新对象,在多任务执行时是安全的

适合单线程。

📌 HashSet 与 HashMap

✍ 关于 HashSet

HashSet是单列集合Set接口 下的实现类, 并且我们知道Set中所存储的元素是不重复的.

★ 关于HashSet在添加元素时，是如何判断元素重复的?

○ 在底层会先调用hashCode()，注意：Object中的hashCode()返回的是对象的地址，此时并不会调用；此时调用的是类中重写的hashCode()，返回的是根据内容计算的哈希值，遍历时，会用哈希值先比较 是否相等，会提高比较的效率；但哈希值会存在问题：内容不同，哈希值相同；这种情况下再调equals比较 内容，这样既保证效率又确保安全。

✍ 关于 HashMap

HashMap是双列结合Map 接口下的实现类，并且我们知道双列集合数据存储是以 ( 键,值 ) 形式存储且键不能重复，值可以重复，HashMap中的键是无序的。

★ 关于HashMap底层存储数据的结构：（面试高频题）

○ 底层使用了一个长度默认为16的哈希数组，用来确定元素的位置，每次用key计算出哈希值，再用哈希值%数组长度确定元素位置，将元素放在哈希表中指定的位置。

○ 后来继续添加元素，如果出现位置相同且不重复的元素，那么将后来元素添加到之前元素的next 节点。

○ 当链表长度等于8且哈希数组的长度大于64时链表会自动转为红黑树。

补充: 哈希表负载因子为0.75 , 当哈希表使用数组的0.75倍时会自动扩容为原来数组长的2倍。

📌 Collection 与 Collections

✍ 关于 Collection

Collection接口定义了单列集合共有的方法，其子接口Set和List分别定义了存储方式。

✍ 关于 Collections

Collections是集合类的工具类，与数组的工具类Arrays类似.

📌 final 与 finally

✍ 关于 final

○ final 可以修饰类，方法，参数，成员变量（常量）

○ final 修饰的类不能被继承，所以不能修饰抽象类，例如Java中String类就是final修饰。

○ final 修饰的方法不能被重写。

○ final 修饰方法的参数，参数值在方法中不能被改变。

○ final 修饰的成员变量值不能改变，因此称为常量。

✍ 关于 finally

○ finally关键字常常在异常处理中使用，finally块中的内容总是会执行的,，且只能有一个finally语句.

当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

 try{  
  编写可能出现异常的代码 
 }catch(异常类型){ 
  处理机制  
 }finally{ 
  代码总能执行  
 }

📌 throws 与 throw

○ throws 用在方法声明的地方，只声明方法异常的类型，并不处理异常。谁用谁异常谁处理。

○ throw 是一个关键字在方法体中，会抛出一个异常，然后生成一个处理异常的新对象，通过传输一些异常数据，返回处理异常的结果 throw 为手动抛出异常，也可以抛出一些自己写的异常。

📌 ReentrantLock与synchronized

synchronized是一个关键字 ，控制依靠底层编译后的指令去实现.
synchronized可以修饰一个方法或一个代码块.
synchronized是隐式的加锁和释放锁，一旦方法或代码块出现异常，会自动释放锁.

ReentrantLock是一个类，依靠java底层代码去控制 (底层有一个同步队列)
ReentrantLock只能修饰 代码块.
ReentrantLock需要手动的加锁和释放锁, 所以释放锁最好写在finally中 , 一旦出现异常, 保证锁能释放.

📌 sleep与wait

sleep ( ) :

属于Thread类 中的方法.
sleep休眠指定时间后，会自动唤醒.
sleep( ) 不会释放锁.

wait ( ) :

属于Object类 中的方法，必须要有锁对象调用.
wait后的线程必须要等待其他线程唤醒（notify或notifyAll）.
wait( ) 自动释放锁.