Programming on NEVERMORE

Claude Certified Architect

Sat, 13 Sep 2025 09:48:39 +0800

Claude 101

getting better results

Why AI will not replace human?
just remember, validation builds confidence, but it doesn’t eliminate responsibility. you’re still accountable for checking that these results make sense and being transparent

Java

Sat, 13 Sep 2025 09:48:39 +0800

语法基础

权限修饰符（范围从小到大）

private：仅在同一个类中可见。
default（无修饰符）：同一个包中可见。
protected：同一个包 和 不同包的子孙类 中可见。
public：所有地方都可见。

变量类型 (Variables)

内存管理简介

虚拟机栈（VM Stack）—— 线程私有区域
- 结构：当前线程执行的所有方法信息（如：栈帧1 main、栈帧2、栈帧3 当前方法）。
- 存储：局部变量（包括基本数据类型的值，以及指向堆中对象的“对象引用”）。
- 特点：随线程/方法结束而自动销毁。
堆区（Heap）—— 线程共享区域
- 存储：绝大多数创建出来的对象实例，以及包含在这些对象当中的实例变量（非 static 成员变量）。
方法区（Method Area）—— 线程共享区域
- 说明：本地内存中的元空间（Metaspace）。
- 存储：类信息、静态变量（静态变量仅在此处留存一份）、常量。

1. 成员变量 (Field)

定义在类中、方法外。

实例变量：属于对象，随对象创建于堆内存中。可用 public/private 等权限修饰符封装。
静态变量(类变量)：必须用 static 修饰，也可以添加权限修饰符。属于类，方法区内只有一份，被所有对象共享。推荐使用 类名.变量名 访问。
常量：通常用 public static final 修饰。内存中只有一份且不可变，命名规范为全大写（如 MAX_SIZE）。

2. 局部变量 (Local Variable)

定义在方法内、代码块内或参数列表中。

存放在栈内存中，方法执行结束即销毁。
修饰符严格：除 final 外，不能使用任何其他修饰符。（可见性仅在方法内，public/private等修饰符无效；加载时机与static冲突）
必须初始化：局部变量没有默认初始值，使用前必须显式赋值。

3. final 变量的赋值时机

final 成员变量：必须在声明时、实例代码块中或构造器中执行结束前完成赋值。
final 静态变量：必须在声明时或静态代码块中完成赋值。
final 局部变量：只要确保在使用前赋值一次即可（可以先声明再赋值）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class VarClass {
 private int instVar; // 实例变量
 private static int staVar; // 静态变量
 public static final int MAX = 100; // 常量

 public void method(int param) { // param 是局部变量
 final int localFinal;
 localFinal = 20; // final 局部变量可以延迟赋值一次
 int localIn = 10; // 局部变量，必须初始化后才能使用
 }
}

实例方法、静态方法 (Methods)

静态方法：由 static 修饰，属于类。常用于 main 方法、工具类。

使用场景：只需完成功能，而不需要访问具体对象的数据时。
优势：调用方便（直接通过类名调用），无需创建对象，节省内存。（建议私有化工具类的构造器以防止实例化） 不能访问类的非静态成员变量和方法。

实例方法：属于对象，由对象名访问。可以访问所有成员变量和方法。

方法重载/重写

方法重载：在同一个类中，方法名相同，但参数列表不同（参数个数、类型或顺序不同），返回值类型可以不同（如果仅有返回值类型不同而参数列表相同，会导致编译错误）。

方法重写：子类继承父类后，子类对父类中已有方法进行重新实现，方法名、参数列表必须完全相同，返回值类型相同或范围更小，且修饰符不能比父类严格。
父类的私有方法、静态方法不能被重写。
使用 @Override 校验注解检查重写的方法是否符合规范。

重载（Overload）：编译时多态（方法名相同，参数不同）。重写（Override）：运行时多态（子类重写父类的方法）。

SOLID原则

单一职责原则（Single Responsibility Principle）：一个类应该只有一个引起它变化的原因，即一个类只负责一项职责。
开闭原则（Open-Closed Principle）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。即在不修改现有代码的基础上，可以通过添加新代码来扩展功能。
里氏替换原则（Liskov Substitution Principle）：子类对象应该能够替换父类对象，且该替换不会影响程序的行为。
接口隔离原则（Interface Segregation Principle）：客户端不应该被迫依赖于它们不使用的方法。即一个类对另一个类的依赖应该建立在最小接口上。
依赖倒置原则（Dependency Inversion Principle）：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

数据类型

整型的默认类型是int

1
2
3
4
5
6
7
8
9


short s = 1;// 值在short范围内，编译器自动帮转
s = s + 1; // 错误，1默认是int，需要强制类型转换
s += 1; // 该式自带隐式类型转换，实际是short s = (short) (s+1)

public static int sum(byte a, byte b)
{
 return a+b;//返回类型为int
}
sum(100,200);//会报错，因为字面量100是默认类型int，需要(byte)100

浮点数的默认类型是double 二进制浮点数通过IEEE 754标准表示，float是4字节单精度32位；double是8字节双精度64位。
float符号位1位，指数位10位，尾数位21位；double符号位1位，指数位11位，尾数位52位。

1
2


float f=3.4; // 错误，3.4默认是double，向下转需要强转
// 为什么float不会自动转？计算机内浮点数本身就是近似值，向下转必定有精度丢失

BigDecimal类可以表示任意精度的浮点数，避免精度丢失问题。
原理：使用整数进行计算，并通过scale属性记录小数点位置。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


BigDecimal errornum = new BigDecimal(0.1);// 0.1是double类型，构造时就已经丢失精度了
BigDecimal a = new BigDecimal("0.1");// 通过字符串构造
BigDecimal b = BigDecimal.valueOf(0.2);// 通过静态方法构造，会自动把double转换为字符串再构造
BigDecimal c = a.add(b);
BigDecimal d = a.divide(b, 2, RoundingMode.HALF_UP);// 除法需要指定精度和舍入模式，避免无限循环报错
System.out.println(c); // 输出 0.3，不使用BigDecimal时会输出0.3000...004

BigDecimal a2 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("1.00");

System.out.println(a2.equals(b2)); // false，scale不同
System.out.println(a2.compareTo(b2)); // 0 还是 -1/1？0

表达式类型转换

最终结果由表达式的最高类型决定； byte、short、char在表达式中运算时直接提升为int参与运算。

运算符

+号在字符串运算中起连接作用，“abc”+5得"abc5",“abc”+5+‘a’得"abc5a", ‘a’+5+“abc"得"102abc”

1
2


b = a++;//先赋值再自加
b = ++a;//先自加再赋值

扩展赋值运算符：+=等五种 a += b 在编译器中是 a = (a的类型) (a + b)

短路与、或(&&、||)：若左边为false/true，则不执行右边(如++b>1不会导致自加)提前返回结果。

方法中可变参数

方法签名中定义的特殊的形参，在类型后加上…，表示该形参可以接受任意数量的实参。
一个方法中的形参列表中，只能有一个可变参数，并且需要放在最后。

1
2
3
4
5
6
7
8
9


public static int sum(int... nums) {
 int total = 0;
 for (int n : nums) {total += n;}// 可变参数在方法中视作数组
 return total;
}
// 调用
sum(); // 不传
sum(1,2,3,4,5); // 多个
sum(new int[]{1,2,3,4,5})// 数组

StringBuilder

可变字符串，效率高于String。

方法	说明
`StringBuilder append(任意类型)`	在字符串末尾追加内容
`StringBuilder reverse()`	反转字符串
`StringBuilder insert(int offset, String str)`	在指定位置插入内容
`StringBuilder delete(int start, int end)`	删除指定范围的内容

返回值均为StringBuilder对象本身，因此可以链式调用。

示例：

1
2
3


StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb.toString()); // 转换回String输出

流程控制语句

switch

表达式支持数据类型：byte、short、char、int、String、枚举类型；不支持double、float、long (因为储存小数靠二进制拟合，0.3实际上是0.300..004之类，导致无法正确匹配)

case的值必须是确定的字面量，且不能重复 break关键字是可选的，如果没有则执行下一个case(穿透性，当几种case处理代码一致时可以复用)；如果有，则跳出switch语句。 default也是可选的。

注解

注解是代码中的一种元数据，用于为程序元素（类、方法、变量等）提供额外的信息。本质是一种特殊的接口。

元注解

元注解是用于注解的注解，主要有以下几种：

@Retention：定义生命周期-源码/类文件/运行时
@Target：定义适用范围-类/方法/变量等
@Documented：将注解包含在Javadoc中
@Inherited：允许子类继承父类的注解

自定义注解

使用 @interface 关键字定义注解。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)// 元注解
public @interface MyAnnotation {// 自定义注解
 String value();// 当注解只有一个属性时且命名为value，使用时可以省略属性名
}

// 使用注解示例
@MyAnnotation("example value")
public class MyClass {
 System.out.println(MyClass.class.getAnnotation(MyAnnotation.class).value());
}

注解的解析

使用反射机制获取注解信息，并根据注解执行相应的逻辑。
getDeclaredAnnotations()：获取当前对象上所有注解 getAnnotation(Class annotationClass)：获取指定类型的注解对象

导第三方包

使用import语句导入第三方包中的类或接口，以便在代码中使用。
语法：

1
2


import 包名.类名;
import 包名.*;

在项目中创建lib文件夹，放入jar包，然后在jar包上右键选择“Add as Library”。

面向对象

三大特征：封装、继承、多态

构造器

创建类的对象时，会自动调用构造器（不指定即是默认的无参）。
是一种特殊的方法(因此可以重载)，无返回值类型，且名称必须和类名相同。
类中默认自带无参构造器，但一旦定义了有参构造器，就不能使用默认无参构造器（需要自行手动构建的无参）。

1
2
3


//对于Student类创建对象s
 Student s = new Student()
// 类名 对象名 方法名

this关键字

this是方法中的一个变量，用于指代调用方法的对象。
解决变量名称冲突问题：如方法的局部变量名/形参名和类成员变量名冲突，用this访问类的变量可以避免冲突，使得可以使用相同的名称。

1
2
3
4
5
6
7


public class Student {
 private String name;

 public void setName(String name) {
 this.name = name;// this.name指成员变量，name指形参
 }
}

静态方法不可能出现this关键字。

封装

设计要求：合理隐藏、合理暴露

隐藏

使用private关键字修饰成员变量，使得只能在本类中被直接访问。

暴露

使用public关键字修饰方法，通过方法操作成员变量。
在方法中可以添加限制，限定成员变量的范围等。

好处：如果需要修改变量类型，只需修改类中对应的方法，不用修改每一个调用的地方。

实体类

成员变量全部私有，并提供公开的getter、setter方法；需要提供无参构造器（有参可选）。只用于保存事物的数据而不进行处理。

继承

public class B extends A{}//B是子类，A是父类

子类能继承父类的非私有成员（变量、方法）

子类的对象由父类和子类共同构建：
父类的private成员也在子类对象里，只是子类代码不能直接访问，要靠父类提供的public/protected方法间接访问。

提高代码复用性：可以使用父类的public属性和方法（父类方法可以重写），也可以有自己新的属性和方法满足拓展。

继承的特点

1.java不支持多继承（因为多个父类的方法可能冲突），但可以使用多层继承 2.java的祖宗类：object 3.子类访问成员遵循就近原则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Fu {
 String name = "父类的name";
}

class Zi extends Fu {
 String name = "子类的name";

 public void show() {
 String localName = "方法的name";
 // 就近原则：先找局部变量
 System.out.println(localName); // 方法的name
 // this 访问当前类成员变量
 System.out.println(this.name); // 子类的name
 // super 访问父类成员变量
 System.out.println(super.name); // 父类的name
 }
}

子类构造器

子类的构造器必须先调用父类的构造器，再调用自己的。
1.默认调用父类的无参super()，可以用super(…)调用父类的有参。 2.可以使用this(…)调用子类的构造器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


private static final String DEFAULT_SCHOOL = "school";

 // 构造器1：没有传 schoolName 时，使用默认值
 public Student(final String name, final char sex, final int age) {
 this(name, sex, age, DEFAULT_SCHOOL);
 //注意 this(...)不能与super()同时出现，因为两者都要求出现在构造器的第一行
 }

 // 构造器2：完整参数
 public Student(final String name, final char sex, final int age, final String schoolName) {
 this.name = name;
 this.sex = sex;
 this.age = age;
 this.schoolName = schoolName;
 }

final关键字

可以修饰类、方法、变量。

修饰类：称为最终类，不能再被继承；
修饰方法：称为最终方法，不能被重写；
修饰变量：该变量除了初始化时，不能被赋值。对于引用变量（数组）：其地址（指向的对象）不可改变，但其指向对象的内容值可以改变

常量名采用全大写，单词间以下划线分割。

多态

定义与表现多态是指在继承或实现关系下，同一个行为具有不同的表现形式。

对象多态：父类类型的变量可以指向不同的子类对象（Animal a = new Dog();）。
行为多态：同一方法调用，根据实际对象类型的不同而执行不同的逻辑（子类重写的方法）。

前提条件
继承/实现：存在父子类继承关系或接口实现关系。
方法重写：子类必须重写父类的方法。
向上转型：父类类型的变量引用子类对象。
核心识别规律（重点）在多态形式下，程序遵循以下原则：

成员方法：编译看左，运行看右。
- 编译时，父类必须定义该方法，否则报错。
- 运行时，实际执行的是子类重写后的逻辑。
成员变量：编译看左，运行看左。
- Java 的成员变量没有多态性，获取的是声明类型（父类）中的值。
局限性：多态对象无法直接调用子类独有的方法（若需调用，需进行向下转型）。

优势与意义

解耦性：隐藏了具体的子类实现，使代码更加通用。
可扩展性：符合“开闭原则”，新增业务子类时，原有的父类引用代码无需修改。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Animal {
 String name = "Animal"; // 父类成员变量

 public void sound() {
 System.out.println("Animal makes a sound");
 }
}

class Dog extends Animal {
 String name = "Dog"; // 子类成员变量

 @Override
 public void sound() {
 System.out.println("Dog barks");
 }
 // 子类独有方法
 public void guardHouse() {
 System.out.println("Dog is guarding the house");
 }
}

public class PolymorphismDemo {
 public static void main(String[] args) {
 Animal a = new Dog();// 父类引用指向子类对象 -> 多态

 // 1. 成员变量没有多态（编译看左边声明类型）
 System.out.println(a.name); // 输出 Animal，而不是 Dog
 // 2. 成员方法有多态（运行时看右边动态绑定）
 a.sound(); // 输出 Dog barks
 // 3. 无法直接调用子类独有方法（编译报错）
 // a.guardHouse();
 // 如果要调用子类独有方法，需要向下强制转换
 if (a instanceof Dog) {
 ((Dog) a).guardHouse();
 }
 }
}

反射

作用：

1.在运行时动态获取类的信息（类名、方法、属性等），并可以动态创建对象、调用方法和访问属性（可以通过setAccessible(true)访问私有属性）。
2.可以绕过泛型（因为类型擦除）进行操作。
3.适合用于通用框架开发，如Spring、Hibernate等。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 1从对象获取
Class<?> clazz = obj.getClass();
// 2类名获取类对象
Class<?> clazz = Class.forName("com.example.MyClass");
// 3从类获取
Class<?> clazz = MyClass.class;

Object obj = clazz.getDeclaredConstructor().newInstance();// 获取构造器，再创建对象
Method method = clazz.getMethod("myMethod", String.class);// 获取方法
method.invoke(obj, "Hello");// 调用方法
Field field = clazz.getDeclaredField("myField");// 获取属性
field.setAccessible(true);// 取消访问检查，可以访问私有属性
field.set(obj, 42);// 设置属性值

特殊类

单例类（单例设计模式）

构造器私有化，以在类内创建唯一的对象，确保某个类只能创建一个对象（应用如任务管理器）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 单例类 single instance
public class A{
 // 在类内创建唯一的对象
 // 为保护该对象不在外部被置成null：
 // 若使用public修饰，则加上final；若使用private修饰，则使用方法返回对象
 private static A a = new A();//懒汉式：private static A a;

 // 构造器私有，避免在类外被调用，只能在类内创建对象
 private A(){
 }

 public static A getObject(){
 // 懒汉式
 // if (a == null){
 // a = new A();
 // }
 return a;
 }
}
// 饿汉式单例：在获取类的对象前就已经创建好对象
// 懒汉式单例：在获取类的对象时才创建对象，即在返回方法内创建对象

枚举类enum

用于信息分类和标识，常应用于switch的case处

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


public enum PlayerType {
 TENNIS,
 FOOTBALL,
 BASKETBALL
}

// 反编译结果
public final class PlayerType extends Enum
{

 public static PlayerType[] values(){
 return (PlayerType[])$VALUES.clone();
 }
 public static PlayerType valueOf(String name){
 return (PlayerType)Enum.valueOf(com/cmower/baeldung/enum1/PlayerType, name);
 }
 private PlayerType(String s, int i){
 super(s, i);
 }

 public static final PlayerType TENNIS;
 public static final PlayerType FOOTBALL;
 public static final PlayerType BASKETBALL;
 private static final PlayerType $VALUES[];

 static
 {
 TENNIS = new PlayerType("TENNIS", 0);
 FOOTBALL = new PlayerType("FOOTBALL", 1);
 BASKETBALL = new PlayerType("BASKETBALL", 2);
 $VALUES = (new PlayerType[] {
 TENNIS, FOOTBALL, BASKETBALL
 });
 }
}

1.枚举都是继承自Enum的最终类，不可被继承；
2.枚举类的第一行只能罗列常量的名称，每个常量都是枚举类的一个对象；
3.枚举类的构造器私有，因此不会对外创建对象

抽象类abstract–模板

使用abstract关键字修饰类和方法。
抽象方法没有方法体，只有方法声明。如public abstract void m();

1.抽象类中可以没有抽象方法，但抽象方法必须在抽象类中。 2.抽象类不能创建对象，仅作为父类以供继承。 3.抽象类的子类必须重写抽象类的全部抽象方法。

因此抽象类强迫子类重新实现抽象方法，避免方法不适用。常用于多态

接口interface–功能

定义规范，分化出不同实现类，使得可以在不同实现类中灵活切换。

使用 implements(实现)关键字通过接口实现“多继承”，注意要重写所有接口的抽象方法。
// class C implements A , B {//重写全部抽象方法}

规则

接口中只允许定义常量（默认加public static final，因此实际为常量）
接口中允许定义抽象方法
接口中允许定义特定实例方法（Java 8 之后）
接口不能创建对象（无构造器、只有抽象方法）
接口也可以用于多态（相当于义父，地位低于父类）

JDK8后新增三种实例方法

增强了接口的功能，且添加功能时避免已有的实现类需要重写。

1.默认方法
使用default修饰，默认会被加上public。
只能由接口的实现类对象调用。

2.私有方法
使用private修饰只能被接口中其它实例方法调用。

3.静态方法
使用static修饰，默认会被加上public。
只能由接口名调用。

*接口与继承的注意事项

1、接口可以多继承，且同名方法会合并；
2、若多个接口出现方法签名冲突，则不支持多继承，也无法被实现；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


// 情况1 完全一致
interface A {void show();}
interface B {void show();}

interface C extends A , B{
 // 此时A B的抽象方法实际上是同一个方法，因此不会报错
}
class MyClass implements C {
 public void show() { ... }
}

// 情况2 返回值类型冲突，重写也没用，报错
interface A {void show();}
interface B {String show();}

interface C extends A , B{
 // 违反了方法重载的要求，参数列表一致但返回值类型冲突，签名冲突报错
}
class MyClass implements C {
 public void show() { ... }// 报错
}

// 情况3 default方法冲突
interface A {
 default void show() { System.out.println("你好"); }
}
interface B {
 default void show() { System.out.println("你好"); }
}

interface C extends A, B {
 // 对于两个default方法的接口，必须重写该方法以解决冲突
 // 即使两个接口的方法完全一样，也必须重写
 @Override
 default void show() {
 A.super.show(); // 或者自定义逻辑
 }
}

class MyClass implements C {
 @Override // 实现C接口了可以不重写，若implements A,B则必须重写
 public void show() {
 System.out.println("我是 MyClass 的实现");
 }
}

3、一个类继承了父类，同时又实现了接口，若父类和接口中有同名方法，遵循“类优先原则”，会优先调用父类中的同名方法；
4、可以通过重写冲突方法来规避2中的报错。

如果一定要调用3 4中接口的方法，使用接口名.super.方法名进行调用。

代码块

分为两种：静态代码块： static{…}
类加载时自动执行，只会执行一次（类只加载一次），常用于静态变量初始化。

实例代码块： {…} 创建对象时自动执行，常用于对实例变量初始化。

内部类

定义在另一个类内部的类。

1.成员内部类

成员内部类寄生于 外部类的对象。
成员内部类可以直接访问外部类的所有成员属性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public class Outer {
 int num = 1;

 public Outer () {
 new Inner().print();// 外部类要通过创建成员内部类的对象，才可以访问内部类的成员
 }

 class Inner {
 public void print() {
 System.out.println(num);// 直接访问外部类
 }
 }
}

// 因此访问内部类时，先得创建一个外部类的对象
Outer.Inner a = new Outer().new Inner();
a.print();

2.静态内部类

由static关键字修饰，只在创建时加载一次，不允许访问外部类中 非static 的变量和方法（即外部类对象）。

Outer.Inner a = new Outer.Inner();

3.局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，其生命周期仅限于作用域内。不能被权限修饰符(public、private、protected、static)修饰

4.匿名内部类（子类对象）

在创建对象的同时，当场声明并实例化的一个类。用于创建只需要使用一次的、临时的实现类。
主要是用来继承其他类或者实现接口，并不需要增加额外的方法，方便对继承的方法进行实现或者重写。

唯一一种没有构造方法的类，是直接通过new关键字创建的一个子类对象。既是类也是对象。

格式：

1
2
3
4


new 类/接口(参数值){
 // 匿名类的类体 (可以包含字段、方法等)
 // 实现接口的方法 或 重写父类的方法
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Comparator<String> lengthComparator1 = new Comparator<String>() {
 @Override
 public int compare(String s1, String s2) {
 return Integer.compare(s1.length(), s2.length());
 }
};
// 2. Lambda 表达式写法 (简洁)
Comparator<String> lengthComparator2 = (s1, s2) -> Integer.compare(s1.length(), s2.length());
// 3. 使用方法引用 (更简洁)
Comparator<String> lengthComparator3 = Comparator.comparingInt(String::length);

函数式编程

Lambda表达式

用于替代**函数式接口(有且仅有一个抽象方法)**的匿名内部类对象。
用注解 @FunctionalInterface 来声明函数式接口。

格式：
(被重写方法的形参列表) -> {被重写方法的方法体}

Lambda语句简化规则：
参数类型可以省略不写；单个参数可以省略()；只有单行代码时，可以省略{}，同时需要去掉分号和return（如果是return语句的话）

方法引用

1.静态方法引用
用法：当Lambda表达式调用了一个静态方法时，且->前后参数形式一致。
格式：类名::静态方法名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Class Arr {
 private int num;

 public static int minus(Arr a1, Arr a2){
 return a1.getNum() - a2.getNum();
 }
}

Arr[] arr1 = new Arr[2];
Array.sort(arr1, (a1,a2)->a1.getNum() - a2.getNum())
Array.sort(arr1, Arr::minus)

2.实例方法引用
用法：当Lambda表达式调用了一个实例方法时，且->前后参数形式一致。
格式：对象名::实例方法名

3.特定类的方法引用
用法：当Lambda表达式调用了一个实例方法时，且第一个参数是方法的主调，后续参数均为该方法的参数。
格式：特定类名::方法名

1
2


Arrays.sort(names, (n1,n2) -> n1.compareToIgnoreCase(n2))
Arrays.sort(names, String::compareToIgnoreCase)

4.构造器引用
用法：当Lambda表达式只是在创建对象，且->前后参数形式一致。
格式：类名::new

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


Class Car{
 private String name;
}

@FunctionalInterface
public interface CarFactory {
 Car getCar(String name);// 函数式接口的抽象方法
}

// -----------简化示例-----------
CarFactory cf = new CarFactory() {
 @Override
 public Car getCar(String name) {
 return new Car(name);
 }
};
// Lambda表达式：简化为参数 -> 方法体
CarFactory cf = name -> new Car(name);
// 构造器引用：L式只是在创建对象，实际需要提供的只有类名
CarFactory cf = Car::new;

// -----------实际使用-----------
Car c1 = cf.getCar("奔驰");
// 本例重写的方法相当于实现了
Car c1 = new Car("奔驰");

API

String

1.通过new创建新对象

提供了四种构造器API：可创建空字符串，根据字符串、字符数组、byte数组创建。

1
2


char[] chars = ['h','e','l','l','o']
String s = new String(chars)

与常规初始化（String s = ‘hello’）不同的地方：
常规方法的字符串对象存储在字符串常量池，相同内容的对象s1 s2实际是同一个对象；
而new方式会创建新的对象（即使对象内容相同）放在堆内存中

2.部分常用API 获取index处的字符: charAt(int index); 将字符串转换为字符数组char[]: toCharArray();
忽略大小写比较: equalsIgnoreCase(); 截取: substring(bIndex, eIndex); 替换: replace(target, replacement);

泛型

在编译阶段约束数据类型，保证数据类型一致性，避免强制转换异常。
泛型只在编译时起作用，运行时并不会保留泛型类型信息。

1
2
3
4
5


// 不指定泛型的ArrayList可以存放任何类型的数据，因为所有类型都继承自Object类。
ArrayList list = new ArrayList();// 实际是ArrayList<Object>
list.add("text");
list.add(new Date());
String str = (String)list.get(0);// 取出数据的时候需要强制类型转换。因为存放的是Object类型的元素，编译器不知道元素本身的类型。

可以用各字母指代泛型，常用<E/T/K/V>，意义分别是Element/Type/Key/Value，

包装类

泛型只支持对象类型，不支持基本数据类型。
因为类型擦除后泛型容器在底层实际上按照一个 Object[] 数组来存储元素，而基本数据类型不属于object的子类。
于是使用包装类Integer、Character(其余均是首字母大写)，它们是基本数据类型的对象版本，并且可以直接当基本类型使用（自动装拆箱）。

1
2
3
4
5
6
7
8


Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true，-128到127的所有Integer对象在缓存池里，a b实际指向同一对象

Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false，是不同对象
System.out.println(c.equals(d));// true

1
2
3
4
5
6
7


Integer in1 = Integer.valueOf(100); // 创建100的对象
Integer in2 = 100;// 实际上编译器会自动包拆装，直接使用即可

// 可以使用包装类的方法实现与字符串之间的相互转换。

String s = Integer.toString(10);
int i = Integer.parseInt("99")

类型擦除

JVM编译时会把泛型的类型变量擦除，并替换为限定类型（没有限定则是Object），这会导致一些问题

下例类型变量String和Date在擦除后会自动消失，method方法的实际参数是ArrayList list，因此导致编译失败

1
2
3
4
5
6
7


public static void method(ArrayList<String> list) {
 System.out.println("ArrayList<String> list");
 }

public static void method(ArrayList<Date> list) {
 System.out.println("ArrayList<Date> list");
 }

泛型类/接口/方法

泛型类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class MyArrayList<E> {
 private Object[] elementData;
 private int size = 0;

 public MyArrayList(int initialCapacity) {
 this.elementData = new Object[initialCapacity];
 }

 public boolean add(E e) {
 elementData[size++] = e;
 return true;
 }

 E elementData(int index) {
 return (E) elementData[index];
 }
}

泛型接口/方法：可以在实现时才指定具体类型，使得接口/方法更通用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public interface Printer<T> {// 泛型接口
 void print(T data);
 }

public <T> T[] toArray(T[] a) {// <T> 声明T作为泛型；T[]是返回类型及参数类型，可无
 return (T[]) Arrays.copyOf(elementData, size, a.getClass());
 }

public E get(int index) {// 不是泛型方法，只是使用类的泛型
 return (E) elementData[index];
 }

泛型限定符extends

限定符 extends 可以缩小泛型的类型范围

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class GrandFather {
 void show() {System.out.println("I am GrandFather");}
}
class Father extends GrandFather {
 @Override
 void show() {System.out.println("I am Father");}
}
class Child extends Father {
 @Override
 void show() {System.out.println("I am Child");}
}
class MyList<E extends Father> {}

MyList<GrandFather> list = new MyList<>();// 错误，E只能是Father或其子类
MyList<Father> list = new MyList<>();// 正确
MyList<Child> list = new MyList<>();// 正确
list.add(new GrandFather());// 错误，GrandFather不是Father的子类
list.add(new Father());
list.add(new Child());// 正确，Child是Father的子类

通配符

**通配符**用来解决类型不确定的情况，例如在方法参数或返回值中使用。

**上限通配符<? extends T>**表示通配符只能接受 T 或 T的子类。

**下限通配符<? super T>**表示通配符必须是 T 或 T的超类。

1
2


public static void printList(List<?> list) {...}// 可以接受任意类型的List，如List<Integer>、List<String>等
public static void printNumberList(List<? extends Number> list) {...}// 可以接受List<Integer>、List<Double>等

假设有一个类Animal及其子类 Dog和Cat。则对于List<? super Dog>集合，类型参数必须是Dog或其父类类型。
可以向该集合中添加Dog类型的元素，也可以添加它的子类元素。但是不能向其中添加Cat类型的元素。

PECS (Producer Extends, Consumer Super)原则 ? extends T：可以安全地读取数据，但限制了写入。
? super T：可以安全地写入数据，但限制了读取。

集合框架（容器）

Collection

常用方法

方法	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有的元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数。
public Object[] toArray()	把集合中的元素，存储到数组中

遍历方法

1.普通for循环
只适用于有索引集合。

2.迭代器

1
2
3
4


Iterator it = list.iterator();// 初始位于第一个元素处
while (it.hasNext()) {// 判断是否还有下一个元素，返回true/false
 System.out.print(it.next());// 读取当前元素再移位
}

3.增强for循环（for-each）本质是迭代器遍历集合的简化写法。

格式：for(元素数据类型变量名 : 要遍历的数组/集合)

1
2
3


for (String s : list) {
 System.out.print(s);
}

4.forEach方法
源码：

1
2
3
4
5
6


default void forEach(Consumer<? super T> action) {
 Objects.requireNonNull(action);// 判断传入的action对象是否为null
 for (T t : this) {
 action.accept(t);// 遍历action对象
 }
}

调用：

1
2
3
4
5
6
7
8


list.forEach(new Consumer<Integer>(){
 @Override
 public void accept(Integer int) {
 System.out.println(int);
 }})
// 简化
list.forEach(int -> System.out.println(int);)
list.forEach(System.out::println)// 已经指明对象为list，forEach方法不需要其他参数

并发修改异常

对于有索引的集合，在一次遍历中使用list.remove()，后续的元素位置会前移，而迭代器的游标位置后移，导致跳过了一个元素。
1 在for循环中删除元素时进行i–，或者从后往前进行循环
2 迭代器会检测是否出现并发修改异常并报错，使用迭代器的it.remove()可以避免，对于无索引的集合只能使用迭代器
3 增强for和forEach方法无法解决并发修改异常，只适合用于遍历

List

均有序、可重复、有索引，因此多了与索引相关的方法。

有ArrayList、LinkedList两种实现类。其底层数据结构分别是动态数组和双向链表，应用场景不同（查询/增删）。

· ArrayList第一次添加元素时，默认容量为10，后续每次扩容为原来的1.5倍。
· LinkedList可以从头尾两端添加元素，多了与头尾相关的方法。常用于构建队列、栈等。

Set

所有set都不重复、无索引；set本身无序。

特点：有HashSet、LinkedHashSet、TreeSet三种实现类，其增删查改的速度均快。
HashSet底层是哈希表，无序。
LinkedHashSet底层是哈希表+链表，有序（默认插入顺序）。
TreeSet底层是红黑树，有序（默认升序排序）。

HashSet

基于哈希表实现，依赖于元素的 hashCode() 和 equals() 方法（其底层几乎完全复用了 HashMap，元素作为 Key 存入，Value 统一为固定的 PRESENT 对象）。如果希望 HashSet 认为内容相同的对象是一样的，则必须重写这两个方法。

哈希表核心流程（JDK 8+）

初始化：首次添加元素时，默认创建长度为 16 的数组（哈希数组），默认加载因子为 0.75。
寻址定位：添加元素时，首先计算对象 hashCode() 对应的哈希值，结合数组长度通过位运算确定该元素在数组中的索引槽位（即“桶”的位置）。
处理冲突：
- 若该槽位为空，直接在此创建新节点。
- 若该槽位已有其他元素（发生哈希冲突），则沿着链表依次调用 equals() 方法进行比较。
- 若发现 equals() 结果为 true（有重复元素），则放弃插入；若全不相同，则将该新元素添加到该槽位的链表末尾（尾插法）。

扩容与树化机制:

数组扩容：当哈希表中的元素总个数超过阈值（初始为 $16 \times 0.75 = 12$）时，数组容量会扩容为原来的 2 倍，并重新计算各节点的位置（Rehash）。
转红黑树：当某个槽位中的链表长度超过 8 且 当前数组总长度大于等于 64 时，该处的链表会转换为红黑树，将查询的时间复杂度从 O(n) 降低至 O(log n)。(若链表大于 8 但数组小于 64，则优先进行数组扩容)。

哈希值 (Hash Code):

Java 中每个对象都有 hashCode()，返回一个 int 整数。默认实现通常基于对象在内存中的地址计算。
特性要求：只要对象的内部属性未被修改，多次调用 hashCode() 必须返回同一个值。
哈希冲突：不同对象的哈希值可能（且一定概率会）相同。哈希表就是为了解决这个问题才引入了链表/红黑树结构。

经典考点：为什么重写 `equals()` 时必须重写 `hashCode()`？

重写 equals 是为了保证逻辑正确性（业务层面）。重写 hashCode 是为了保证数据结构的高效与合规（底层存储层面）。

Java 官方契约：如果两个对象 equals 比较相等，那么它们的 hashCode 值必须相等
哈希集合的定址规则：先计算 hashCode 定位到哪个桶（定位）。再在桶内用 equals 遍历比对（比对）。
定位失效带来的双重惩罚：写入时：无法正确识别“重复”，造成逻辑错误（Set中元素不唯一）。读取时：无法正确命中已存在的数据，造成功能失效（Map找不到值）。

1
2
3
4
5
6
7
8


// 默认实现，返回对象的内存地址相关哈希值
public native int hashCode();

@Override// 重写后根据对象的属性计算哈希值
public int hashCode() {
 // ⚠️ 注意：计算多个属性的哈希值需要使用 Objects.hash() 方法
 return Objects.hash(this.name, this.age);
}

LinkedHashSet

继承自 HashSet。也是基于哈希表实现，但其底层通过 LinkedHashMap 提供支持。 核心差异：在原有哈希表（数组+链表/红黑树）的基础上，它额外为每一个节点增加了双向链表指针（before 和 after），用于记录元素的插入顺序。它的查询、增删效率非常接近 HashSet，同时又保证了迭代输出的顺序与插入顺序完全一致。

TreeSet

基于红黑树实现，元素自动升序排序。
对于自定义类型，默认无法直接排序，需要重写compareTo()方法。重写方法可以保留相同值的元素。

Map

也叫做键值对集合，格式为：{key1:value1, key2:value2, …}。
其中key不可重复，value可以重复。key与value一一对应。

有HashMap、LinkedHashMap、TreeMap三种实现类。
其特点见上面set的三种实现类，因为实际上set系列集合底层是基于map实现的（只使用key丢弃了value）。

1

Map<String, Integer> map = new HashMap<>();

常用方法

方法	说明
public V put(K key, V value)	添加元素，如果key已存在，则用新的value覆盖旧的value，并返回旧的value
public int size()	获取集合的大小
public void clear()	清空集合
public boolean isEmpty()	判断集合是否为空, 为空返回true
public V get(Object key)	根据键获取对应值
public V remove(Object key)	根据键删除整个元素
public boolean containsKey(Object key)	判断是否包含某个键
public boolean containsValue(Object value)	判断是否包含某个值
public Set keySet()	获取全部键的集合
public Collection values()	获取Map集合的全部值

遍历方式 1.键找值
先获取键的集合（keySet()方法），再通过键获取值（get(Object key)方法）

2.键值对
entrySet()方法获取键值对的集合，再通过getKey()、getValue()方法获取键和值。

1
2
3
4
5
6


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

3.forEach方法
forEach方法可以遍历键值对，并对键值对进行操作。

1
2
3
4
5
6
7
8


map.forEach(new BiConsumer<String, Integer>() {
 @Override
 public void accept(String key, Integer value) {
 System.out.println(key + ":" + value);
 }
});
// 简化
map.forEach((key,value) -> System.out.println(key + ":" + value));

Stream流

用于对集合、数组进行操作的API，可以进行过滤、排序、映射、聚合等操作。

示例：

1

List<String> newList = list.stream().filter(s->s.startWith("a")).filter(s->s.length()==2).collect(Collectors.toList()); // 过滤以a开头，长度为2的字符串，并收集到新List中

获取stream流

集合的stream方法

1
2


Stream<String> stream1 = list.stream();
Stream<String> stream11 = map.keySet().stream();// map先获取键或者值 map.values().stream() 或键值对map.entrySet().stream()

数组的stream方法

1

Stream<String> stream2 = Arrays.stream(arr);

stream类的方法

1

Stream<String> stream3 = Stream.of("a", "ab", "ca");

中间处理方法

调用完成后返回新的Stream流，可以链式调用。

方法	说明
Stream filter(Predicate<? super T> predicate)	过滤元素，返回符合条件的元素
Stream sorted()	对元素进行升序排序
Stream sorted(Comparator<? super T> comparator)	按照指定规则排序
Stream limit(long maxSize)	获取前几个元素
Stream skip(long n)	跳过前几个元素
Stream distinct()	去除流中重复的元素（自定义类的对象需要重写hashCode和equals方法）
Stream map(Function<? super T, ? extends R> mapper)	对元素进行加工，并返回对应的新流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流

终止方法

调用完成后返回结果，终止stream流。

方法	说明
void forEach(Consumer action)	对此流运算后的元素执行遍历
long count()	统计此流运算后的元素个数
Optional max(Comparator<? super T> comparator)	获取此流运算后的最大值元素放入optional容器，避免空指针异常
Optional min(Comparator<? super T> comparator)	获取此流运算后的最小值元素
Object[] toArray()	将流元素收集到数组
R collect(Collector<? super T> collector)	将流元素收集到容器中，collector类可以进一步收集到集合中

collect方法可以收集到集合中，如toList()、toSet()、toMap(keyMapper, valueMapper)等。例：Map<String,Integer> map = stream.collect(Collectors.toMap(Students::getName, Students::getAge));// 收集到map集合

IO流

用于读取文件、网络中的数据。实际开发中常用框架如Apache Commons IO、Google Guava等来简化IO操作。

按内容分为：字节流（处理所有类型数据）和字符流（处理文本文件）。
按方向分为：输入流（从源读取数据）和输出流（向目的写入数据）。

文件类操作

方法	说明
file.exists()	判断文件是否存在
file.isFile()	判断是否为文件
file.isDirectory()	判断是否为目录
file.getName()	获取文件名
file.length()	获取文件大小
file.lastModified()	获取文件最后修改时间
file.createNewFile()	创建文件
file.delete()	删除文件或空文件夹
file.mkdir()	创建目录
file.mkdirs()	创建多级目录
File[] listFiles()	获取目录下所有一级文件对象到文件对象数组中

输入输出流

字节输入输出流

建立

类	说明
InputStream in = new FileInputStream(file/path);	建立字节输入流
BufferedInputStream bin = new BufferedInputStream(in);	缓冲字节输入流，提高读取效率
OutputStream out = new FileOutputStream(file/path, boolean append);	建立字节输出流，append为true时表示追加写入
BufferedOutputStream bout = new BufferedOutputStream(out);	缓冲字节输出流，提高写入效率

读写方法

读写方法	说明
int read(int b)	读取一个字节
int read(byte[] b [, int offset, int len])	从offset开始读取len个字节到byte数组b中
byte[] ReadAllBytes	读取整个文件内容到字节数组中
write(int b)	写出一个字节
write(byte[] b [, int pos, int len])	写出字节数组
close() throws IOException	关闭流

资源释放方案

try-catch-finally

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


try{
 InputStream fin = new FileInputStream(file/path); |建立字节输入流
 OutputStream fout = new FileOutputStream(file/path, boolean append);
 // 读写操作
}catch(IOException e){
 // 异常处理
}finally{// 资源释放
 fin.close();
 fout.close();
}

try-with-resources(推荐) 在try后面的小括号内创建流对象，JVM会自动释放资源，避免忘记关闭流。
资源对象必须实现AutoCloseable接口（所有流类均已实现）。

1
2
3
4
5
6


try(InputStream fin = new FileInputStream(file/path);
 OutputStream fout = new FileOutputStream(file/path, boolean append);){
 // 读写操作
}catch(IOException e){
 // 异常处理
}

字符输入输出流

建立

类	说明
FileReader fr = new FileReader(file/path);	建立字符输入流
BufferedReader br = new BufferedReader(fr);	缓冲字符输入流，提高读取效率
FileWriter fw = new FileWriter(file/path, boolean append);	建立字符输出流
BufferedWriter bw = new BufferedWriter(fw);	缓冲字符输出流，提高写入效率

读写方法	说明
int read()	读取一个字符
int read(char[] cbuf [, int offset, int len])	从offset开始读取len个字符到char数组cbuf中
char[] ReadAllChars	读取整个文件内容到字符数组中
String readLine()	缓冲流独有的功能：读取一行文本
void write(int c)	写出一个字符
void write(String str [, int pos, int len])	写出字符串
void write(char[] cbuf [, int pos, int len])	写出字符数组
void newLine()	缓冲流独有的功能：写出一个换行符

字符输出流写出数据后，需要调用 flush() 或 close() 方法将缓冲区数据强制写出，否则数据可能在内存中未写入硬盘文件。

字符输入/输出转换流

用于解决字节流与字符流之间的转换问题，指定编码格式。

类	说明
InputStreamReader isr = new InputStreamReader(InputStream in, String charsetName);	字节输入流转换为字符输入流，可指定编码格式
OutputStreamWriter osw = new OutputStreamWriter(OutputStream out, String charsetName);	字节输出流转换为字符输出流，可指定编码格式

打印流

更高效的输出流，提供了多种重载的print()和println()方法，可以直接输出各种数据类型。

类	说明
PrintStream ps = new PrintStream(OutputStream/File/Path out, boolean autoFlush, String charsetName);	字节打印流
PrintWriter pw = new PrintWriter(Writer out, boolean autoFlush);	字符打印

特殊流

数据流(Data Stream)：用于读写基本数据类型和字符串，提供了readInt()、writeInt()等方法。对象流(Object Stream)：用于读写Java对象，提供了readObject()、writeObject()方法。对象必须实现Serializable接口。

类	说明
DataInputStream dis = new DataInputStream(InputStream in);	字节数据输入流
DataOutputStream dos = new DataOutputStream(OutputStream out);	字节数据输出流
ObjectInputStream ois = new ObjectInputStream(InputStream in);	字节对象输入流
ObjectOutputStream oos = new ObjectOutputStream(OutputStream out);	字节对象输出流

异常

有错误则抛出异常，但不会终止程序。

异常分类

Exception和Error都继承了Throwable类。只有Throwable类（或者子类）的对象才能使用throw关键字抛出，或者作为catch的参数类型。

Checked Exception（受检异常）：在编译期被检查的异常，必须显式处理（通过try-catch 或 throws）。正逐步淘汰。 Unchecked Exception（非受检异常 / 运行时异常）：运行时异常，不需要在编译期显式处理。继承自：RuntimeException

·NoClassDefFoundError 和 ClassNotFoundException的区别：
都由于系统运行时找不到要加载的类导致，但触发原因不同。 NoClassDefFoundError：程序在编译时可以找到所依赖的类，但是在运行时找不到指定的类文件；原因可能是编译的类文件被删除。 ClassNotFoundException：当动态加载 Class 对象的时候找不到对应的类时抛出该异常；原因可能是要加载的类不存在或者类名写错了。

异常处理

try-catch(-finally)

1
2
3
4
5
6
7
8
9


try{
// 可能发生异常的代码
}catch (exception(type) e(object)){
// 异常处理代码
}catch (exception2 e2){
// 可以有多个catch
}finally{
// 无论是否发生异常，都会执行的代码
}

多个catch块捕获异常时，子类异常必须在前，父类异常在后，否则会报错。如ArithmeticException是Exception的子类，其范围更具体，因此要放在前面。

即便是try块中执行了return、break、continue这些跳转语句，finally块也会被执行。
不执行的情况：死循环、JVM退出（System.exit(0)）等。

throws和throw

throws关键字用于声明异常，它的作用和try-catch相似；而throw关键字用于显式的抛出异常。
throws关键字后面跟的是异常的名字；而throw关键字后面跟的是异常的对象。

1
2


public void myMethod1() throws ArithmeticException, NullPointerException{...};// 方法体中有这些异常则抛出
if(b==0){throw new ArithmeticException("算术异常");}// 显式抛出异常

自定义异常

1.继承Exception或RuntimeException类 2.提供两个构造器：无参和带String参数（异常信息）

1
2
3
4
5
6
7
8
9


public class MyException extends Exception {
 public MyException() {
 super();// 调用父类的无参构造器
 }

 public MyException(String message) {
 super(message);// 调用父类的带String参数的构造器
 }
}

JUnit

测试方法必须使用@Test注解标记，且方法必须是public无参无返回值。

1
2
3
4
5
6
7
8


import org.junit.jupiter.api.Test;

public class MyTest {
 @Test
 public void testMyMethod() {
 // 测试代码
 }
}

其他注解

注解	说明
@ParameterizedTest	参数化测试，可以使用不同的参数多次运行同一个测试方法
@ValueSource	为参数化测试提供值,与@ParameterizedTest一起使用
@BeforeAll	在所有测试方法执行前运行一次，必须是静态方法
@AfterAll	在所有测试方法执行后运行一次，必须是静态方法
@BeforeEach	在每个测试方法执行前运行一次
@AfterEach	在每个测试方法执行后运行一次

参数化测试示例：

1
2
3
4
5


@ParameterizedTest
@ValueSource(strings = {"hello", "world", "java"})
public void testWithStringParameter(String arg) {
 assertNotNull(arg);
}

多线程

创建线程

继承Thread类，重写run()方法

1
2
3
4
5
6
7
8


public class MyThread extends Thread {
 @Override
 public void run() {
 // 线程执行的代码
 }
}
MyThread t1 = new MyThread();
t1.start();// 启动线程，调用run()方法

编码简单，但Java单继承的缺点也限制了其使用。
执行结果不能直接返回（run方法返回值是void）。

实现Runnable接口，重写run()方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public class MyRunnable implements Runnable {
 @Override
 public void run() {
 // 线程执行的代码
 }
}
MyRunnable r1 = new MyRunnable();// 创建Runnable对象
new Thread(r1).start();// 将Runnable对象传递给Thread构造器，启动线程

// 匿名内部类写法
new Thread(new Runnable() {
 @Override
 public void run() {
 // 线程执行的代码
 }
}).start();

扩展性强，但需要多创建一个Runnable对象。
执行结果不能直接返回（run方法返回值是void）。

Callable接口，重写call()方法 Callable接口可以有返回值，并且可以抛出异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class MyCallable implements Callable<Integer> {
 @Override
 public Integer call() throws Exception {
 // 线程执行的代码
 return 123;// 返回值
 }
}
MyCallable c1 = new MyCallable();
FutureTask<Integer> task = new FutureTask<>(c1);// FutureTask实现了Runnable接口
new Thread(task).start();// 启动线程，调用call()方法
Integer result = task.get();// 获取返回值，可能会阻塞等待线程执行完毕

线程的常用方法

方法	说明
start()	启动线程
run()	线程执行的代码
sleep(long millis)	让当前线程睡眠指定毫秒数
join()	调用该方法的线程优先执行
isAlive()	判断线程是否存活
setName(String name)	设置线程名称
getName()	获取线程名称
setPriority(int newPriority)	设置线程优先级，范围1-10，默认5
getPriority()	获取线程优先级
currentThread()	获取当前线程对象

线程同步

多线程并发访问共享资源时，可能会出现数据不一致的问题。
为了解决这个问题，可以使用以下几种方式进行线程同步：

同步代码块：在访问共享资源的代码块上加上synchronized关键字，表示该代码块是同步的，只有一个线程可以访问。

1
2
3
4
5


public void myMethod() {
 synchronized (this) {// 锁对象:实例方法使用共享资源；静态方法使用字节码（类名.class）
 // 线程安全的代码
 }
}

同步方法：在方法上加上synchronized关键字，表示该方法是同步的，只有一个线程可以访问。

1
2
3


public synchronized void myMethod() {
 // 线程安全的代码
}

Lock锁：使用java.util.concurrent.locks.Lock接口及其实现类（如ReentrantLock）来实现更灵活的线程同步。

1
2
3
4
5
6
7


final Lock lock = new ReentrantLock();// 创建Lock对象
lock.lock();// 获得锁
try {
 // 线程安全的代码
} finally {
 lock.unlock();// 释放锁，之中的代码会被锁保护
}

线程池

线程池可以复用线程，避免频繁创建和销毁线程带来的开销，提高系统性能。

常用方法：

方法	说明
execut(Runnable task)	提交Runnable任务到线程池，无返回值
Future submit(Runnable/Callable task)	提交Callable任务到线程池，返回Future对象
shutdown()	任务执行完毕后，关闭线程池
List shutdownNow()	立即关闭线程池，尝试停止所有正在执行的任务，返回队列中未执行的任务

1.ThreadPoolExecutor类 是线程池ExecutorService的核心类，可以通过构造器创建线程池。

构造器有七个参数，含义为：

corePoolSize：核心线程数，线程池中始终保持的线程数。
maximumPoolSize：最大线程数，线程池中允许的最大线程数。
keepAliveTime：线程空闲时间，超过这个时间的空闲线程会被终止。
unit：时间单位，keepAliveTime的时间单位。
workQueue：任务队列，用于存放待执行的任务。
threadFactory：线程工厂，用于创建新线程。
handler：拒绝策略，当任务队列满且线程数达到最大值时，如何处理新任务。

创建临时线程的时机：当核心线程全被占用且任务队列满，同时线程数未达到maximumPoolSize时。

拒绝任务的时机：当核心线程全被占用且任务队列满，同时线程数已达到maximumPoolSize时。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ThreadPoolExecutor executor = new ThreadPoolExecutor(
 5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
for (int i = 0; i < 10; i++) {
 final int taskId = i;
 executor.submit(() -> {
 // 线程执行的代码
 System.out.println("Task " + taskId + " is running");
 });
}
executor.shutdown();// 关闭线程池

2.Executors工具类 本质是对ThreadPoolExecutor的封装，简化线程池的创建。

工具类静态方法：

方法	说明
newSingleThreadExecutor()	创建单线程的线程池，出现异常会自动补充
newFixedThreadPool(int nThreads)	创建固定大小的线程池，若有线程出现异常结束，会自动补充新的线程
newCachedThreadPool()	创建可缓存的线程池，线程数随任务数增加，空闲一分钟回收
newScheduledThreadPool(int corePoolSize)	创建固定大小的线程池，可以延迟或定时执行任务

弊端：

FixedThreadPool和SingleThreadExecutor允许请求的队列长度无限制，可能导致内存耗尽。
CachedThreadPool和ScheduledThreadPool允许创建的线程数无限制，可能导致系统资源耗尽。
因此阿里禁用Executors创建线程池。

示例：

1
2
3
4
5
6
7
8
9


ExecutorService executor = Executors.newFixedThreadPool(5);// 创建固定大小的线程池
for (int i = 0; i < 10; i++) {
 final int taskId = i;
 executor.submit(() -> {
 // 线程执行的代码
 System.out.println("Task " + taskId + " is running");
 });
}
executor.shutdown();// 关闭线程池

网络编程

Java提供了丰富的网络编程API，主要包括以下几个方面：

Socket编程：用于实现TCP/IP协议的网络通信，包括客户端和服务器端的Socket编程。
UDP编程：用于实现基于UDP协议的网络通信，适用于对实时性要求较高的场景。
HTTP编程：用于实现基于HTTP协议的网络通信，包括发送HTTP请求和处理HTTP响应。
WebSocket编程：用于实现基于WebSocket协议的双向通信，适用于实时应用场景。

Socket编程(TCP)

Socket编程是Java网络编程的基础，主要包括以下几个类：

类	说明
Socket	客户端Socket类，用于连接服务器
ServerSocket	服务器Socket类，用于监听客户端连接
InetAddress	表示IP地址的类
SocketException	Socket操作异常类

创建客户端Socket

1
2
3
4
5
6
7


Socket socket = new Socket("localhost", 8080);// 连接服务器
OutputStream out = socket.getOutputStream();// 获取输出流
InputStream in = socket.getInputStream();// 获取输入流
// 读写数据等，输出后记得flush()
in.close();
out.close();
socket.close();// 关闭Socket

创建服务器端Socket

1
2
3
4
5
6
7
8
9


ServerSocket serverSocket = new ServerSocket(8080);// 监听端口
while (true) {
 Socket clientSocket = serverSocket.accept();// 接受客户端连接
 clientSocket.getInputStream();// 获取输入流
 clientSocket.getOutputStream();// 获取输出流
 // 读写数据等
 clientSocket.close();// 关闭客户端Socket
}
serverSocket.close();// 关闭服务器Socket

如果要处理多个客户端连接，可以为每个连接的socket创建一个新的线程。

1
2
3
4
5
6


new Thread(() -> {
 clientSocket.getInputStream();// 获取输入流
 clientSocket.getOutputStream();// 获取输出流
 // 读写数据等
 clientSocket.close();// 关闭客户端Socket
}).start();

B/S架构

B/S（Browser/Server）架构是基于浏览器和服务器的网络架构，常用于Web应用开发。
HTTP协议是B/S架构中最常用的协议，Java提供了HttpURLConnection类用于发送HTTP请求和处理HTTP响应。

UDP编程

UDP编程主要包括以下几个类：

类	说明
DatagramSocket	UDP Socket类，用于发送和接收数据包
DatagramPacket	数据包类，用于封装发送和接收的数据

创建UDP客户端

1
2
3
4
5
6


DatagramSocket socket = new DatagramSocket();// 创建UDP Socket
String message = "Hello, UDP!";
byte[] buffer = message.getBytes();
DatagramPacket packet = new DatagramPacket(buffer, buffer.length, InetAddress.getByName("localhost"), 8080);// 创建数据包
socket.send(packet);// 发送数据包
socket.close();// 关闭Socket

创建UDP服务器端

1
2
3
4
5
6
7


DatagramSocket socket = new DatagramSocket(8080);// 监听端口
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);// 创建数据包
socket.receive(packet);// 接收数据包
String message = new String(packet.getData(), 0, packet.getLength());
System.out.println("Received message: " + message);
socket.close();// 关闭Socket

Java Web

Sat, 13 Sep 2025 09:48:39 +0800

协议

HTTP 方法

GET：请求指定资源，获取数据。参数附加在URL后，长度有限制，不适合传输敏感信息
POST：向指定资源提交数据，通常用于表单提交。参数放在请求体中，无长度限制
PUT：向指定资源上传数据，通常用于更新资源的全部内容
DELETE：删除指定资源
HEAD：类似于GET请求，但只返回响应头，不返回响应体。用于检查资源是否存在或获取元数据常见状态码（200、301、302、404、500）: 2xx表示成功，3xx表示重定向，4xx表示客户端引发的错误，5xx表示服务器端引发的错误

RESTful 风格

资源（Resource）：通过URL表示资源，如/users表示用户资源
HTTP 方法：使用不同的HTTP方法操作资源，如GET获取资源，POST创建资源，PUT更新资源，DELETE删除资源
无状态（Stateless）：每个请求都应包含所有必要的信息，服务器不应存储客户端的状态
统一接口（Uniform Interface）：通过标准化的接口与资源进行交互，如使用JSON或XML格式进行数据交换

请求协议

请求行、请求头目标主机名、浏览器版本、接受的文件类型

1
2
3
4


GET /index.html HTTP/1.1 // 第一行为请求行
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html

请求体与请求头之间有一个空行分隔。
只有POST请求才会携带请求体，包含提交的数据，大小无限制

1
2
3
4
5
6
7


@RestController // 将controller的返回值作为响应体返回
public class PostController {
 @PostMapping("/submit")
 public String handleSubmit(@RequestBody String body) {
 return "Received data: " + body;
 }
}

响应协议

1
2
3


HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 1234

URL 组成
协议（Protocol）：如 http、https
域名（Domain）：如 www.example.com
路径（Path）：如 /index.html
查询参数（Query）：如 ?id=123&name=abc
端口（Port）：如 :80（HTTP默认端口）、:443（HTTPS默认端口）
锚点（Fragment）：如 #section1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


@RestController
// 方式一：Spring提供的ResponseEntity类
public class ResponseController {
 @GetMapping("/data")
 public ResponseEntity<String> getData() {
 HttpHeaders headers = new HttpHeaders();
 headers.add("Custom-Header", "CustomValue");
 return ResponseEntity.status(HttpStatus.OK).headers(headers).body("Response Body");// 通常只手动设置响应体
 }
}
// 方式二：使用HttpServletResponse对象
public class ResponseController {
 @GetMapping("/data")
 public void getData(HttpServletResponse response) throws IOException {
 response.setHeader("Custom-Header", "CustomValue");
 response.setStatus(HttpServletResponse.SC_OK);
 response.getWriter().write("Response Body");
 }
}

Web前端

HTML 基础

基本结构示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>Document</title>
</head>
<body>

</body>
</html>

标签不区分大小写，属性值用单双引号均可

常用标签

标题标签：<h1>到<h6>
段落标签：<p>
链接标签：<a href="https://example.com" target="_blank">Example</a>
链接地址使用href属性，打开方式使用target属性（_blank新窗口打开，_self当前窗口打开）
图像标签：<img src="image.jpg" alt="Description">
图像地址使用src属性，alt属性用于图像无法显示时的替代文本
列表标签：<ul>、<ol>、<li>
表格标签：<table>、<tr>、<td>、<th>
表单标签：<form>、<input>、<textarea>

CSS

内联样式：使用style属性直接在HTML标签中定义样式
内部样式表：使用<style>标签在HTML文档的<head>部分定义样式
外部样式表：使用<link>标签链接外部CSS文件

1
2


<link rel="stylesheet" href="styles.css">
</code>

CSS选择器

元素选择器：选择所有指定的元素，例如p选择所有段落
类选择器：选择所有指定类的元素，例如.className选择所有类名为className的元素
ID选择器：选择指定ID的元素，例如#idName选择ID为idName的元素
属性选择器：选择具有指定属性的元素，例如[type="text"]选择所有type属性为text的输入框

1
2
3
4


p {font-size: 16px;}
[class="highlight"] {color: red;}
#header {background-color: blue;}
[type="text"] {background-color: lightyellow;}

JavaScript 基础

引入方式

1

<script src="script.js"></script>

JSON格式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


{
 "name": "John",
 "age": 30,
 "isStudent": false,
 "courses": ["Math", "Science"],
 "address": {
 "street": "123 Main St",
 "city": "Anytown"
 }
}

DOM（文档对象模型）是HTML和XML文档的JS编程接口。它将文档表示为一个树结构，其中每个节点表示文档的一部分（例如元素、属性或文本）。

访问节点：通过document对象访问文档中的元素，例如document.getElementById()、document.querySelector('选择器')。
修改节点：可以更改节点的内容、属性或样式，例如element.innerHTML、element.style。
事件处理：可以为节点添加事件监听器，例如element.addEventListener("click", function)。
创建和删除节点：可以动态添加或移除文档中的元素，例如document.createElement()、parentNode.appendChild()、parentNode.removeChild()。

1

document.getElementById("myElement").innerText = "Hello, World!";

事件监听

1
2
3


document.getElementById("myButton").addEventListener("click", function() {
 alert("Button clicked!");
});

常见事件类型：

鼠标事件：click、dblclick、mouseenter、mouseleave
键盘事件：keydown键盘按下、keyup键盘抬起、keypress
表单事件：submit表单提交、change值改变、focus获得焦点、blur失去焦点

Vue

Vue 是一个用于构建用户界面的渐进式 JavaScript 框架。它的核心库专注于视图层，易于上手，并与其他库或现有项目轻松集成。

Element组件网址：https://element-plus.org/

项目管理命令

创建项目：npm init vue@latest
安装依赖：npm install
运行项目：npm run dev

基础格式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
<div id="app">
 {{ message }}
</div>
<script>
 const app = Vue.createApp({
 data() {
 return {
 message: 'Hello Vue!'
 }
 }
 });
 app.mount('#app');// 将 Vue 应用挂载到具有 id "app" 的 DOM 元素上
</script>

常用函数

v-for: 列表渲染
v-bind: 动态绑定 HTML 属性
v-model: 创建双向数据绑定
v-if / v-else-if / v-else: 条件渲染（是否创建）
v-show: 条件显示（创建后选择是否显示）
v-on: 事件监听

生命周期钩子函数

created: 实例创建后调用
mounted: 实例挂载到 DOM 后调用
updated: 数据更新后调用

VueRouter

Vue Router 是 Vue.js 的官方路由管理器，定义路径与组件之间的对应关系。

：请求链接组件，浏览器会解析成

：动态视图组件，用来渲染展示与路由路径对应的组件

AJAX

在不重新加载整个网页的情况下，与服务器交换数据并更新部分网页内容。

基本使用示例：

1
2
3
4
5
6
7
8


<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
axios.get('https://api.example.com/data')
 .then(function (response) {// then异步处理成功回调
 console.log(response.data);
 })
 .catch(function (error) {
 console.error('Error fetching data:', error);
 });

async/await 语法：将异步代码变成同步

1
2
3
4
5
6
7
8
9


async function fetchData() {
 try {
 const response = await axios.get('https://api.example.com/data');// await 等待异步操作完成
 console.log(response.data);
 } catch (error) {
 console.error('Error fetching data:', error);
 }
}
fetchData();

Web后端

分层解耦

三层架构：控制层Controller（响应前端请求）、业务逻辑层Service（具体处理逻辑）、数据访问层Dao（数据库）

IOC（控制反转） DI（依赖注入）

IOC 将对象的创建和依赖关系的管理交给容器，而不是由对象自身；IOC容器中管理的对象称为 Bean。 DI 通过构造器注入、属性注入或接口注入将依赖关系传递给对象。

1
2
3
4
5
6
7
8
9


@Component // 将类标记为Spring管理的IOC组件
public class UserService {
 private final UserRepository userRepository;// 不用显式指定对象类名，会自动查找各实现类

 @Autowired // 通过构造器注入依赖
 public UserService(UserRepository userRepository) {
 this.userRepository = userRepository;
 }
}

@Autowired按类型注入。
若有多个实现类，对实现类添加@Primary注解指定首选实现类；在@Autowired添加@Qualifier()元注解指定具体实现类。
@Resource(name=“beanName”)按名称注入。

Maven

Maven 是一个项目管理和构建自动化工具，主要用于 Java 项目。它使用 pom.xml 文件来管理项目的构建、依赖和文档。

项目结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


my-app
├── pom.xml // 项目对象模型文件，包含项目信息和配置
└── src // 源代码目录
 ├── main
 │ ├── java
 │ │ └── com
 │ │ └── mycompany
 │ │ └── app
 │ │ └── App.java
 │ └── resources // 资源文件目录
 └── test // 测试代码目录
 ├── java
 └── resources

生命周期分为三套周期:clean、default、site
同一套生命周期中，运行某个阶段会自动执行该阶段之前的所有阶段。 clean 阶段：
- clean: 清理上一次构建生成的文件 default 阶段：
- validate: 验证项目是否正确且所有必要信息是否可用
- compile: 编译项目的源代码
- test: 运行测试
- package: 将编译后的代码打包成可分发格式 JAR 普通模块（内嵌tomcat）；WAR Web模块； POM 聚合模块(只用于管理依赖)
- install: 将包安装到本地 Maven 仓库
- deploy: 将最终包复制到远程仓库 site 阶段：
- site: 生成项目的站点文档

继承与聚合

继承与聚合的pom.xml文件打包方式均为pom，不生成实际的jar/war包。两者可以共存在同一个pom文件中。
聚合与继承均属于设计型模块，并无实际的模块内容

继承

用于简化依赖配置、统一管理依赖。

在父项目中配置共有的依赖，子项目在其 pom.xml 中使用 <parent> 标签指定父项目。

1
2
3
4
5
6
7


子项目的pom.xml
<parent>
 <groupId>com.example</groupId>
 <artifactId>my-parent</artifactId>
 <version>1.0-SNAPSHOT</version>
 <relativePath>../pom.xml</relativePath>
</parent>

对于一些依赖，只在部分子项目中使用。
因此父项目中不直接引入这些依赖，而是通过 <dependencyManagement> 标签统一管理版本，并未直接引入。此时子项目只需声明依赖而不指定版本号。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


父项目的pom.xml
<dependencyManagement>
<!-- 指定了依赖的版本号，但没有引入依赖 -->
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 <version>2.5.4</version>
 </dependency>
 </dependencies>
</dependencyManagement>

子项目的pom.xml
<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 <!-- 版本号由父项目管理，无需指定 -->
 </dependency>
</dependencies>

聚合

将多个模块组织成一个整体，统一进行项目的编译、打包、安装等构建操作。

聚合工程：一个不具有业务功能的“空”工程（有且仅有一个pom文件）【PS：一般来说，继承关系中的父工程与聚合关系中的聚合工程是同一个】

1
2
3
4
5


聚合工程的pom.xml
<modules>
 <module>module-a</module>
 <module>module-b</module>
</modules>

Spring Boot

Spring Boot 是一个用于简化 Spring 应用程序开发的框架。它通过自动配置和约定优于配置的原则，使开发者能够快速创建独立、生产级别的 Spring 应用程序。

基础概念

常用注解：

@SpringBootApplication: 标记主类，启用自动配置和组件扫描
@RestController: 标记控制器类，返回 JSON 或 XML 响应
@GetMapping、@PostMapping: 处理 GET 和 POST 请求
@Service: 标记服务类，包含业务逻辑
@Repository: 标记数据访问类，处理数据库操作
@Autowired: 自动注入依赖的 Bean

1
2
3
4
5
6


@SpringBootApplication // 标记主类，启用自动配置和组件扫描，项目运行入口
public class MyApplication {
 public static void main(String[] args) {
 SpringApplication.run(MyApplication.class, args);
 }
}

配置文件

Spring Boot 使用 application.properties(优先级最高) 或 application.yml 文件对应用的配置进行管理。

在启动程序下拉栏的“Edit Configurations…”中可以设置系统属性(-Dserver.port=9000)和命令行参数(–server.port=9001)。

1
2
3
4


server.port=8081 // 设置服务器端口
spring.datasource.url=jdbc:mysql://localhost:3306/dbname // 数据库连接URL
spring.datasource.username=root // 数据库用户名
spring.datasource.password=your_password // 数据库密码

yml中，冒号后必须有空格；缩进表示层级关系，空格个数不限，但同层级必须统一。

1
2
3
4
5
6
7


server:
 port: 8081 // 设置服务器端口
spring:
 datasource:
 url: jdbc:mysql://localhost:3306/dbname // 数据库连接URL
 username: root // 数据库用户名
 password: your_password // 数据库密码

全局异常处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@RestControllerAdvice //表示当前类是全局异常处理器
//相当于@ControllerAdvice + @ResponseBody，将异常处理方法返回值转换为json后响应给前端
public class GlobalExceptionHandler {
 //处理异常
 @ExceptionHandler
 public Result ex(Exception e){//方法形参中指定能够处理的异常类型
 e.printStackTrace();//打印堆栈中的异常信息
 return Result.error("对不起,操作失败,请联系管理员");//捕获异常后使用result类进行响应
 }
}

Bean 组件

使用 注解@Component 以及它的三个衍生注解（@Controller、@Service、@Repository）来声明IOC容器中的bean对象。

作用域： Spring中的bean默认是单例的（singleton），可以通过注解@Scope设置作用域。

singleton（单例，默认值）：IOC容器中只创建一个共享的Bean实例
prototype（原型）：每次请求都会创建一个新的Bean实例
request：每个HTTP请求创建一个新的Bean实例（仅适用于Web应用）
session：每个HTTP会话创建一个新的Bean实例（仅适用于Web应用）
application：在ServletContext范围内创建一个Bean实例（仅适用于Web应用）

第三方Bean 使用注解 @Configuration 和 @Bean 来定义和注册第三方类的Bean。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


@Configuration // 标记当前类为配置类，集中管理Bean定义
public class MyConfig {
 @Bean
 public MyThirdPartyService1 myThirdPartyService1() {
 return new MyThirdPartyService1();
 }

 @Bean
 public MyThirdPartyService2 myThirdPartyService2() {
 return new MyThirdPartyService2();
 }
}

自定义starter

将某个技术的依赖 + 配置 + Bean 的自动注入全部封装起来，用户只需引入对应的 starter 坐标就能开箱即用。

创建一个新的 Maven 项目，命名为 exp-spring-boot-starter，只包含pom.xml。在 pom.xml 中添加所需的依赖和插件，并引入第二点的自动配置模块。
创建自动配置module，并编写自动配置类

1
2
3
4
5
6
7
8


@Configuration
public class MyAutoConf {
 @Bean
 @ConditionalOnMissingBean // 当容器中没有指定类型的Bean时，才创建该Bean
 public MyService myService() {
 return new MyService();
 }
}

在 src/main/resources/META-INF/spring.factories 文件中注册自动配置类

1
2


org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfiguration.MyAutoConf

使用：在配置文件中引入依赖exp-spring-boot-starter，即可在项目中直接 @Autowired 使用。

1
2


@Autowired
private MyService myService;

*导入第三方依赖Bean

使用 @ComponentScan 扫描指定包路径下的类并注册为Bean。（使用繁琐、性能低）
使用 @Import 导入普通类或配置类或对应的实现类。

1
2
3
4
5
6
7
8
9


import org.springframework.context.annotation.Import;

@Import(MyConfig.class) // 导入配置类
@SpringBootApplication // 主类
public class MyApplication {
 public static void main(String[] args) {
 SpringApplication.run(MyApplication.class, args);
 }
}

使用第三方依赖提供的 @Enable 开启特定功能并注册相关Bean。

1
2
3
4
5
6
7
8
9


import org.springframework.context.annotation.EnableAspectJAutoProxy;

@EnableAspectJAutoProxy // 开启AOP功能
@SpringBootApplication // 主类
public class MyApplication {
 public static void main(String[] args) {
 SpringApplication.run(MyApplication.class, args);
 }
}

MySQL

DDL（数据定义语言）

数据库：

查询数据库：SHOW DATABASES; 查询当前使用的数据库：SELECT DATABASE();
创建数据库：CREATE DATABASE dbname;
删除数据库：DROP DATABASE dbname;
使用数据库：USE dbname;

表：

创建表：CREATE TABLE tablename (column1_name datatype 约束, column2_name datatype, ...);
删除表：DROP TABLE tablename;
查看建表指令：SHOW CREATE TABLE tablename;
查看表结构：DESCRIBE tablename; 或 SHOW COLUMNS FROM tablename;
修改表： ALTER TABLE tablename ADD column_name datatype;（添加列）
ALTER TABLE tablename DROP COLUMN column_name;（删除列）
ALTER TABLE tablename MODIFY COLUMN column_name new_datatype;（修改列数据类型）
修改表名：RENAME TABLE old_tablename TO new_tablename;
删除表：DROP TABLE tablename;

示例：

1
2
3
4
5
6


CREATE TABLE users (
 id INT PRIMARY KEY AUTO_INCREMENT comment '用户ID自增',
 username VARCHAR(50) NOT NULL,
 email VARCHAR(100) NOT NULL,
 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) comment='用户表';

DML（数据操作语言）

插入数据：INSERT INTO tablename (column1, column2, ...) VALUES (value1, value2, ...),(value1, value2, ...);
更新数据：UPDATE tablename SET column1 = value1, column2 = value2, ... WHERE condition;
删除数据：DELETE FROM tablename WHERE condition;

DQL（数据查询语言）

基本查询：SELECT column1, column2, ... FROM tablename; 通配符*表示查询所有列为查询字段设置别名：SELECT column AS alias FROM tablename; 去重：SELECT DISTINCT column FROM tablename;
条件查询：SELECT * FROM tablename WHERE column = value; 范围查询：SELECT * FROM tablename WHERE column BETWEEN value1 AND value2; in查询：SELECT * FROM tablename WHERE column IN (value1, value2, ...); like模糊查询：SELECT * FROM tablename WHERE column LIKE 'pattern'; pattern中%表示任意字符序列，_表示单个任意字符
分组查询：SELECT column, COUNT(*) FROM tablename GROUP BY column; HAVING 子句总是出现在GROUP BY之后，用于过滤分组后的结果，是唯一可以在过滤条件中使用聚合函数（如 COUNT(), SUM(), AVG(), MAX(), MIN()）的子句
例：SELECT salary, COUNT(*) FROM users where salary > 3000 group by salary having COUNT(*) > 2; 查询工资高于3000且人数超过2人的工资情况。
排序查询：SELECT * FROM tablename ORDER BY column ASC|DESC;
分页查询：SELECT * FROM tablename LIMIT offset, row_count;

执行顺序：FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY -> LIMIT 选取表 -> 过滤行 -> 分组 -> 过滤组 -> 选择列 -> 排序 -> 分页

JDBC

Java Database Connectivity 是用于连接和操作关系型数据库的API，是其它 ORM 框架（如 Hibernate、MyBatis）的实现基础。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


Class.forName("com.mysql.cj.jdbc.Driver");// 加载MySQL JDBC驱动程序
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbname", "username", "password");// 建立连接
Statement statement = connection.createStatement();// 创建Statement对象

// DML 示例：插入数据
int rowsAffected = statement.executeUpdate("INSERT INTO tablename (column1, column2) VALUES ('value1', 'value2');");// 返回受影响的行数

// DQL方式1 通过Statement执行
ResultSet resultSet = statement.executeQuery("SELECT id, name FROM tablename WHERE id = ? AND name = ?;");

// DQL方式2 PreparedStatement 预编译查询
PreparedStatement pStatement = connection.prepareStatement("SELECT id, name FROM tablename WHERE id = ? AND name = ?;");// 预编译sql语句，？表示占位符
pStatement.setInt(1, 1);// 设置第一个占位符的值
pStatement.setString(2, "John");
ResultSet resultSet = pStatement.executeQuery();

while (resultSet.next()) {
 String columnValue = resultSet.getString("column_name");// 获取列值
}
resultSet.close();// 关闭ResultSet
statement.close();// 关闭Statement
connection.close();// 关闭Connection

MyBatis

通过XML或注解将SQL语句与Java方法映射，实现对象与数据库之间的映射。

Mybatis中封装查询结果:

如果查询返回的字段名与实体的属性名可以直接对应上，用resultType 。
如果查询返回的字段名与实体的属性名对应不上，或实体属性比较复杂，可以通过resultMap手动封装。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


<!--自定义结果集ResultMap-->
<resultMap id="empResultMap" type="com.itheima.pojo.Emp">
 <id column="id" property="id" />
 <result column="name" property="name" />
 <result column="dept_id" property="deptId" />
 <result column="create_time" property="createTime" />
 <result column="update_time" property="updateTime" />

 <!--封装工作经历exprList-->
 <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">
 <id column="exp_id" property="id"/>
 <result column="exp_company" property="company"/>
 <result column="exp_empid" property="empId"/>
 </collection>
</resultMap>

<!--根据ID查询信息，查询结果封装指向自定义结果集-->
<select id="getById" resultMap="empResultMap">
 select e.*,
 exp.id exp_id,
 exp.emp_id exp_empid,
 exp.company exp_company
 from emp e left join emp_expr exp on e.id = exp.emp_id
 where e.id = #{id}
</select>

持久层接口

1
2
3
4
5
6
7
8


@Mapper // 标记为MyBatis的Mapper接口
public interface UserMapper {// 命名为XxxMapper
 @Select("SELECT * FROM users WHERE id = #{id}") // 使用注解方式定义SQL
 User getUserById(int id);

 @Insert("INSERT INTO users (username, email) VALUES (#{username}, #{email})")
 void insertUser(User user);
}

数据操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 类定义
@Mapper
public interface UserMapper {
 @Select("SELECT * FROM users WHERE id = #{id}")
 public User getUserById(int id);// 根据ID查询用户

 @Insert("INSERT INTO users (username, email) VALUES (#{username}, #{email})")
 public void insertUser(User user);// 增加用户

 @Delete("DELETE FROM users WHERE id = #{id}")
 public void deleteUser(int id);// 删除用户

 @Update("UPDATE users SET email = #{email} WHERE id = #{id}")
 public void updateUser(@Param("id") int id, String email);// 更新用户邮箱
 // 非官方骨架中，若有多个形参需要使用@Param注解指定参数名与sql语句对应
}

// 使用示例
@Autowired
private UserMapper userMapper;
public void exampleUsage() {
 User user = userMapper.getUserById(1);// 查询用户
 userMapper.insertUser(new User("newUser", "newuser@example.com"));// 增
 userMapper.deleteUser(2);// 删
 userMapper.updateUser(3, "updated@example.com");// 改
}

多表关系

外键约束(物理)

创建外键：ALTER TABLE 子表名 ADD CONSTRAINT 外键名 FOREIGN KEY (column_name) REFERENCES 父表名(parent_column); 建表时创建：[CONSTRAINT] 外键名 FOREIGN KEY (column_name) REFERENCES 父表名(parent_column)，应位于表定义的最后。
删除外键：ALTER TABLE 子表名 DROP FOREIGN KEY 外键名;

多对多关系 通过建立第三张中间表，中间表至少包含两个外键，分别关联两方主键。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


CREATE TABLE students (
 id INT PRIMARY KEY AUTO_INCREMENT,
 name VARCHAR(100) NOT NULL
);
CREATE TABLE courses (
 id INT PRIMARY KEY AUTO_INCREMENT,
 title VARCHAR(100) NOT NULL
);
CREATE TABLE student_courses (
 student_id INT,
 course_id INT,
 PRIMARY KEY (student_id, course_id),
 FOREIGN KEY (student_id) REFERENCES students(id),
 FOREIGN KEY (course_id) REFERENCES courses(id)
);

多表查询

内连接

查询多表中交集部分的记录，即满足连接条件的记录。

1

SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件 ... ;

一对一：SELECT * FROM table1 JOIN table2 ON table1.id = table2.id;
一对多：SELECT * FROM table1 JOIN table2 ON table1.id = table2.table1_id;
多对多：SELECT * FROM table1 JOIN table2 ON table1.id = table2.table1_id JOIN table3 ON table2.table3_id = table3.id;

外连接

查询多表中交集部分及非交集部分的记录。

左外连接（LEFT JOIN）：返回左表的所有记录及右表中匹配的记录

1

SELECT 字段列表 FROM 表1 LEFT JOIN 表2 ON 连接条件 ... ;

右外连接（RIGHT JOIN）：返回右表的所有记录及左表中匹配的记录

1

SELECT 字段列表 FROM 表1 RIGHT JOIN 表2 ON 连接条件 ... ;

子查询

在一个查询语句中嵌套另一个查询语句。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


SELECT 字段列表 FROM 表名 WHERE 列名 OPERATOR (子查询);

-- 示例：查询所有选修了课程ID为1的学生
SELECT * FROM students WHERE id IN (SELECT student_id FROM student_courses WHERE course_id = 1);

-- 查询每个部门中薪资最高的员工信息
SELECT * FROM emp e, (SELECT dept_id, MAX(salary) max_sal FROM emp GROUP BY dept_id) x WHERE e.dept_id = x.dept_id AND e.salary = x.max_sal;

-- 查询员工所属部门名称及员工人数超过10人的部门名称，e.dept_id = d.id用于约束两表的连接关系
SELECT d.name FROM emp AS e, dept AS d WHERE e.dept_id = d.id GROUP BY d.name HAVING COUNT(*) > 10;

-- 查询工资 低于本部门平均工资 的员工信息 。
SELECT e.* FROM emp e, (SELECT dept_id, AVG(salary) avg_sal FROM emp GROUP BY dept_id) AS x
WHERE e.dept_id = x.dept_id AND e.salary < x.avg_sal;

优化

实体类传递参数，避免逐个参数传递

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class EmpQuery {
 private String name;
 private Integer gender;
 private Date begin;
 private Date end;
 // 省略getter和setter
}
@Mapper
public interface EmpMapper {
 List<Emp> list(EmpQuery empQuery);// 会自动将empQuery对象的属性映射到SQL语句中的参数（名称需要一致）
}

动态SQL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.EmpMapper">
 <select id="list" resultType="com.itheima.pojo.Emp">
 select e.*, d.name deptName from emp as e left join dept as d on e.dept_id = d.id
 <where>
 <if test="name != null and name != ''">
 e.name like concat('%',#{name},'%')
 </if>
 <if test="gender != null">
 and e.gender = #{gender}
 </if>
 <if test="begin != null and end != null">
 and e.entry_date between #{begin} and #{end}
 </if>
 </where>
 </select>
</mapper>

：条件成立则进行拼接。：根据查询条件生成where关键字，并会自动去除条件前面多余的and或or（若不去除，则无name，有gender时会多出一个and）

事务管理

事务（Transaction）是一组操作的集合，这些操作要么全部成功，要么全部失败，保持数据的一致性和完整性。事务具有四个基本特性，简称为ACID特性：

原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部不完成。
一致性（Consistency）：事务执行前后，数据库必须保持一致的状态。执行中可能会有中间状态，但最终不论成败都会回到一致性状态。
隔离性（Isolation）：并发执行的事务之间相互隔离，互不干扰。
持久性（Durability）：一旦事务提交，其结果是永久性的，即使系统崩溃也不会丢失。

MySQL的事务默认是自动提交的。当执行一条DML语句，MySQL会立即隐式的提交事务。

使用方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


-- 开启事务
start transaction; / begin;
-- 1. 保存员工基本信息
insert into emp values (39, 'Tom', '123456', '汤姆', 1, '13300001111', 1, 4000, '1.jpg', '2023-11-01', 1, now(), now());
-- 2. 保存员工的工作经历信息
insert into emp_expr(emp_id, begin, end, company, job) values (39,'2019-01-01', '2020-01-01', '百度', '开发'), (39,'2020-01-10', '2022-02-01', '阿里', '架构');
-- 提交事务(全部成功)
commit;
-- 回滚事务(有一个失败)
rollback;

@Transactional 注解:在当前方法（类、接口）执行之前开启事务，方法执行完毕之后提交事务,若执行出现异常则回滚事务。

默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。
当抛出 Exception（编译时异常）或其子类时默认不回滚，除非手动配置 @Transactional(rollbackFor = Exception.class)

事务的传播行为

REQUIRED（默认）：如果已存在事务，则加入；如果没有，则创建新事务。
REQUIRES_NEW：无论有无，总是创建新事务；如果存在事务，则将当前事务挂起

登录认证

本质是根据用户名和密码查询员工信息。

HTTP协议是无状态协议，每次请求都是独立的，服务器不会自动记住用户的登录状态。因此需要在每次请求时都进行登录校验。
常见的登录校验方法有： 会话技术：

Cookie
Session
Token

统一拦截： 通过拦截器统一处理登录校验逻辑，简化代码重复性，提高可维护性。

过滤器（Filter）
拦截器（Interceptor）

会话技术

客户端存储少量数据（如Session ID），每次请求时浏览器会自动携带Cookie信息。
客户端第一次请求服务器时，服务器自动创建一个Cookie，并将其发送给客户端浏览器。
浏览器会将Cookie保存下来，并在后续的每次请求中自动携带该Cookie信息发送给服务器。

HTTP 协议提供了一个响应头和请求头：

响应头 Set-Cookie ：设置Cookie S->C
请求头 Cookie：携带Cookie C->S

特点：

HTTP原生支持
安全性较低，能在客户端被篡改
不能跨域
无法在移动端使用

Session（会话）

服务器端存储用户的登录状态信息，每个用户对应一个Session对象。当客户端第一次请求服务器时，服务器会创建一个Session对象，并生成一个唯一的Session ID。
服务器将Session ID通过Cookie发送给客户端，客户端在后续请求中携带该Cookie信息。服务器通过Session ID识别用户的登录状态。

特点：

集群环境下，Session信息需要共享，增加复杂性
底层基于Cookie实现，存在相同的安全性问题，只是将数据存储在服务器端相对安全

Token（令牌）

客户端在登录成功后，服务器生成一个唯一的令牌，并将其返回给客户端。
客户端后续请求的请求头中需包含令牌，服务器通过校验令牌的有效性识别登录状态。

特点：

无状态，适合分布式系统
支持移动端
支持跨域
但校验算法需要自行设计

JWT（JSON Web Token）

对原始的json数据格式进行安全的封装。

特点：

简洁：是一个简单的字符串（经过BASE64编码）。可以在请求参数或者是请求头当中直接传递。
自包含：可以根据需求在jwt令牌中存储自定义的数据内容。

结构：

头部（Header）：包含令牌的类型和签名算法
载荷（Payload）：包含声明（Claims），即存储的数据
签名（Signature）：用于验证令牌的完整性和真实性

统一拦截

过滤器（Filter）过滤器是 JavaWeb三大组件(Servlet、Filter、Listener)之一。

需要在项目启动类上添加注解 @ServletComponentScan 开启SpringBoot项目对于Servlet组件的支持。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


@WebFilter(urlPatterns = "/*") // 配置过滤器拦截的请求路径
public class DemoFilter implements Filter {
 //初始化方法, web服务器启动, 创建Filter实例时调用, 只调用一次
 public void init(FilterConfig filterConfig) throws ServletException {
 System.out.println("init ...");
 }
 //拦截方法,可以调用多次
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
 System.out.println("放行前逻辑.....");
 filterChain.doFilter(servletRequest,servletResponse);// 放行方法
 System.out.println("放行后逻辑.....");// 访问完资源还会回到过滤器中
 }
 //销毁方法, web服务器关闭时调用, 只调用一次
 public void destroy() {
 System.out.println("destroy ... ");
 }
}

过滤器链的执行顺序：对于通过注解配置的Filter，优先级是过滤器类名的自然排序。

拦截器（Interceptor）拦截器是 Spring MVC 提供的一种机制，用于在请求处理之前和之后执行特定的逻辑。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


//自定义拦截器，托管给Spring容器管理
@Component
public class DemoInterceptor implements HandlerInterceptor {
 //目标资源方法执行前执行 
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 System.out.println("preHandle .... ");

 return true; //true表示放行；返回false：不放行
 }

 //目标资源方法执行后执行
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 System.out.println("postHandle ... ");
 }

 //渲染完毕后执行，最后执行
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 System.out.println("afterCompletion .... ");
 }
}

获取当前登录用户的信息

通过Filter或Interceptor拦截请求后，如何将请求头中信息传递给业务逻辑层？
在同一个线程/同一个请求中，使用ThreadLocal进行数据共享。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


public class LocalContent {
 // 创建ThreadLocal对象，用于存储当前请求的信息
 private static final ThreadLocal<Integer> CURRENT_LOCAL = new ThreadLocal<>();
 // 记录、读取信息的方法
 public static void setCurrentId(Integer employeeId) {
 CURRENT_LOCAL.set(employeeId);
 }
 public static Integer getCurrentId() {
 return CURRENT_LOCAL.get();
 }
 public static void remove() {
 CURRENT_LOCAL.remove();
 }
}

// 在拦截器中使用
@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {
 // ...
 // 获取请求头并解析得到employeeId后
 LocalContent.setCurrentId(employeeId);// 记录数据

 filterChain.doFilter(servletRequest, servletResponse);// 放行
 LocalContent.remove();// 请求处理完毕，移除数据
}

// 在业务逻辑层使用
Integer employeeId = LocalContent.getCurrentId();// 读取数据

AOP(面向切面编程)

通俗的理解：将与业务无关的代码（如日志记录、权限校验、事务管理等）从业务逻辑中分离出来，在运行时无侵入地实现动态代理，从而实现代码的模块化和复用。

核心概念

连接点（Join Point）：程序执行中的特定点，即方法、异常等。
切入点（PointCut）：用规则或表达式限定操作连接点的范围。
通知（Advice）：在连接点上执行的操作，如前置通知、后置通知、环绕通知等。
切面（Aspect）：即通知+切入点。模块化的关注，如日志记录、事务管理等。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


@Component //托管给Spring容器管理，才能识别到切面注解
@Aspect //标记为切面类
@Slf4j
public class RecordTimeAspect {

 @Around("execution(* com.hych.service.impl.DeptServiceImpl.*(..))")// 围绕通知，指定切入点表达式
 public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
 //记录方法执行开始时间
 long begin = System.currentTimeMillis();
 //执行原始方法
 Object result = pjp.proceed();
 //记录方法执行结束时间
 long end = System.currentTimeMillis();
 //计算方法执行耗时
 log.info("方法执行耗时: {}毫秒",end-begin);
 return result;
 }
}

@Aspect 注解表示该类是一个切面类。 @Around 注解表示环绕通知，可以在方法执行前后添加自定义逻辑。 execution(* com.hych.service.impl.DeptServiceImpl.*(..)) 表示切入点表达式，匹配 DeptServiceImpl 类中的所有方法。 pjp 为要操作的目标对象。 pjp.proceed() 执行目标对象中被AOP控制的方法，即连接点。

通知类型

@Around：环绕通知，在方法执行前后执行。若pjp.proceed()方法抛出异常，则后续通知逻辑不再执行。 @Before：前置通知，在方法执行前执行。 @After：后置通知，在方法执行后执行（无论方法是否成功完成）。 @AfterReturning：返回通知，在方法成功执行后执行，有异常不执行。 @AfterThrowing：异常通知，在方法抛出异常后执行。

1
2
3
4
5


// 除了around，其余四种通知使用格式（调用对象为jp而非pjp）
@Before("execution(* com.itheima.service.*.*(..))")
 public void before(JoinPoint joinPoint){// JoinPoint类是ProceedingJoinPoint的父类
 log.info("before ...");
 }

不同切面类中通知执行顺序：对于Before，切面类字母排名靠前的先执行；对于After，切面类字母排名靠前的后执行。
可通过@Order(Integer)注解指定顺序，按数字顺序规则同上。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


@Slf4j
@Component
@Aspect
public class MyAspect1 {
 //前置通知
 @Before
 public void before(JoinPoint joinPoint){log.info("MyAspect1 -> before ...");}
 //后置通知
 @After
 public void after(JoinPoint joinPoint){log.info("MyAspect1 -> after ...");}
}

// MyAspect2 ...

// MyAspect3 ...

前置通知执行顺序：MyAspect1 -> MyAspect2 -> MyAspect3 后置通知执行顺序：MyAspect3 -> MyAspect2 -> MyAspect1

切入点表达式

execution 格式：

1

execution([访问修饰符] 返回值 [包名.类名.]方法名(方法参数) [throws 异常])

通配符：

*：匹配任意单个符号（类名、方法名、返回值类型），也可以通配名称的一部分（如find*可匹配 findByID）
..：匹配任意数量的参数（包括0个参数）

可使用 && ，||，！组合复杂的切入点表达式。

annotation 匹配标注了指定注解的方法或类。可在选为连接点的方法上添加自定义注解。

Redis

Sat, 13 Sep 2025 09:48:39 +0800

Redis

基于内存的键值型NoSQL数据库，单线程（因此每个命令具有原子性）

NoSql(Not Only Sql)，不仅仅是SQL，泛指非关系型数据库。

Redis应用场景：缓存、消息队列、任务队列、分布式锁

通用命令

命令	说明
`KEYS pattern`	查找所有符合给定模式(pattern)的key
`EXISTS key`	检查给定key是否存在
`TYPE key`	返回key所储存的值的类型
`TTL key`	返回给定key的剩余生存时间(TTL, time to live)，以秒为单位
`DEL key`	该命令用于在key存在是删除key

数据类型

String

又细分为普通字符串、整数和浮点数。
字符串类型的最大空间不超过512MB。

常用命令：

命令	说明
`SET key value`	设置指定key的值为value
`GET key`	获取指定key的值
`MSET key value [key value ...]`	同时设置一个或多个key-value对
`MGET key [key ...]`	获取所有给定key的值
`INCR key`	将key中储存的数字值增一
`DECR key`	将key中储存的数字值减一
`INCRBY key increment`	将key中储存的数字值增加指定的增量increment
`DECRBY key decrement`	将key中储存的数字值减少指定的减量decrement
—	—
`SETNX key value`	只有在key不存在时，设置key的值为value
`SETEX key seconds value`	将key的值设为value，并将key的生存时间设为seconds秒
`APPEND key value`	如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值的末尾
`STRLEN key`	返回key所储存的字符串值的长度

KEY结构： Redis没有类似MySQL中Table的概念，使用多个单词形成层级结构以区分不同类型的数据。

prj:user:1 {“id”:1, “name”: “Jack”, “age”: 21} prj:dish:1 {“id”:1, “name”: “鲟鱼火锅”, “price”: 4999}

Hash

Hash类型是一个键值对集合，适合用于存储对象。其value本身是一个键值对集合。

常用命令：

命令	说明
`HSET key field value`	为key中的hash类型添加一个field-value对
`HGET key field`	获取key中的hash类型指定field的值
`HMSET key field value [field value ...]`	同时为key中的hash类型设置多个field-value对
`HMGET key field [field ...]`	获取key中的hash类型指定的多个field的值
`HGETALL key`	获取key中的hash类型的所有field-value对
`HDEL key field [field ...]`	删除key中的hash类型指定的一个或多个field
`HLEN key`	获取key中的hash类型的field数量
`HKEYS key`	获取key中的hash类型的所有field

List

List类型是一个简单的字符串列表，特征与linked list相似，按照插入顺序排序、插入和删除快、查询速度一般、元素可以重复。
常用来存储有序数据，例如：朋友圈点赞列表，评论列表等。

常用命令：

命令	说明
`LPUSH key value [value ...]`	将一个或多个值value插入到对应的表头
`RPUSH key value [value ...]`	将一个或多个值value插入到对应的表尾
`LPOP key`	移除并返回对应的表头元素
`RPOP key`	移除并返回对应的表尾元素
`BLPOP key [key ...] timeout`	同LPOP，若list为空则等待timeout
`LRANGE key start end`	返回对应的list中指定闭合区间内的元素

Set

Set类型是string类型的无序集合，集合内的元素无序、查找快、不允许重复。

常用命令：

命令	说明
`SADD key member [member ...]`	向set添加一个或多个元素member
`SREM key member [member ...]`	移除set中的一个或多个元素member
`SMEMBERS key`	返回set中的所有成员
`SCARD key`	返回set中的元素个数
`SISMEMBER key member`	判断元素member是否是set的成员
`SINTER key [key ...]`	返回多个set的交集
`SUNION key [key ...]`	返回多个set的并集
`SDIFF key [key ...]`	返回多个set的差集

Sorted Set

Sorted Set类型是string类型的有序集合，集合内的元素按分数(score)排序、查找快、不允许重复。

常用命令：

命令	说明
`ZADD key score member [score member ...]`	向有序集合添加一个或多个元素member及其分数score
`ZREM key member [member ...]`	移除有序集合中的一个或多个元素member
`ZCARD key`	返回有序集合中的元素个数
`ZSCORE key member`	返回有序集合中元素member的分数score
`ZRANK key member`	返回有序集合中元素member的排名(按分数从低到高排序)
`ZRANGE key min max [WITHSCORES]`	返回有序集合中指定闭合区间内的元素
`ZCOUNT key min max`	返回有序集合中指定分数区间内的元素个数
`ZREVRANGE key start end [WITHSCORES]`	返回有序集合中指定闭合区间内的元素，按分数从高到低排序
`ZINTER ZUNION ZDIFF`	有序集合的交集、并集、差集操作

Java客户端

Jedis：功能完善、使用广泛的Java Redis客户端。
Lettuce：基于Netty的高性能Java Redis客户端，支持异步和响应式编程模型。
Redisson：功能丰富的Java Redis客户端，提供分布式锁、分布式集合等高级功能。
SpringDataRedis：Spring框架的Redis模块，集成了Jedis和Lettuce客户端。

Numpy & Scipy

Thu, 13 Mar 2025 09:48:39 +0800

Numpy

Scipy

常量模块constants

返回各种数学常数、各类单位的值，如pi，单位等

1
2


from scipy import constants
print(constants.pi)

优化器optimize

最小化函数: 使用 minimize 方法对多种优化算法进行统一接口封装。
求解方程的根: 使用 root 方法求解非线性方程或方程组。
曲线拟合: 使用 curve_fit 进行非线性最小二乘拟合。
线性规划: 使用 linprog 解决线性规划问题。

稀疏矩阵sparse

指大部分元素都为0的矩阵 CSR(Compressed Sparse Row)矩阵是一种高效的稀疏矩阵存储格式,主要用于存储和计算大型稀疏矩阵。

主要特点:

只存储非零元素及其位置信息
按行压缩存储
适合进行矩阵-向量乘法运算

基本用法示例:

1
2
3
4
5
6
7


import numpy as np
from scipy.sparse import csr_matrix

arr = np.array([0, 0, 0, 0, 0, 1, 1, 0, 2])

print(csr_matrix(arr))
输出结果为： (0, 5) 1 (0, 6) 1 (0, 8) 2

图结构

邻接矩阵（Adjacency Matrix）：由两部分组成：V 是顶点，E 是边，边有时会有权重，表示节点之间的连接强度。
组成：用一个一维数组存放图中所有顶点数据，用一个二维数组存放顶点间关系（边或弧）的数据，这个二维数组称为邻接矩阵。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import numpy as np
from scipy.sparse.csgraph import connected_components
from scipy.sparse import csr_matrix

# 创建一个3x3的邻接矩阵，表示一个无向图
arr = np.array([
 [0, 1, 2], # 节点0的连接情况
 [1, 0, 0], # 节点1的连接情况
 [2, 0, 0] # 节点2的连接情况
])
# 将邻接矩阵转换为CSR格式的稀疏矩阵
newarr = csr_matrix(arr)

# 使用connected_components函数找出图中的连通分量
# 返回值包含两个部分：
# 1. 连通分量的数量
# 2. 每个节点所属的连通分量编号
print(connected_components(newarr))# (1, array([0, 0, 0], dtype=int32))

空间数据

三角测量

多边形的三角测量是将多边形分成多个三角形。

任何曲面都存在三角剖分。
假设曲面上有一个三角剖分，我们把所有三角形的顶点总个数记为 p(公共顶点只看成一个)，边数记为 a，三角形的个数记为 n，则欧拉示性数e=p-a+n 是曲面的拓扑不变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


import numpy as np
from scipy.spatial import Delaunay
import matplotlib.pyplot as plt

points = np.array([
 [2, 4],
 [3, 4],
 [3, 0],
 [2, 2],
 [4, 1]
])
simplices = Delaunay(points).simplices # 三角形中顶点的索引

plt.triplot(points[:, 0], points[:, 1], simplices)
plt.scatter(points[:, 0], points[:, 1], color='r')

plt.show()

各类距离

·欧几里得距离：m维空间中两个点之间的真实距离

1
2
3
4
5
6
7


from scipy.spatial.distance import euclidean

p1 = (1, 0)
p2 = (10, 2)
res = euclidean(p1, p2)

print(res)

·曼哈顿距离：只能上、下、左、右四个方向进行移动

1
2
3
4
5
6
7


from scipy.spatial.distance import cityblock

p1 = (1, 0)
p2 = (10, 2)
res = cityblock(p1, p2)

print(res)

余弦距离：也称为余弦相似度，通过测量两个向量的夹角的余弦值来度量它们之间的相似性

1
2
3
4
5
6
7


from scipy.spatial.distance import cosine

p1 = (1, 0)
p2 = (10, 2)
res = cosine(p1, p2)

print(res)

汉明距离：两个字符串对应位置的不同字符的个数

1
2
3
4
5
6
7


from scipy.spatial.distance import hamming

p1 = (True, False, True)
p2 = (False, True, True)
res = hamming(p1, p2)

print(res)

插值

通过已知的、离散的数据点，在范围内推求新数据点的过程或方法。
一维插值：方法 interp1d()
返回一个可调用函数，该函数可以用新的 x 调用并返回相应的 y

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from scipy.interpolate import interp1d
import numpy as np

xs = np.arange(10)# 限定输入范围
ys = 2*xs + 1# 计算方法
interp_func = interp1d(xs, ys)

newarr = interp_func(np.arange(2.1, 3, 0.1))# 插值范围及步长

print(newarr)# [5.2 5.4 5.6 5.8 6. 6.2 6.4 6.6 6.8]

Python

Tue, 13 Aug 2024 09:48:39 +0800

基础语法

*args 允许你将任意数量的非关键字参数传递给一个函数。这些参数会以一个元组的形式传递给函数。

**kwargs 允许你将任意数量的关键字参数传递给一个函数。这些参数会以一个字典的形式传递给函数。

1
2
3
4
5


 def my_function(*args, **kwargs):
 print("args:", args)
 print("kwargs:", kwargs)

 my_function(1, 2, 3, name="Alice", age=30)

数据类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

对不可变数据对象重新赋值，实际上是创建了一个新的对象，不是修改了原来的对象。

isinstance()

isinstance() 函数用于判断一个对象是否是一个已知的类型，返回 True 或 False。

1
2


a = 2
isinstance (a,int)# True

type()与isinstance()的区别：
type() 不会认为子类是一种父类类型，不考虑继承关系 isinstance() 会认为子类是一种父类类型，考虑继承关系
推荐使用 isinstance() 来判断对象类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 区别示例
class A:
 pass
class B(A):
 pass

isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False

数据类型转换

对于同大类的数据类型，Python 可以自动进行类型转换。如int+float=float。
在不同类运算时，Python 中可以使用 int()、float()、str() 函数将其他类型转换为数字、浮点数、字符串。

数字

Python 支持四种不同的数字类型：int、float、bool、complex（复数）。

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。 pi,e,tau 都是内置常量。 bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1。
布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。

数字运算

a**b 表示 a 的 b 次方
a//b 表示 a 除以 b 的商

10//3=3, 10.0//3=3.0
a%b 表示 a 除以 b 的余数

:= 赋值运算符

 if (n := 10) > 5: # 赋值表达式
print(n)

运算函数

abs() 取绝对值
round(x，n) 四舍五入到 n 位小数
ceil() 向上取整
floor() 向下取整
exp() 计算 e 的 x 次方
log() 计算自然对数
log10() 计算以 10 为底的对数
pow() 计算 x 的 y 次方
sqrt() 计算平方根
ord() 获得字符的 ASCII 码

随机数函数

random() 随机生成 0 到 1 之间的浮点数
randint(a, b) 随机生成 a 到 b 之间的整数
choice(seq) 从序列 seq 中随机选择一个元素
shuffle(seq) 将序列 seq 随机排序
seed(x) 设置随机数种子
uniform(a, b) 随机生成 a 到 b 之间的浮点数
gauss(mu, sigma) 随机生成符合高斯分布的随机数

成员运算符

in 和 not in 用于判断元素是否存在于列表、元组、字符串、字典等序列中。

身份运算符

is 和 is not 用于比较两个变量是否指向同一个对象。

字符串

Python 中单引号 ’ 和双引号 " 使用完全相同
使用三引号 ’’’ 或 """ 可以指定一个多行字符串(所见即所得)
```
 '''This is a
multi-line string.
'''
```
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。

如 r"this is a line with \n" 则 \n 会显示，并不是换行。
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始

1
2
3
4
5
6
7
8


 str='123456789'

 print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
 print(str[2:]) # 输出从第三个开始后的所有字符
 print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
 print(str * 2) # 输出字符串两次
 print ("我叫%s今年 %d 岁!" % ('小明', 10))
 # 格式化输出字符串

f-string

>>>f'{1+2}' # 使用表达式
'3'
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>>f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

转义字符

转义字符	含义
\b	退格
\t	横向制表符
\r	回车
\f	换页
\ooo	八进制数
\xhh	十六进制数

print('google runoob taobao\r123456')
123456 runoob taobao
八进制 \012 代表换行
十六进制 \x0a 代表换行

列表

列表是 Python 中最常用的数据结构，用方括号 [] 来表示。
同一列表可以包含不同类型的数据，可以随时添加或删除元素。

列表可以嵌套列表。
列表可以当作栈、队列、集合使用，特别是pop和append方法。

1
2
3
4
5
6


 list.append(obj) # 在列表末尾添加新的对象
 list.extend(seq) # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
 list.remove(obj) # 删除列表中某个值的第一个匹配项
 del list[index] # 删除指定索引的元素
 list.pop(n) # 从列表中删除某个元素（默认最后一个元素），并且返回该元素的值
 list.reverse() # 反转列表

列表的sort()方法

sort() 方法没有返回值，但是会对列表的对象进行排序

1
2
3
4


list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- key 参数要求传递的是一个函数，用于提取每个元素的排序依据，该参数取自于可迭代对象中，指定可迭代对象中的一个元素（即元素的元素）来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）

先根据key指定要排序的元素，再根据reverse指定顺序、cmp指定比较的方法。

例子：

1
2
3
4
5
6
7
8


# 获取列表的第二个元素
def takeSecond(elem):
 return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
print(random) # 输出：[(4, 1), (2, 2), (1, 3), (3, 4)]

sorted()函数也能对列表进行排序，但是它返回一个新的列表，而不是对原列表进行排序。

1
2


sorted(iterable, key=None, reverse=False)
# iterable -- 待排序的可迭代对象。

例子：

1
2
3
4
5
6
7
8


def SortTuples( x ): # x is a list contain tuples
 return sorted(x,key=lambda item: item[1])

if __name__ == '__main__':
 l = [('English', 88), ('Science', 90), ('Maths', 97), ('Social sciences', 82)]
 m = SortTuples( l )
 print( m )
 assert m == [('Social sciences', 82), ('English', 88), ('Science', 90), ('Maths', 97)]

字典

字典是一种映射类型，字典用 { } 标识，它是一个无序的键(key) : 值(value) 的集合，集合元素间用逗号隔开。

键(key)必须使用不可变类型，比如字符串、数字或元组。
键应该是唯一的，重复的键会覆盖前面的键。
值(value)可以是任意类型，包括列表甚至另一个字典？。

访问字典的值

1
2
3
4
5
6
7
8
9


 dictexp = {}
 dictexp['one'] = "1 - 菜鸟教程"
 dictexp[2] = "2 - 菜鸟工具"

 print (dictexp['one']) # 输出键为 'one' 的值
 print (dictexp[2]) # 输出键为 2 的值
 print (dictexp) # 输出完整的字典
 print (dictexp.keys()) # 输出所有键
 print (dictexp.values()) # 输出所有值

字典内置函数

1
2


 len(dictexp) #计算字典元素个数 
 str(dictexp) #输出字典可打印的字符串表示 

字典嵌套

例子中，键’class’的值是子字典。
操作上实际就是多级索引。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 dictexp = {'name': 'runoob', 'age': 7, 'class': {'name': '101', 'teacher': 'teacher1'}}

 # 访问 'class' 对应子字典中的键 'name' 的值
 print(dictexp['class']['name'])
 # 连续使用get()方法安全访问，避免因为键不存在导致程序崩溃（这当然也适用于普通字典）
 print(f"get:{dictexp.get('class', {}).get('name', 'default')}") # 输出键为 'class' 的值中的键为 'name' 的值，如果不存在则返回'default'

 # 想要遍历到子字典中的所有键值对，需要循环嵌套
 for key, value in dictexp.items():
 print(f"key:{key}", f"value:{value}")
 if type(value) == dict:
 for k, v in value.items():
 print(f"subdict key:{k}", f"subdict value:{v}")

集合

注意与字典的区别
在 Python 中，集合使用大括号 {} 表示，元素之间用逗号分隔。
另外，也可以使用 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

语句规则

多行语句

Python允许使用反斜杠\来实现多行语句，例如：

total = item_one + \
item_two + \
item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \

print() 函数

print() 函数可以输出多个值，用逗号隔开。
默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""。

条件语句

Python中的else if关键字为elif.
Python中没有switch语句，所以多个条件判断，只能用 elif 来实现。在python3.10中引入了match语句。

match subject:
case <pattern_1>:
<action_1>
case <pattern_2>:
<action_2>
case <pattern_3>|<pattern_4>|...|<pattern_n>: #多个条件用竖线分隔
<action_3>
case _: #'_'是通配符，即C语言的default
<action_wildcard>

循环语句

Python中有两种循环语句，一种是for…in循环，另一种是while循环。
for循环的语法格式如下：

for <变量> in <序列>:
<语句>
else:
<语句> # 当for循环正常结束时，执行该语句。

对于<序列>部分，可以使用range()函数生成整数序列，使用item()函数遍历字典的键值对。

item()函数返回一个元组，同时包含字典的键和值。

while循环的语法格式如下：
注意：Python中没有do-while循环。

while <条件>:
<语句>
else:
<语句> # 当while条件为False时，执行该语句并退出循环。

break和continue语句
使用break语句可以提前退出循环，并不执行else语句；
使用continue语句可以跳过当前的迭代并继续下一轮循环。

这两个语句对于for和while跳出过程一致。

推导式

推导式是一种根据已有列表、字典等创建新数据序列的简洁方式，同时可以对原序列进行过滤、排序等操作。
语法格式如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


 # 生成器表达式
 (<表达式> for <变量> in <序列> if <条件>)
 #eg:
 numbers = [1, 2, 3, 4, 5, 6, 7, 8]
 even_numbers = (num for num in numbers if num % 2 == 0)
 print(list(even_numbers)) # 输出：[2, 4, 6, 8]//也可以用next方法或for循环
 # 列表推导式
 [<表达式> for <变量> in <序列> if <条件>]
 #eg:
 names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
 new_names = [name.upper()for name in names if len(name)>3]
 print(new_names)
 # 输出结果：['ALICE', 'JERRY', 'WENDY', 'SMITH']

 # 字典推导式
 {<键表达式>:<值表达式> for <变量> in <序列> if <条件>}
 #eg:
 d = {'a':1,'b':2,'c':3}
 new_d = {k:v for k,v in d.items() if v>1}
 print(new_d)
 # 输出结果：{'b': 2, 'c': 3}

函数

默认参数

def function_name(parameter1, parameter2=default_value):
<表达式>

如果调用该函数时不提供 parameter2 的值，则会使用 default_value。
注意：

默认参数必须放在非默认参数的后面。
默认参数的值在函数定义时计算一次，而不是在函数每次调用时计算。

因此，更推荐使用 None 作为默认参数，在函数内进行判断之后赋值：

def function_name(parameter1, parameter2=None):
if parameter2 is None:
parameter2 = default_value
<其它表达式>

return和yeild

return语句用来提前结束函数
而yield语句用于生成一个值，并在下一次迭代时返回。
注意：

return 语句只能在函数内部使用，而 yield 语句可以在函数内部或外部使用。
yield 语句只能用于生成器函数，而 return 语句只能用于非生成器函数。

lambda（匿名函数）

lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用。

语法格式：

lambda arguments: expression

示例：

1
2
3
4
5
6
7
8


 # 示例1
 x = lambda a, b : a * b
 print(x(5, 6)) # 输出：30

 # 示例2
 numbers = [1, 2, 3, 4, 5, 6, 7, 8]
 even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
 print(even_numbers) # 输出：[2, 4, 6, 8]

功能模块

迭代器(iterator)

迭代器是一个记住遍历的位置的对象，不像列表把所有元素一次性加载到内存，而是每次需要数据的时候才实时计算下一个数据，节省内存。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

基本生成： Python的迭代器有两个基本的方法：iter() 和 next()。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


 list=[1,2,3,4]
 it = iter(list) # 创建迭代器对象
 # 使用next()函数获取迭代器中下一个元素
 for x in range(4):
 print (next(it))

 # 使用for循环获取迭代器中下一个元素
 for x in it:
 print (x, end=" ")

 # 直接读取列表
 for x in list:
 print (x, end=" ")

 # 三种方法结果都是1 2 3 4

客制化生成： 如果要创建自己的迭代器，需要定义一个类，并实现私有的iter()和next()方法。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


 class MyNumbers:
 def __iter__(self): # 类私有方法，返回一个特殊的迭代器对象
 self.a = 1
 return self

 def __next__(self):
 if self.a <= 20: # 可以限定迭代次数
 x = self.a
 self.a += 1 # 可以客制化迭代生成值
 return x
 else:
 raise StopIteration # StopIteration 异常用于标识迭代的完成

 myclass = MyNumbers()
 myiter = iter(myclass)

 for x in myiter:
 print(x)

生成器(generator)[更简便更常用，当正常函数写]

生成器本质上是一种特殊的迭代器(使用yeild语句)，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

简单地讲，yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 function(var) 不会执行该函数，而是返回一个 iterable 对象。
当在生成器函数中使用 yield 语句时，函数的执行将会暂停。yield 对应的值在函数被调用时不会立刻返回，而是调用next方法时才返回。
然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


 def countdown(n):
 while n > 0:
 yield n
 n -= 1

 # 创建生成器对象
 generator = countdown(5)

 # 使用 for 循环迭代生成器/也可以使用next()方法
 for value in generator:
 print(value) # 输出:5 4 3 2 1

装饰器

装饰器本质上是一个函数，它接收一个函数作为参数并返回一个新的函数。这个新函数是对原函数的一种包装或增强，可以在不改变原函数代码的前提下，增加额外的功能。

Python 还提供了一些内置的装饰器，比如 @staticmethod 和 @classmethod，用于定义静态方法和类方法。

工作流程

装饰器的工作流程可以分为以下几个步骤：

定义装饰器：首先定义一个装饰器函数，该函数接收一个函数作为参数。
定义包装函数：在装饰器函数内部，定义一个包装函数（wrapper），这个包装函数会调用原函数，并可以在调用前后添加额外的逻辑。
返回包装函数：装饰器函数返回这个包装函数。
使用@语法：在需要被装饰的函数定义前使用@符号加上装饰器名称，这样使用被装饰函数时，Python解释器会自动将这个函数作为参数传递给装饰器，并将包装函数赋值给原函数名。

因此调用被装饰函数时，实际上是调用了包装函数。

装饰器语法格式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


 # 这是装饰器函数，参数 func 传入被装饰的函数
 def logger(func):
 def wrapper(*args, **kwargs): # 传入被装饰函数func的各参数
 print('我准备开始执行：{} 函数了:'.format(func.__name__))

 func(*args, **kwargs)# 真正执行被装饰函数的是这行。

 print('我执行完了。')
 return wrapper # 注意需要返回包装函数

 @logger
 def add(x, y): # 被装饰的函数，实际上是logger的参数func
 print('{} + {} = {}'.format(x, y, x+y))

 add(2, 3)

带参数的装饰器语法格式：需要两层嵌套

因为装饰器函数的参数只有func(被装饰函数)，所以无法直接传入参数，需要额外嵌套一层。

示例一：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


 def repeat(n): # 传入装饰器参数
 def decorator(func):
 def wrapper(*args, **kwargs): # 传入被装饰函数func的各参数
 for i in range(n):
 print('No.',i+1,end=' ')
 func(*args, **kwargs)
 return wrapper
 return decorator

 @repeat(3) # 装饰器名称应为最外层
 def greet(name):
 print(f"Hello, {name}!")

 greet("Alice")

示例二：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


 def say_hello(country): # 传入装饰器参数
 def deco(func):
 def wrapper(*args, **kwargs): # 传入被装饰函数func的各参数
 if country == "china":
 print("你好!")
 elif country == "america":
 print('hello.')
 else:
 return

 func(*args, **kwargs)# 真正执行被装饰函数的一行

 return wrapper # 注意需要返回包装函数
 return deco # 注意需要返回次层装饰器函数

 # 小明，中国人
 @say_hello("china")
 def xiaoming():
 pass
 # jack，美国人
 @say_hello("america")
 def jack():
 pass

 xiaoming()
 print("------------")
 jack()

异常处理

Python的异常处理机制非常灵活，可以处理多种类型的异常。

基本语法

try:
<可能发生异常的代码>
except <异常类型1>:
<异常处理1>
except (<异常类型2>, <异常类型3>,...):
<异常处理2>
# 可以用except:作为通配符处理所有异常
else: # 必须放在所有except语句之后
<没有异常发生时执行>
finally:
<无论异常是否发生都执行> # 若try/except/else产生的异常未被处理，将先执行finally语句再被抛出

raise语句

raise语句用于手动抛出异常，并通知调用者发生了什么异常。

语法格式：raise唯一的一个参数Exception，指定了要被抛出的异常。若不提供参数，则重新抛出当前异常而不进行处理。

raise [Exception [, args [, traceback]]]

示例：

1
2
3
4
5
6
7
8
9


 x=10
 try:
 if x>5:
 raise NameError('HiThere') # 抛出一个NameError异常。
 except NameError:
 print('An exception flew by!')
 raise # 不提供Exception参数，则重新抛出当前异常，程序中断于此。若删去该行，仍会执行下面语句输出y的值。
 y=6
 print(y)

用户自定义异常

用户自定义异常类需要继承自Exception类。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


 class MyError(Exception):
 def __init__(self, value): # 覆盖类Exception的__init__方法
 self.value = value
 def __str__(self):
 return repr(self.value)

 try:
 raise MyError(2*2)
 except MyError as e:
 print('My exception occurred, value:', e.value)

with语句进行预定义的清理

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行它的清理方法:

1
2
3


 with open("myfile.txt") as f:
 for line in f:
 print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

补充：with 语句的语法格式如下：

with expression [as variable]:
with-block

expression 是一个上下文管理器对象，它定义了该对象的上下文，with-block 是在该上下文中要执行的语句。

当执行到 with 语句时，会首先执行 expression，该表达式应该返回一个上下文管理器对象。然后，with 语句将该上下文管理器对象压入一个栈，并将该对象的变量（如果有）赋值给 variable（如果有）。

当执行完 with-block 后，会弹出该上下文管理器对象，并调用其清理方法。

面向对象

self参数

self表示类的实例（对象）自身，通过self参数将类的实例传入类的方法中，使得类的方法能够访问和操作所创建的各个实例的属性。

示例一：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 class MyClass:
 def __init__(self, value):
 self.value = value

 def display_value(self):
 print(self.value)

 # 创建一个类的实例
 obj = MyClass(42) # self传入obj实例
 obj2 = MyClass(25) # self传入obj2实例
 # 调用实例的方法
 obj.display_value() # 输出 42
 obj2.display_value() # 输出 25

示例二：查看self实例位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


 class Desc:
 def __get__(self, ins, cls):
 print(self, ins, cls) # self参数为Desc类的实例，ins参数为Test类的实例，cls参数为Test类本身。
 class Test:
 x = Desc()
 def prt(self):
 print('self in Test: %s' % self)

 t0 = Test()
 t1 = Test()

 t0.prt()
 t1.prt()
 t0.x
 t1.x
 # 输出：
 # self in Test: <__main__.Test object at 0x000001>
 # self in Test: <__main__.Test object at 0x000002>
 # <__main__.Desc object at 0x000003> <__main__.Test object at 0x000001> <class '__main__.Test'>
 # <__main__.Desc object at 0x000003> <__main__.Test object at 0x000002> <class '__main__.Test'>
 # 说明：
 # 1. 实例化Test类时，t0和t1传入的self参数分别对应Test类的两个实例。
 # 2. Test类中的x = Desc()语句与self参数无关，因此不论是t0.x还是t1.x或Test.x，x都指向同一个Desc类的实例，即x是类Test的类属性。

类的继承

class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>

子类会继承父类的属性和方法，并可以对其进行覆写，也可以添加新的属性和方法。

Python支持多继承(并行继承、多重继承都可以)，一个类可以从多个父类继承方法和属性。当调用父类方法，且几个父类中有相同的方法名时，python将按从左到右的顺序调用父类中的方法。父类可以从别的文件import。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


 class people:
 # 定义构造方法
 def __init__(self, n, a):
 self.name = n
 self.age = a
 def speak(self):
 print("父类%s 说: 我 %d 岁。" % (self.name, self.age))

 # 单继承示例
 class student(people):
 grade = ''
 def __init__(self, n, a, g):
 # 调用父类的构函
 people.__init__(self, n, a)
 self.grade = g
 # 覆写父类的方法
 def speak(self):
 print("子类%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))

 s0 = people('s0',18)
 s1 = student('s1',10,3)
 s0.speak()
 s1.speak()
 # 输出：父类s0 说: 我 18 岁。 子类s1 说: 我 10 岁了，我在读 3 年级

类的方法种类

静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。

普通方法: 默认有个self参数，且只能被对象调用。

类方法: 默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。定义和调用时不需要传入实例对象。

@staticmethod
def func0():
print('静态方法')
@classmethod
def func1(cls):
print('类方法')
print(cls)

类的专有方法：

__init__(self, args)：类的构造函数，在对象创建时调用。

类的私有方法：

def __private_method(self, args)：
<表达式> # 私有方法，只能在类的内部调用。

类的公有方法：

def public_method(self, args)：
<表达式> # 公有方法，可以在类的外部调用。

类的私有属性(封装)：

__private_attribute = value #私有属性，只能在类的内部访问。

这确保了外部代码不能随意修改类的内部状态。
若需要从外部读取或修改私有属性时，需要通过公有方法来实现。

类的公有属性：

public_attribute = value #公有属性，可以在类的外部访问。

正则表达式

基本函数

re.search(pattern, string, flags=0)：在字符串中搜索匹配项。
re.match(pattern, string, flags=0)：从字符串的开头匹配，只匹配开头。
re.findall(pattern, string, flags=0)：找到所有匹配的子串，并以列表形式返回。
或pattern.findall(string[, pos[, endpos]])，与findall()相同，可指定搜索区间。
re.sub(pattern, repl, string, count=0, flags=0)：替换匹配到的子串。
re.split(pattern, string[, maxsplit=0, flags=0])：根据正则表达式分割字符串。
re.compile(pattern[, flags])：编译正则表达式，以便重复使用。

参数解释：

pattern：正则表达式。
string：要匹配的字符串。
flags：可选参数，表示匹配模式，比如忽略大小写，多行匹配等。
repl：要替换的字符串，repl参数也可以是一个函数，用于 re.sub() 方法。
count：用于 re.sub() 方法，表示最多替换的次数。
maxsplit：用于 re.split() 方法，表示最多分割次数。

示例1：

1
2
3
4
5


 import re
 pattern = re.compile(r'([a-z]+) ([a-z]+) ([a-z]+)', re.I) # re.I 表示忽略大小写
 # 匹配三个单词的组合
 m = pattern.search('Hello World Wide Web')
 print(m.groups())

示例2：re.sub()方法，repl参数是一个函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


 import re

 # 将匹配的数字乘以 2
 def double(matched):
 valueout = int(matched.group('value0'))
 return str(valueout * 2)

 s = 'A23G4HFD567'
 print(re.sub('(?P<value0>\d+)', double, s))
 # (?P<name>...)：这是命名捕获组的语法。name 是指定的组名，... 是要捕获的正则表达式模式。
 # 此处即捕获由数字组成的字符串组value0，传递至double()函数

匹配规则

字符和分组

.：匹配除换行符外任意字符。
[]：匹配括号中的任意字符。如[abc]：匹配a、b、c中的任意一个字符。
[^]：匹配不在括号中的任意字符。如[^abc]：匹配除 a、b、c 以外的任意字符。
[a-z]：匹配指定范围内的字符。例如，[a-z] 匹配任意小写字母。
()：用于分组。例如，(abc)+ 匹配一个或多个连续的 abc。
|：表示或。例如，abc|def 匹配 abc 或 def。

量词

*：匹配前面的元素零次或多次。例如，a* 匹配 ""、a、aa、aaa 等。
+：匹配前面的元素一次或多次。例如，a+ 匹配 a、aa、aaa 等。
?：匹配前面的元素零次或一次。例如，a? 匹配 "" 或 a。
{n}：匹配前面的元素恰好 n 次。例如，a{3} 匹配 aaa。
{n,}：匹配前面的元素至少 n 次。例如，a{3,} 匹配 aaa、aaaa 等。
{n,m}：匹配前面的元素至少 n 次，但不超过 m 次。例如，a{2,3} 匹配 aa 或 aaa。

位置匹配

^：匹配字符串的开始。例如，^abc 匹配以 abc 开头的字符串。
$：匹配字符串的结束。例如，abc$ 匹配以 abc 结尾的字符串。
\b：匹配单词边界。例如，\bcat\b 匹配完整的单词 cat。
\B：匹配非单词边界。例如，\Bcat\B 匹配字符串 scatters 中的 cat。

特殊字符

\：转义字符，用于匹配特殊字符。如'\. '匹配点号，而不是匹配任意字符。
\d：匹配任意数字。相当于 [0-9]
\D：匹配任意非数字。相当于 [^0-9]
\w：匹配任意字母、数字、下划线。相当于 [a-zA-Z0-9_]
\W：匹配任意非字母、数字、下划线。相当于 [^a-zA-Z0-9_]
\s：匹配任意空白字符，包括空格、制表符、换行符。相当于[ \t\n\r\f\v]。
\S：匹配任意非空白字符。相当于 [^ \t\n\r\f\v]。
\n：匹配换行符。
\t：匹配制表符。
\r：匹配回车符。

零宽断言

(?=...)：正向肯定断言，要求后面必须能匹配某个模式。例如，a(?=b) 匹配 a，但要求 a 后面必须有 b。
(?!...)：正向否定断言，要求后面不能匹配某个模式。例如，a(?!b) 匹配 a，但要求 a 后面不能有 b。
(?<=...)：反向肯定断言，要求前面必须能匹配某个模式。例如，(?<=b)a 匹配 a，但要求 a 前面必须有 b。
(?<!...)：反向否定断言，要求前面不能匹配某个模式。例如，(?<!b)a 匹配 a，但要求 a 前面不能有 b。

常见表达式

匹配电子邮件：

[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+
# [a-zA-Z0-9_.+-]+：匹配至少一个字母、数字、下划线、点、加号或减号
# [a-zA-Z0-9-]+：匹配@后面至少一个字母、数字或减号
# [a-zA-Z0-9-.]+：匹配.后面至少一个字母、数字、减号或点

匹配手机号码：

(\+?\d{1,3})?[-.\s]?(\d{3})[-.\s]?(\d{4})[-.\s]?(\d{4})
# (\+?\d{1,3})?：加号可选，后跟一到三位数字。该非捕获组可选
# [-.\s]?：连字符、句点、空格可选
# (\d{3})：三位数字

匹配IP地址：

((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
# 匹配((0-255).)三次，再匹配(0-255)一次

匹配URL：

https?://[a-zA-Z0-9./?=&_-]+
# s?：匹配s可选，即http或https
# (?:www\.)是非捕获组，只用于分组而不捕获，配合其后的问号，(?:www\.)?表示www.可选。
# [a-zA-Z0-9./?=&_-]+匹配方括号中任意字符一次或多次

示例：

1
2
3
4
5
6
7
8
9


 import re

 pattern_mail=re.compile('[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+')
 pattern_num=re.compile('(\+?\d{1,3})?[-.\s]?(\d{3})[-.\s]?(\d{4})[-.\s]?(\d{4})')
 pattern_ip=re.compile('((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)')
 pattern_url= re.compile('https?://(?:www\.)?[a-zA-Z0-9./?=&_-]+')

 s = 'self表示类的实例（对象）自身，通过self参数ychuang317@163.com将类的实例传入+86-13706811848类的方法中，使得类的方法能255.255.255.0够访问和操作http://hych0317.github.io/hugoweb_auto所创建的各个实例的属性。'
 print(re.search(pattern_num, s).group(0))

Python Requests

python的requests模块可以用来发送HTTP请求，它可以自动处理cookie、认证、重定向、超时等问题。

get()方法

requests.get(url, params={key: value}, \
headers={key: value}, cookies={key: value}, \
auth=(), timeout=None, allow_redirects=True, \
proxies=None, hooks=None)

post()方法

requests.post(url, data={key: value}, \
json={key: value}, args)

data参数用于发送表单数据，json参数用于发送JSON数据。args为其他参数，比如 cookies、headers、verify等。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


 import requests

 # GET请求
 response = requests.get('https://www.google.com')
 print(response.status_code) # 输出状态码
 print(response.text) # 输出unicode响应内容
 print(response.content) # 输出响应内容
 print(response.json()) # 输出JSON格式响应内容

 # POST请求
 response = requests.post('https://httpbin.org/post', data={'key': 'value'})
 print(response.text) # 输出响应内容

 # 上传文件
 files = {'file': open('report.xls', 'rb')}
 response = requests.post('https://httpbin.org/post', files=files)
 print(response.text) # 输出响应内容

 # 自定义请求头
 headers = {'User-Agent': 'Mozilla/5.0'} # 设置请求头
 params = {'key1': 'value1', 'key2': 'value2'} # 设置查询参数
 data = {'username': 'example', 'password': '123456'} # 设置请求体
 response = requests.post('https://www.runoob.com', headers=headers, params=params, data=data) # 输出响应内容

 # 超时设置
 response = requests.get('https://www.google.com', timeout=5)
 print(response.text) # 输出响应内容

进阶用法

身份认证

身份认证是指客户端提供用户名和密码给服务器，服务器验证用户名和密码是否正确，并确认客户端的身份。

requests模块提供了四种身份认证方法：

Basic Auth：基本认证，用户名和密码以明文形式发送，容易被窃听。
Digest Auth：摘要认证，用户名和密码以加密形式发送，安全性高。
OAuth 1.0a：OAuth 1.0a 认证，用于第三方应用授权。
OAuth 2.0：OAuth 2.0 认证，用于第三方应用授权。

重定向

requests模块默认会自动处理重定向，如果服务器返回的响应状态码为3xx，客户端自动请求新的URL，进行重定向。

超时设置

超时设置是指如果服务器在指定时间内没有响应，则请求超时。 requests模块默认超时时间为10秒，可以通过timeout参数设置超时时间。

Python 网络编程

socket使主机间或者一台计算机上的进程间可以通讯。

用一个简单的示例展示服务器与客户端的通信过程中使用的套接字函数。

示例一：

服务器端： server.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


 import socket
 import time
 COD = 'utf-8'
 HOST = socket.gethostname()# 获取本地主机ip
 PORT = 21566 # 软件端口号
 BUFSIZ = 1024
 ADDR = (HOST, PORT)
 SIZE = 10
 tcpS = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建socket对象
 tcpS.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 加入socket配置，重用ip和端口
 tcpS.bind(ADDR) # 绑定ip和端口号到套接字
 tcpS.listen(SIZE) # 监听链接，设置最大链接数
 while True:
 print("服务器启动，监听客户端链接")
 conn, addr = tcpS.accept()# 建立客户端链接
 print("链接的客户端", addr)
 while True:
 try:
 data = conn.recv(BUFSIZ) # 读取已链接客户的发送的消息
 except Exception:
 print("断开的客户端", addr)
 break
 print("客户端发送的内容:",data.decode(COD))
 if not data:
 break
 msg = time.strftime("%Y-%m-%d %X") # 获取结构化事件戳
 msg1 = '已接收到[%s]的内容:%s' % (msg, data.decode(COD))
 conn.send(msg1.encode(COD)) # 发送消息给已链接客户端
 conn.close() # 关闭客户端链接
 tcpS.closel()

客户端： client.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


 import socket
 import time
 HOST = socket.gethostname()# 获取本地主机ip
 PORT = 21566 # 服务端端口号
 BUFSIZ = 1024
 ADDR = (HOST, PORT)
 tcpCliSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建socket对象
 tcpCliSock.connect(ADDR) # 连接服务器
 while True:
 data = input('>>').strip()
 if not data:
 break
 tcpCliSock.send(data.encode('utf-8')) # 发送消息
 data = tcpCliSock.recv(BUFSIZ) # 读取消息
 if not data:
 break
 print(data.decode('utf-8'))
 tcpCliSock.close() # 关闭客户端

示例二：

抄送、密送聊天室程序：

服务器端： server.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


 import socket
 import threading

 # 客户端地址 名称
 addr_name = {}
 # 所有客户端
 all_clients = []
 # 名称 客户端
 name_client = {}

 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 host = socket.gethostname()
 port = 9999
 server.bind((host, port))
 server.listen(5)
 lock = threading.Lock()
 print("开启聊天室")

 def handle_sock(sock, addr):
 while True:
 try:
 data = sock.recv(1024)
 msg = data.decode("utf-8")
 print("send msg")
 from_name = addr_name[str(addr)]
 if msg.startswith('@'):
 index = msg.index(' ')
 # 私聊人
 to_name = msg[1:index]
 # 接收者客户端
 to_sock = name_client[to_name]
 # 发送的消息
 to_msg = msg[index:]
 send_one(to_sock, addr, from_name + ":" + to_msg)
 else:
 # 群发消息
 send_all(all_clients, addr, from_name + ":" + msg)
 except ConnectionResetError:
 exit_name = addr_name[str(addr)]
 exit_client = name_client[exit_name]
 all_clients.remove(exit_client)
 msg = exit_name + " 退出了群聊"
 send_all(all_clients, addr, msg)
 break

 def send_all(socks, addr, msg):
 for sock in socks:
 sock.send(msg.encode("utf-8"))

 def send_one(sock, addr, msg):
 sock.send(msg.encode("utf-8"))

 while True:
 sock, addr = server.accept()
 name = sock.recv(1024).decode("utf-8")
 addr_name[str(addr)] = name
 name_client[name] = sock
 all_clients.append(sock)
 hello = name + "加入了聊天室"
 send_all(all_clients, addr, hello)
 client_thread = threading.Thread(target=handle_sock, args=(sock, addr))
 client_thread.start()

客户端： client.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


 import socket
 import threading

 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 host = socket.gethostname()
 port = 9999
 s.connect((host, port))
 name = "cc"
 s.send(name.encode("utf-8"))

 def receive_handle(sock, addr):
 while True:
 data = sock.recv(1024)
 print(data.decode("utf-8"))

 # 开启线程监听接收消息
 receive_thread = threading.Thread(target=receive_handle, args=(s, '1'))
 receive_thread.start()

 while True:
 re_data = input()
 s.send(re_data.encode("utf-8"))

网络编程常用模块：

Python官方 Socket Library and Modules

Python JSON

待补充

Python MySQL

待补充

Programming on NEVERMORE

Claude Certified Architect

Claude 101

getting better results

Java

语法基础

权限修饰符 （范围从小到大）

变量类型 (Variables)

内存管理简介

1. 成员变量 (Field)

2. 局部变量 (Local Variable)

3. final 变量的赋值时机

实例方法、静态方法 (Methods)

方法重载/重写

SOLID原则

数据类型

表达式类型转换

运算符

方法中可变参数

StringBuilder

流程控制语句

switch

注解

元注解

自定义注解

注解的解析

导第三方包

面向对象

构造器

this关键字

封装

隐藏

暴露

实体类

继承

继承的特点

子类构造器

final关键字

多态

反射

特殊类

单例类（单例设计模式）

枚举类enum

抽象类abstract–模板

接口interface–功能

规则

JDK8后新增三种实例方法

*接口与继承的注意事项

代码块

内部类

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类（子类对象）

函数式编程

Lambda表达式

方法引用

API

String

泛型

包装类

类型擦除

泛型类/接口/方法

泛型限定符extends

通配符

集合框架（容器）

Collection

遍历方法

并发修改异常

List

Set

HashSet

哈希表核心流程（JDK 8+）

经典考点：为什么重写 equals() 时必须重写 hashCode()？

LinkedHashSet

TreeSet

Map

Stream流

获取stream流

中间处理方法

权限修饰符（范围从小到大）

经典考点：为什么重写 `equals()` 时必须重写 `hashCode()`？