this变量#

一个始终指向当前实例的隐藏变量，可以访问对象的所有 field

可变参数#

第一个 语法糖 一种让代码更简洁的重构方式

1
public void setNames(String... names)
2
public void setNames(String[] names)

• 这两个语句都代表方法所需要的传参为一个数组，但是对与第二条语句，也就是所谓的 可变参数，如果你传参写了 一堆Str的单元素变量，比如 "Alice", "Bob"，那他也会自动打包
• 另外，传统数组参数可接受NULL，但是可变参数并不会允许这样，当 没有传参时，会构建一个0元素的变量

构造方法#

• 一个连返回值都不配拥有的方法
• 甚至名字都是和类名完全相同，寄生虫啊我看
• 作用就是在 new的时候初始化内部的各种字段，初始化到 合适的位置，避免在各种情况没有调用类的某些参数时会错误返回到一个 不合理 的情况

方法重载#

• 当方法定义的形参不同的时候，传入不同数量的参数可以调用不同的

1
class Person {
2
    private String name;
3
    private int age;
4

5
    public Person(String name, int age) {
6
        this.name = name;
7
        this.age = age;
8
    }
9

10
    public String getName() {
11
        return this.name;
12
    }
13

14
    public int getAge() {
15
        return this.age;
16
    }
17
}

• 而且你没有发现吗，所有对象在new的时候后面跟着的写法 不正是一个同名的方法吗？？ ，这么重要的信息居然被你忽略了

• 总之就是方法重载就等于是新增了一个可变的方法（这一点在后面的方法重载也会有体现），最重要的一点是：你可以让这个同名方法形参类型，个数，顺序不一样（一般都是这样），同时你也可以让这个方法返回值不一样 ==但你不能说形参一模一样的同时还换了返回值==，那这样JVM会说：奶奶的，你到底想让我返回哪个类型啊，给个准信

• （BTW其实这算不合法的重写，跟你私自缩小重写方法权限会失败是同一个道理，只要你方法名相同，传参类型顺序相同，编译的时候就会自动进入重写方法格式检测）

• 但也因此这个也会产生一个特例：除非如果父类的方法是返回一个父类，子类可以把这个同名方法返回一个更小类，这个其实是合法的，去看 向上转型那一章就能够知道，返回的实例是子类写的方法返回值还是父类的返回值都是合法的，这就是 协变返回类型

  1
  class A {}
  2
  class B extends A {}
  3
  
  4
  class Parent {
  5
      A getObj() { return new A(); }
  6
  }
  7
  
  8
  class Child extends Parent {
  9
      @Override
  10
      B getObj() { return new B(); }  // ✅ 合法（协变返回）
  11
  }

构造方法可以有多种#

不同参数数量和类型，java编译器能够自动匹配对应的构造方法 构造方法可以这样，其他方法也当然如此，这就是 方法重构

1
int indexOf(int ch) //根据字符的Unicode码查找；
2
int indexOf(String str) //根据字符串查找；
3
int indexOf(int ch, int fromIndex) //根据字符查找，但指定起始位置；
4
int indexOf(String str, int fromIndex) //根据字符串查找，但指定起始位置。

阻止继承#

有的时候，我们就是不想让类被一些小比崽子继承怎么办？ 在java 15之前，只要不是被final修饰的类，都能被合理的继承 但之后，用sealed(封装的意思),就可以用permit去规定能继承的子类名称

1
public sealed class Shape permits Rect, Circle, Triangle {
2
    ...
3
}

向上转型#

1
Person p = new Student();

java允许这样的new，因为子类具有所有父类的特性 向上转型实际上是把一个子类型安全地变为更加抽象的父类型，所谓向上的上就是如此

向下转型#

由于向上转型的存在，实际上父类类型变量指向的是哪一个子类（还是它本身），在编译之前我们都不知道，父类很大概率并不具有子类的新增成员（实际上肯定不具有啊，要不然为什么要继承。），但是又指向了子类的空间，如果强转的方向是这个子类引用本身，那当然合法（实例总是能满足引用的要求），但如果强转的方向是这个子类的“兄弟”，那这个就说不通了（子类一般都会加东西，但是兄弟类型和本类同时加东西的话，兄弟加的东西和此类会完全一样吗？大概率不是吧，所以就会导致实例（赋值等式右边）无法满足引用类型的要求，向下转型失败）

只是理解层面，实际上更复杂一点：

转型失败不是因为“字段不同”，而是因为对象的实际类型不兼容（JVM 的类型标记不同）。 即使两个类结构一模一样（比如字段名和数量完全相同），只要类型系统中它们无继承关系，仍然不行。

Override#

其实就是子类定义了一个 与父类完全相同的方法 ，方法名相同，方法参数相同，返回值也相同，做题区里最常见的Override就是在子类中重写toString，其实重写toString也不一定要用@Override，但是如果你在方法前加上这个声明的话，那么编译器会帮你检查拼写，可见性和方法参数的错误（它人还怪好的咧），那么这一个你早就用烂的机制和这个父标题有什么关系呢？

• 那么你能发现，其实JAVA调用同名方法的时候，其真正执行的方法取决于运行时期实际类型的方法，这种模式就叫 多态 这样说可能还是很抽象，让我们具体一点 定义三个类都有名为run的方法

1
class Person {
2
    void run() {
3
        System.out.println("人慢慢跑");
4
    }
5
}
6

7
class Student extends Person {
8
    void run() {
9
        System.out.println("学生飞快地跑");
10
    }
11
}
12

13
class Teacher extends Person {
14
    void run() {
15
        System.out.println("老师稳稳地跑");
16
    }
17
}
18

19
Person p1 = new Person();
20
Person p2 = new Student();
21
Person p3 = new Teacher();
22

23
p1.run();  // 人慢慢跑
24
p2.run();  // 学生飞快地跑
25
p3.run();  // 老师稳稳地跑

以上结果充分表明：“你是 Person 的一员，就应该有 run 方法。”，如果将来要新增一个子类，它也能自动正确计算，这就是可扩展性——多态带来的最大好处。允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。

来看一个更有实践意义的例子：

首先我定义了一个报税类

1
class Income {
2
    protected double income;
3
    public double getTax() {
4
        return income * 0.1; // 税率10%
5
    }
6
}

对于工资收入，可以减去一个基数，那么我们可以从Income派生出SalaryIncome，并覆写getTax()：

1
class Salary extends Income {
2
    @Override
3
    public double getTax() {
4
        if (income <= 5000) {
5
            return 0;
6
        }
7
        return (income - 5000) * 0.2;
8
    }
9
}

如果你享受国务院特殊津贴，那么按照规定，可以全部免税：

1
class StateCouncilSpecialAllowance extends Income {
2
    @Override
3
    public double getTax() {
4
        return 0;
5
    }
6
}

接着，你给一个有普通收入、工资收入和享受国务院特殊津贴的小伙算税，那么你的文件就可以这样写：

1
// Polymorphic
2
public class Main {
3
    public static void main(String[] args) {
4
        Income[] incomes = new Income[] {
5
            new Income(3000),
6
            new Salary(7500),
7
            new StateCouncilSpecialAllowance(15000)
8
        };
9
        System.out.println(totalTax(incomes));
10
    }
11

12
    public static double totalTax(Income... incomes) {
13
        double total = 0;
14
        for (Income income: incomes) {
15
            total = total + income.getTax();
16
        }
17
        return total;
18
    }
19
}
20

21
class Income {
22
    protected double income;
23

24
    public Income(double income) {
25
        this.income = income;
26
    }
27

28
    public double getTax() {
29
        return income * 0.1; // 税率10%
30
    }
31
}
32

33
class Salary extends Income {
34
    public Salary(double income) {
35
        super(income);
36
    }
37

38
    @Override
39
    public double getTax() {
40
        if (income <= 5000) {
41
            return 0;
42
        }
43
        return (income - 5000) * 0.2;
44
    }
45
}
46

47
class StateCouncilSpecialAllowance extends Income {
48
    public StateCouncilSpecialAllowance(double income) {
49
        super(income);
50
    }
51

52
    @Override
53
    public double getTax() {
54
        return 0;
55
    }
56
}

这样总算税的方法只需要和Income一个类打交道，而无须知道其它子类的存在，非常方便你去增删其它的工资类

覆写Object（超大类）#

因为所有的class最终都继承自Object，而Object定义了几个重要的方法：

• toString用于把实例转化字符串
• equals()用于判断是否逻辑相当
• hashCode()计算实例哈希值

根据所要求重现就行，除了equal都比较好理解

1
    // 比较是否相等:
2
    @Override
3
    public boolean equals(Object o) {
4
        // 当且仅当o为Person类型:
5
        if (o instanceof Person) {
6
            Person p = (Person) o;
7
            // 并且name字段相同时，返回true:
8
            return this.name.equals(p.name);
9
        }
10
        return false;
11
    }
12

13
    //慢慢去理解

调用super#

有时候你在重写父类方法的时候，正好需要这个父类方法的返回值,或者干脆去调用它，那么你就可以写：

1
class Person {
2
    protected String name;
3
    public String hello() {
4
        return "Hello, " + name;
5
    }
6
}
7

8
class Student extends Person {
9
    @Override
10
    public String hello() {
11
        // 调用父类的hello()方法:
12
        return super.hello() + "!";
13
    }
14
}

final#

抽象方法#

如果一个父类方法完全不需要规定任何内容，就比如记忆命途的忆灵出伤模式，大记忆类完全不知道具体是怎么出伤的，只能由具体子类去描述，瑕蝶长夜月是自爆忆灵出伤，阿格莱雅和记忆主是驻场出伤，那么这个记忆命途的void damage方法完全不需要写这个东西，只需要：

1
abstract class memory {
2
    int hp;
3
    int power;
4
    ...
5
    public abstract void damage();      //仅仅是为了定义方法签名，目的是让子类去覆写它
6
}

抽象类#

如果一个类里面有抽象方法，那么它必须也得被描述为抽象类，因为它包含了抽象方法，所以它必定无法被“实”例化，只能用于被继承如果理解不了，想象一下你能弄出一个“记忆”的角色吗？

• 但反过来讲，抽象类没说必须要有抽象方法，只有属性的类也可以说是抽象方法
• 抽象类可以有构造方法，也是类里唯一一个不属于abstract的方法，毕竟本质继承，如果构造方法都没有，怎么去符合super()的规范？
• 子类如果存在没重写的方法，那么继承自带abstract前缀，那么这个子类 也应当为抽象类

抽象类不能被实例化 抽象类不能被实例化 抽象类不能被实例化 重要事情说三遍

面向抽象编程#

定义抽象父类后，所有的引用对象标签都为该抽象类（构造方法用子类），就算这个子类并不存在，也可以通过抽象的方法去避免编译错误,比如昔涟其实没新建文件夹，但是她肯定会有忆灵出伤的方式，所以在版本前内容有需要的话也可以直接用

1
memory x = new xilian();
2
x.damege(1e9);
3
...

这种尽量引用高层类型，避免引用实际子类型的方式，称之为面向抽象编程。

接口与instanceof和引用类型#

这个对象的实际类是否实现了该接口？

如果实例确实能够实现，那么这个引用类型会自动可具有该接口名，也相当于是一种逻辑上的“继承关系”，也就是说，该实例 可以完全合法地向上转型

1
interface Flyable {
2
    void fly();
3
}
4

5
class Bird implements Flyable {
6
    public void fly() { System.out.println("Bird flies"); }
7
}
8

9
Flyable f = new Bird();
10
System.out.println(f instanceof Bird);     // ✅ true
11
System.out.println(f instanceof Flyable);  // ✅ true
12
System.out.println(f instanceof Object);   // ✅ true
13

14
Bird b = new Bird();
15
Flyable f = b;   // ✅ 合法，自动向上转型

implement实际上是一种can-do关系，可以简易地这样理解：

1
class Bird implements Flyable, Eatable, Drawable { ... }
2

3
/*
4
Bird → 可以 Flyable
5
Bird → 也能 Eatable
6
Bird → 还能 Drawable
7
*/

接口的菱形继承#

接口继承#

一个接口类可以继承另一个接口类，方法如下，相当于扩展了接口方法，很容易理解不细说了：

1
interface Hello {
2
    void hello();
3
}
4

5
interface Person extends Hello {
6
    void run();
7
    String getName();
8
}

继承关系#

有时候总是在别人的项目部署文章里提到xxx接口什么的 对于一个符合规范的代码项目来说：实例化对象永远只能是某个具体的子类，但引用时应当只通过接口

default方法#

但是要注意，若子类implements,那必须严格重写全部该接口类声明的全部方法

由此可知，如果在接口类新增一个方法，那么子类必须全部重写，否则报错，这样会有非常大的痛苦 所以Java8可以给接口的抽象方法新增一个default修饰符，如果新增的是deault方法，所继承的子类就无须全部修改

default方法和抽象类的普通方法是有所不同的。因为interface没有字段，default方法无法访问字段，而抽象类的普通方法可以访问实例字段。

静态字段#

没有被static修饰的字段被称为实例字段，而被static定义的字段被称为静态字段，静态字段不属于任何实例，所以无论修改哪个实例的静态字段，它都会被修改

• 也正因为如此，接口类也可以去拥有一个静态字段，结合前面所学，我们也能知道在接口类的字段是也只能是public static final（不需要去任何实例化，它在类加载阶段即被初始化，存在于方法区，可随意任何实例中被访问但不可被修改的字段），就算你不写，字段也会被编译器自动加上该修饰符

不推荐用“实例.静态字段”去访问静态字段，就算你这样写了实际也会被JVM强转，更推荐使用“类名.静态字段”

静态字段命名规则一般是全大写

就算引用变量为null，它依然能访问作用域所有的static字段

静态方法#

调用实例方法必须通过一个实例变量，而调用静态方法则不需要实例变量，通过类名就可以调用。静态方法类似其它编程语言的函数，这也是为什么main方法总是需要一个static修饰的原因，只有这样JVM才能在最开始 没有创建任何对象，也不知道构造方法、成员字段等信息 的情况下去生成一个命令行参数数组（也就是String[] args）,传递给main方法

工具类常用静态方法，所以写起来不用new来new去的 其实工具类是什么也需要你去详细阐述

• Arrays.sort()
• Math.random()

1
class User {
2
    private String name;
3
    private int age;
4

5
    // 构造器设为私有，防止外部随便 new
6
    private User(String name, int age) {
7
        this.name = name;
8
        this.age = age;
9
    }
10

11
    // 工厂方法：静态“伪构造器”
12
    public static User create(String name, int age) {
13
        if (age < 0 || age > 150) {
14
            System.out.println("年龄非法，返回 null");
15
            return null;
16
        }
17
        return new User(name, age);
18
    }
19

20
    @Override
21
    public String toString() {
22
        return name + " (" + age + ")";
23
    }
24
}
25

26
public class Main {
27
    public static void main(String[] args) {
28
        User a = User.create("Alice", 20);
29
        User b = User.create("Bob", -3); // 不会被创建
30
        System.out.println(a);
31
        System.out.println(b); // null
32
    }
33
}

名字就是static的方法：#

静态初始化块

1
    static {
2
        System.out.println("静态块执行！");
3
    }

为什么需要它？： 会在类加载时由 JVM 自动执行一次，和构造方法第一句的super()原理类似

import#

那么如果要用别人包（比如说就是官方写的）这些类，按照规范，肯定得是包名.类名，如java.util.Scanner sc = new java.util.Scanner(System.in);, 这种方式也叫全限定类名，它的功能非常强大，可以直接访问任何 java 包（乃至你能访问到的任何包）里的公开字段、方法或类成员（System.in的输入流（InputStream）类型其实也是这样实现的的）。但是每次都得这样写未免也太折磨，import 它有二+一种写法

• 只有public类能被import
• • 只有public类能被import
• • • 只有public类能被import
• 只导入包中某个类名：import mr.jun.Arrays;，这样后面使用这个类就可以只写简单类名了
• 直接把全包的类全导入：import mr.jun.*;,一般不推荐这种写法，容易分不清哪个类是哪个包
  • 既然谈到类重名这个问题了，那么可以看一下如果发生这种情况，java编译器会怎么排优先级
    1. 当前类所在的包（当前文件的 package）
    2. 当前类的内部类或嵌套类
    3. 通过 import 明确导入的类
    4. 通过通配符 import xxx.* 导入的类
    5. java.lang 包下的类（自动导入）
  • 总之确实是：“显式优于隐式”

为了方便你编写最基本的程序，最开始编译的时候，编译器会自动帮我们做两个import动作：

• 默认自动import当前package的其他class
• import java.lang.*

跨包继承#

继承可以跨包，子类可以访问父类的public和

模块（module）#

这个是JDK9之后才有的东西，简单来说就是包的包

和IDEA以及Maven的module不是一个概念！！！！，Maven为了区分也改成subproject了

一个月前更新了JAVA25,它支持一个非常逆天很像python的语句

1
import module java.base;

可以把这个包的包全部都import进去，不用一个一个去import类 虽然现在大佬都对这个感到非常匪夷所思，但其实这个又确实是我目前对module最深刻的感知了…… 但实际上，module(JPMS)在 JDK 9 → 24 期间存在的意义，从来就不是让你“更省事地 import 类” 而是让你“更安全、更清晰、更可控地管理模块间依赖（.jar与.jar之间的关联）和封装。 暂时先跳过这块吧，先有个概念

🧩 一、什么是 .jar#

.jar = Java ARchive 本质上它是一个 ZIP 压缩包，里面打包了：

• 编译后的 .class 文件；
• 所有依赖资源（图片、配置、元数据）；
• 以及一个特殊的文件：META-INF/MANIFEST.MF（清单文件）。

你可以直接用解压工具打开 .jar 看内容 👇

1
logisim.jar
2
 ├── META-INF/
3
 │    └── MANIFEST.MF
4
 ├── com/
5
 │    └── cburch/
6
 │         └── logisim/
7
 │              ├── Main.class
8
 │              ├── gui/
9
 │              └── circuit/
10
 ├── icons/
11
 └── resources/