JAVA知识点笔记

一、 命名

类名首字母大写 && 方法首字母小写 && 变量/方法名遵循驼峰命名

二、 数据类型

1. 基本数据类型（ CPU可以直接进行运算的类型）
   整数类型：byte，short，int，long
   浮点数类型：float，double
   字符类型：char
   布尔类型：boolean
2. 引用类型：String 字符串
3. 常量：加上final修饰符，变量就变成了常量
4. var关键字：只是可以少写变量类型

三、 方法 function

field：单个变量域，用private修饰field，拒绝外部访问

1. 重载 Overload

方法名相同，但各自参数不同（返回值类型通常也相同）
目的是：功能类似的方法使用同一名字，更容易记住

2. 覆写 Override

子类定义了与父类方法签名完全相同的方法

Overload方法签名不同，是一个新方法；
Override方法签名相同，返回值也相同，是重定义父类的方法。

加上@Override可以让编译器帮助检查是否进行了正确的覆写。
希望进行覆写，但是不小心写错了方法签名，编译器会报错。

四、 继承

1. extends

Java使用extends关键字来实现继承

子类自动获得了父类的所有字段，严禁定义与父类重名的字段！

2. super

关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName

3. super()

任何class的构造方法，第一行语句必须是调用父类的构造方法。
子类不会继承任何父类的构造方法。（子类默认的构造方法是编译器自动生成的。）
【 如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super(); 】
但是如果父类没有默认的构造方法，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。

在OOP的术语中，我们把Person称为超类（super class），父类（parent class），基类（base class），把Student称为子类（subclass），扩展类（extended class）。

4. protected

子类无法访问父类的private字段或者private方法。
把private改为protected。用protected修饰的字段可以被子类访问

5. final

如果一个父类不允许子类对它的某个方法进行覆写，可以把该方法标记为final。
用final修饰的方法不能被Override，
用final修饰的类不能被继承，
用final修饰的字段在初始化后不能被修改

6. sealed类

从Java 15开始，允许使用sealed修饰class，并通过permits明确写出能够从该class继承的子类名称。
public sealed class Shape permits Rect, Circle, Triangle {...}
这种sealed类主要用于一些框架，防止继承被滥用

五、多态 Polymorphic

多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。

功能：允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码

六、抽象类 abstract

如果class定义了方法，但没有具体执行代码，这个方法就是抽象方法，用abstract修饰。

因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。
我们无法实例化一个抽象类

编译器会告诉我们，无法编译，因为包含抽象方法。

抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。因此，抽象方法实际上相当于定义了“规范”。

七、接口 interface

如果一个抽象类没有字段，全都是抽象方法，就可以把该抽象类改写为接口
（ 所有方法默认都是public abstract ）

1. 接口实现

当一个具体的class去实现一个interface时，需要使用implements关键字

一个类只能继承自另一个类，不能从多个类继承。但是，一个类可以实现多个interface

2. 接口继承

interface继承自interface使用extends

3. 继承关系

合理设计interface和abstract class的继承关系，可以充分复用代码。一般来说，公共逻辑适合放在abstract class中，具体逻辑放到各个子类，而接口层次代表抽象程度。

List list = new ArrayList(); // 用List接口引用具体子类的实例
Collection coll = list; // 向上转型为Collection接口
Iterable it = coll; // 向上转型为Iterable接口
1
2
3

4. default方法

目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。如果新增的是default方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。

八、静态 static

1. 静态字段：static field

实例字段在每个实例中都有自己的一个独立“空间”，但是静态字段只有一个共享“空间”，所有实例都会共享该字段。
可以把静态字段理解为描述class本身的字段（非实例字段）

2. 静态方法

调用实例方法必须通过一个实例变量，
而调用静态方法则不需要实例变量，通过类名就可以调用。
【 静态方法类似其它编程语言的函数。】

静态方法属于class而不属于实例
因此，静态方法内部，无法访问this变量，也无法访问实例字段，它只能访问静态字段。

通过实例变量也可以调用静态方法，但这只是编译器自动帮我们把实例改写成类名而已。
通常情况下，通过实例变量访问静态字段和静态方法，会得到一个编译警告。

3. 接口的静态字段

因为interface是一个纯抽象类，所以它不能定义实例字段。但是，interface是可以有静态字段的，并且静态字段必须为final类型。

public interface Person {
    // 编译器会自动加上public statc final:
    int MALE = 1;
    int FEMALE = 2;
}
1
2
3
4
5

九、泛型 Generics

泛型就是编写模板代码来适应任意类型（一套代码创建各种类型）；

例如编写ArrayList<T>，就可以创建任意类型的ArrayList
为用到的类创建对应的ArrayList<类型>：

ArrayList<String> strList = new ArrayList<String>();
1

1. 优点：使用时不必对类型进行强制转换，它通过编译器对类型进行检查；

注意泛型的继承关系：可以把ArrayList<Integer>向上转型为List<Integer>（T不能变！），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）

2. 局限：（ Java的泛型是采用擦拭法实现的 ）
   1） <T>不能是基本类型，例如int
   因为实际类型是Object，Object类型无法持有基本类型
   2） 无法取得带泛型的Class。例如：Pair<String>.class；
   无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>
   3） 无法判断带泛型的类型。例如：x instanceof Pair<String>；
   4） 不能实例化T类型。例如：new T()

子类可以获取父类的泛型类型<T>

十、 集合 Collections

如果一个Java对象可以在内部持有若干其他Java对象，并对外提供访问接口，我们把这种Java对象称为集合。

Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。

1. 三种类型的集合：

List：一种有序列表的集合

1. 按索引顺序访问的长度可变的有序表，优先使用ArrayList而不是LinkedList；
2. 根据给定元素快速创建List：List.of()

List<Integer> list = List.of(1, 2, 5); //不接受null值
1

3. 遍历：使用迭代器Iterator 【 for循环 get(i) 不推荐 】
4. Iterator对象有两个方法：
   boolean hasNext() 判断是否有下一个元素，
   E next() 返回下一个元素。

List<String> list = List.of("apple", "pear", "banana");
for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
    String s = it.next();
    System.out.println(s);
}
//简化
for (String s : list) {
    System.out.println(s);
}
1
2
3
4
5
6
7
8
9

5. List和Array转换

把List变为Array:
1️⃣ 调用toArray()方法直接返回一个Object[]数组

Object[] array = list.toArray(); //会丢失类型信息
1

2️⃣ 给toArray(T[])传入一个类型相同的Array，List内部自动把元素复制到传入的Array中

Integer[] array = list.toArray(new Integer[list.size()]);
1

3️⃣ 通过List接口定义的T[] toArray(IntFunction<T[]> generator)方法：

Integer[] array = list.toArray(Integer[]::new);
1

把Array变为List:
1️⃣ 通过List.of(T…)方法最简单

Integer[] array = { 1, 2, 3 };
List<Integer> list = List.of(array);
1
2

( 返回的List不一定就是ArrayList或者LinkedList，因为List只是一个接口，List.of()返回的是一个只读List )

6. 是否包含某个指定元素：boolean contains(Object o)
7. 返回某个元素的索引：int indexOf(Object o) 如果元素不存在，就返回-1
8. 调用List的contains()、indexOf()这些方法，需要实现equals()方法：确定实例哪些字段相等，就认为实例相等
9. 对引用类型用Objects.equals()比较，对基本类型直接用==比较

public boolean equals(Object o) {
    if (o instanceof Person) {
        Person p = (Person) o;
        return Objects.equals(this.name, p.name) && this.age == p.age;
    }
    return false;
}
1
2
3
4
5
6
7

Set：一种保证没有重复元素的集合

1. 添加元素：boolean add(E e)
2. 删除元素：boolean remove(Object e)
3. 判断是否包含元素：boolean contains(Object e)

Map：一种通过键值（key-value）查找的映射表集合

1. 映射入表：put(K key, V value)
2. 通过key获取对应的value：get(K key)
3. 查询某个key是否存在：boolean containsKey(K key)
4. 遍历key：通过for each遍历keySet()

for (String key : map.keySet()) {
   Integer value = map.get(key);
   System.out.println(key + " = " + value);
}
1
2
3
4

5. 同时遍历key和value：通过for each遍历entrySet()

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + " = " + value);
}
1
2
3
4
5

6. HashMap
   遍历HashMap的Key时，其顺序是不可预测的。

要正确使用HashMap，作为key的类必须正确覆写equals()和hashCode()方法

equals()用到的用于比较的每一个字段，都必须在hashCode()中用于计算；
equals()中没有使用到的字段，绝不可放在hashCode()中计算。

int hashCode() {
    return Objects.hash(firstName, lastName, age);
}
1
2
3

7. TreeMap
   SortedMap在遍历时严格按照Key的顺序遍历，最常用的实现类是TreeMap；

作为SortedMap的Key必须实现Comparable接口，或者传入Comparator；

Map<Person, Integer> map = new TreeMap<>(new Comparator<Person>() {
            public int compare(Person p1, Person p2) {
                return p1.name.compareTo(p2.name);
            }
});
1
2
3
4
5

2. 特点

1. 实现了接口和实现类相分离，例如，有序表的接口是List，具体的实现类有ArrayList，LinkedList等，
2. 支持泛型，我们可以限制在一个集合中只能放入同一种数据类型的元素

3. 访问方式

Java提供了标准的迭代器模型，即集合类实现java.util.Iterable接口

for each 循环：List、Set和Queue会迭代每个元素，Map会迭代每个key

用 迭代器 Iterator 遍历：无需知道集合内部元素是按什么方式存储的

List<String> list = List.of("Apple", "Orange", "Pear");
for (String s : list) {
    System.out.println(s);
}
1
2
3
4

实际编译：

for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
     String s = it.next();
     System.out.println(s);
}
1
2
3
4

4. 使用Collections

Collections类提供了一组工具方法来方便使用集合类

1. 创建集合：

• 创建List：List<T> emptyList() && List<T> singletonList(T o)
• 创建Map：Map<K, V> emptyMap() && Map<K, V> singletonMap(K key, V value)
• 创建Set：Set<T> emptySet() && Set<T> singleton(T o)

返回的集合是不可变集合，无法向其中添加或删除元素

实际上，使用List.of(T...)更方便，因为它既可以创建空集合，也可以创建单元素集合，还可以创建任意个元素的集合

2. 创建不可变集合

List<T> unmodifiableList(List<? extends T> list)
1

3. 排序 / 洗牌
   排序 / 随机打乱List内部元素的顺序

其他

break：跳出自己所在的那一层循环（一层）
continue： 提前结束本次循环，继续执行下次循环