JavaSE学习日志#

示例#

1
int age = 25;
2
double price = 19.99;
3
char gender = 'M';
4
String name = "Tom";
5
boolean isActive = true;

也可以先声明后赋值：

1
int score;
2
score = 100;

变量名建议使用有意义的英文单词，遵循小驼峰命名法（如 studentName）。

基本用法#

1. 导入包：

1
import java.util.Scanner;

2. 创建Scanner对象：

1
Scanner sc = new Scanner(System.in);

3. 读取输入：

• 读取字符串：String str = sc.nextLine();
• 读取整数：int num = sc.nextInt();
• 读取浮点数：double d = sc.nextDouble();

示例代码#

1
import java.util.Scanner;
2

3
public class InputDemo {
4
    public static void main(String[] args) {
5
        Scanner sc = new Scanner(System.in);
6
        System.out.print("请输入姓名：");
7
        String name = sc.nextLine();
8
        System.out.print("请输入年龄：");
9
        int age = sc.nextInt();
10
        System.out.println("姓名：" + name + ", 年龄：" + age);
11
    }
12
}

提示：使用完Scanner后建议调用sc.close();关闭资源。

主要部分说明#

• src/main/java/：存放项目的主Java源代码。
• src/main/resources/：存放配置文件、图片等资源。
• src/test/java/：存放测试用的Java代码。
• src/test/resources/：存放测试相关的资源文件。
• pom.xml：Maven项目的依赖和构建配置文件。
• build.gradle：Gradle项目的依赖和构建配置文件。
• out/、target/、build/：编译或打包后生成的输出目录。

普通Java项目只有src和out，Maven/Gradle项目结构更规范，推荐使用。

项目、模块、类的概念与关系#

• 项目（Project）

  • 在IDEA中，项目是开发的整体工程，包含所有代码、资源、配置和依赖管理。一个项目可以包含一个或多个模块。

• 模块（Module）

  • 模块是项目中的功能单元，可以独立编译、运行和测试。每个模块有自己的源码、资源和依赖配置。大型项目通常会按功能或层次拆分为多个模块（如web、service、dao等）。

• 类（Class）

  • 类是Java程序的基本代码结构，用于描述对象的属性和行为。类文件（.java）位于模块的src目录下，是实现具体功能的最小单元。

1. 算术运算符#

• + ：加法，两数相加。例如：a + b
• - ：减法，两数相减。例如：a - b
• * ：乘法，两数相乘。例如：a * b
• / ：除法，两数相除（整除/浮点）。例如：a / b
• % ：取余，取模，余数。例如：a % b
• ++ ：自增，变量加1（前/后缀）。例如：a++ 或 ++a
• -- ：自减，变量减1（前/后缀）。例如：a— 或 —a

示例：

1
int a = 10, b = 3;
2
System.out.println(a + b); // 13
3
System.out.println(a - b); // 7
4
System.out.println(a * b); // 30
5
System.out.println(a / b); // 3
6
System.out.println(a % b); // 1
7
System.out.println(++a);   // 11
8
System.out.println(b--);   // 3（b变为2）

2. 赋值运算符#

• = ：赋值，将右侧值赋给左侧变量。例如：a = b
• += ：加后赋值，a = a + b。例如：a += b
• -= ：减后赋值，a = a - b。例如：a -= b
• *= ：乘后赋值，a = a * b。例如：a *= b
• /= ：除后赋值，a = a / b。例如：a /= b
• %= ：取余后赋值，a = a % b。例如：a %= b

示例：

1
int a = 5;
2
a += 3; // a = 8
3
a -= 2; // a = 6
4
a *= 4; // a = 24
5
a /= 6; // a = 4
6
a %= 3; // a = 1

3. 比较（关系）运算符#

• == ：等于，判断两值是否相等。例如：a == b
• != ：不等于，判断两值是否不等。例如：a != b
• > ：大于。例如：a > b
• < ：小于。例如：a < b
• >= ：大于等于。例如：a >= b
• <= ：小于等于。例如：a <= b

示例：

1
int a = 5, b = 8;
2
System.out.println(a == b); // false
3
System.out.println(a != b); // true
4
System.out.println(a > b);  // false
5
System.out.println(a < b);  // true
6
System.out.println(a >= 5); // true
7
System.out.println(b <= 8); // true

4. 逻辑运算符#

• && ：逻辑与，两个条件都为true时结果为true。例如：a && b
• || ：逻辑或，两个条件有一个为true时结果为true。例如：a || b
• ! ：逻辑非，取反。例如：!a

示例：

1
boolean x = true, y = false;
2
System.out.println(x && y); // false
3
System.out.println(x || y); // true
4
System.out.println(!x);     // false

5. 位运算符#

• & ：按位与。例如：a & b
• | ：按位或。例如：a | b
• ^ ：按位异或。例如：a ^ b
• ~ ：按位取反。例如：~a
• << ：左移。例如：a << n
• >> ：右移。例如：a >> n
• >>> ：无符号右移。例如：a >>> n

示例：

1
int a = 6, b = 3; // 6: 110, 3: 011
2
System.out.println(a & b);  // 2  (010)
3
System.out.println(a | b);  // 7  (111)
4
System.out.println(a ^ b);  // 5  (101)
5
System.out.println(~a);     // -7
6
System.out.println(a << 1); // 12
7
System.out.println(a >> 1); // 3
8
System.out.println(a >>> 1);// 3

6. 条件（三元）运算符#

• ?: ：条件运算符，格式为 条件 ? 值1 : 值2。例如：a > b ? x : y

示例：

1
int a = 10, b = 20;
2
int max = (a > b) ? a : b; // max = 20
3
System.out.println(max);

7. 字符串连接运算符#

• + ：字符串拼接，只要有一个操作数是字符串，+ 就会拼接。例如：“Hello” + name

示例：

1
String name = "Java";
2
System.out.println("Hello, " + name); // Hello, Java
3
System.out.println("结果：" + 1 + 2); // 结果：12
4
System.out.println(1 + 2 + "结果"); // 3结果

8. instanceof 运算符#

• instanceof ：类型判断，判断对象是否为某个类的实例。例如：obj instanceof String

示例：

1
Object obj = "abc";
2
System.out.println(obj instanceof String); // true
3
System.out.println(obj instanceof Integer); // false

如需详细举例或对某类运算符深入讲解，可随时补充！

1. 原码#

• 原码是最直接的二进制表示，最高位为符号位（0正1负），其余为数值部分。
• 例如：
  • +7 的原码：0000 0111
  • -7 的原码：1000 0111

2. 反码#

• 正数的反码与原码相同。
• 负数的反码：符号位不变，数值部分按位取反（0变1，1变0）。
• 例如：
  • +7 的反码：0000 0111
  • -7 的反码：1111 1000

3. 补码#

• 正数的补码与原码相同。
• 负数的补码：反码加1。
• 例如：
  • +7 的补码：0000 0111
  • -7 的补码：1111 1001

4. 转换规则总结#

• 正数：原码 = 反码 = 补码
• 负数：补码 = 反码 + 1
• 反码 = 补码 - 1

5. Java中的意义#

• Java中的int、byte等整数类型，底层存储和运算都采用补码。
• 补码的好处：加减法统一、便于硬件实现、只有一个零。
• 位运算、溢出、负数右移等现象都与补码密切相关。

6. 示例#

1
int a = 7;      // 二进制：0000 0111
2
int b = -7;     // 二进制（补码）：1111 1001
3
System.out.println(Integer.toBinaryString(a)); // 111
4
System.out.println(Integer.toBinaryString(b)); // 11111111111111111111111111111001

理解补码机制有助于深入掌握Java底层运算和调试技巧。

10.1 顺序结构#

• 程序从上到下依次执行每一条语句，中间没有任何判断和跳转。
• 是最简单、最常见的结构。

示例：

1
int a = 10;
2
int b = 20;
3
int sum = a + b;
4
System.out.println("和为：" + sum);

10.2 分支结构（选择结构）#

• 根据条件判断，决定执行哪一部分代码。
• 常用的分支语句有：if、if-else、if-else if-else、switch。

if语句示例：

1
int score = 85;
2
if (score >= 60) {
3
    System.out.println("及格");
4
} else {
5
    System.out.println("不及格");
6
}

switch语句示例：

1
int day = 3;
2
switch (day) {
3
    case 1:
4
        System.out.println("星期一");
5
        break;
6
    case 2:
7
        System.out.println("星期二");
8
        break;
9
    case 3:
10
        System.out.println("星期三");
11
        // break;
12
    default:
13
        System.out.println("其他");
14
}

case穿透（fall through）说明：

• 如果某个case分支没有写break，程序会继续执行后续case或default中的代码，直到遇到break或switch结束。
• 这称为”case穿透”或”fall through”。

穿透示例：

1
int num = 2;
2
switch (num) {
3
    case 1:
4
        System.out.println("A");
5
    case 2:
6
        System.out.println("B");
7
    case 3:
8
        System.out.println("C");
9
    default:
10
        System.out.println("D");
11
}
12
// 输出：B
13
//      C
14
//      D

建议每个case后都加break，除非有意为之。

case -> 新写法（Java 14+）：

• 从Java 14开始，switch语句支持”case ->“箭头写法，简化代码且不允许穿透。
• 每个case只能执行对应的代码块，自动break，无需手动添加。

示例：

1
int day = 2;
2
switch (day) {
3
    case 1 -> System.out.println("星期一");
4
    case 2 -> System.out.println("星期二");
5
    case 3, 4, 5 -> System.out.println("工作日");
6
    default -> System.out.println("周末或非法");
7
}

• 也可以用于赋值：

1
String result = switch (day) {
2
    case 1 -> "星期一";
3
    case 2 -> "星期二";
4
    default -> "其他";
5
};
6
System.out.println(result);

箭头写法更简洁、安全，推荐在支持的JDK版本中使用。

10.3 循环结构#

• 根据条件反复执行某段代码。
• 常用的循环语句有：for、while、do-while。

for循环示例：

1
for (int i = 1; i <= 5; i++) {
2
    System.out.println("第" + i + "次循环");
3
}

for循环运用场景：

• 适用于已知循环次数的场景，如遍历数组、批量处理、计数循环等。
• 例如：遍历数组、打印1~100、批量初始化对象等。

while循环示例：

1
int i = 1;
2
while (i <= 5) {
3
    System.out.println("第" + i + "次循环");
4
    i++;
5
}

while循环运用场景：

• 适用于循环次数不确定、依赖条件判断的场景，如用户输入、等待某个条件达成、读取文件等。
• 例如：用户输入密码直到正确、读取文件直到结尾、网络连接重试等。

总结：for循环更适合计数型、范围型循环，while循环更适合条件型、事件驱动型循环。合理选择可提升代码可读性和健壮性。

do-while循环示例：

1
int i = 1;
2
do {
3
    System.out.println("第" + i + "次循环");
4
    i++;
5
} while (i <= 5);

顺序、分支、循环结构是所有程序的基础，合理组合可实现各种复杂逻辑。

基本用法#

1. 导入包：

1
import java.util.Random;

2. 创建Random对象：

1
Random rand = new Random();

常用方法#

• nextInt()：生成一个int范围内的随机整数。
• nextInt(n)：生成[0, n)范围内的随机整数。
• nextDouble()：生成[0.0, 1.0)范围内的随机小数。
• nextBoolean()：生成一个随机布尔值。
• nextLong()：生成一个随机long值。

示例代码#

1
import java.util.Random;
2

3
public class RandomDemo {
4
    public static void main(String[] args) {
5
        Random rand = new Random();
6
        int num = rand.nextInt(100); // 0~99的随机整数
7
        double d = rand.nextDouble(); // 0.0~1.0的随机小数
8
        boolean b = rand.nextBoolean(); // 随机布尔值
9
        System.out.println("随机整数：" + num);
10
        System.out.println("随机小数：" + d);
11
        System.out.println("随机布尔：" + b);
12
    }
13
}

Random生成的随机数是伪随机数，种子相同则序列相同。Java 1.7+还可用ThreadLocalRandom和SecureRandom。

1. 设计思想#

• next强调”顺序获取”，通常用于遍历、生成、读取等需要依次处理数据的场景。
• 以nextXxx()命名的方法，往往每调用一次就返回序列中的下一个元素或值。
• 这种命名方式让API的用途一目了然，易于理解和记忆。

2. 常见场景#

• 迭代器（Iterator）：
  • hasNext()判断是否还有下一个元素，next()获取下一个元素。
  • 典型用法：

    1
    Iterator<String> it = list.iterator();
    2
    while (it.hasNext()) {
    3
        String s = it.next();
    4
        // 处理s
    5
    }
    

• 输入读取（Scanner）：
  • next()读取下一个以空白分隔的字符串。
  • nextInt()、nextDouble()等读取下一个指定类型的输入。
  • 典型用法：

    1
    Scanner sc = new Scanner(System.in);
    2
    int num = sc.nextInt();
    3
    String word = sc.next();
    

• 随机数生成（Random）：
  • nextInt()、nextDouble()等每次生成一个新的随机值。
• 枚举、流、生成器等：
  • 只要是”顺序获取”或”生成下一个”，都常用next命名。

3. 与hasNext的配合#

• 在迭代器、流等场景，通常有hasNext()方法判断是否还有下一个元素，配合next()安全遍历。
• 这样可以避免越界异常（如NoSuchElementException）。

4. 易混淆点#

• next()和nextLine()：Scanner的next()读取一个单词，nextLine()读取一整行。
• next()通常不做类型转换，nextInt()等会尝试将输入转换为指定类型。

5. 实际开发建议#

• 使用nextXxx()方法时，建议先用hasNextXxx()判断是否有下一个元素或输入，避免异常。
• 理解”next”语义有助于快速掌握Java集合、输入、生成器等API的用法。

总结：以next开头的方法体现了Java对顺序处理、流式操作的高度抽象，是高效、可读代码的重要基础。

13.1 数组的概念#

• 数组是存储同一类型数据的有序集合，长度固定。
• 每个元素通过下标（索引）访问，下标从0开始。

13.2 数组的声明与初始化#

• 声明数组：

  1
  int[] arr;
  2
  String[] names;
  

• 分配空间并初始化：

  1
  arr = new int[5]; // 长度为5，默认值为0
  2
  String[] cities = new String[3]; // 长度为3，默认值为null
  

• 声明+初始化（静态初始化）：

  1
  int[] nums = {1, 2, 3, 4, 5};
  2
  String[] colors = {"red", "green", "blue"};
  

13.3 访问和修改数组元素#

1
int[] arr = {10, 20, 30};
2
System.out.println(arr[0]); // 10
3
arr[1] = 99;
4
System.out.println(arr[1]); // 99

13.4 数组的遍历#

• for循环遍历：

  1
  for (int i = 0; i < arr.length; i++) {
  2
      System.out.println(arr[i]);
  3
  }
  

• 增强for循环（for-each）：

  1
  for (int num : arr) {
  2
      System.out.println(num);
  3
  }
  

13.5 数组的常用属性和特性#

• length：数组长度属性，如arr.length。
• 数组一旦创建，长度不可变。
• 支持多维数组（如int[][] matrix = new int[3][4];）。
• 数组元素类型可以是基本类型或引用类型。

13.6 示例：求数组元素之和#

1
int[] nums = {1, 2, 3, 4, 5};
2
int sum = 0;
3
for (int n : nums) {
4
    sum += n;
5
}
6
System.out.println("总和：" + sum);

13.7 直接输出数组与地址格式说明#

• 直接输出数组对象（如System.out.println(arr);）时，显示的不是数组内容，而是数组的类型和哈希码地址。
• 格式通常为：[类型标识@哈希码]，如：[I@6d06d69c
  • [I 表示int[]类型，@后为哈希码的十六进制。
  • 其他类型如String[]会显示为 [Ljava.lang.String;@xxxxxx

示例：

1
int[] arr = {1, 2, 3};
2
System.out.println(arr); // 输出：[I@6d06d69c（示例）

• 如果要输出数组内容，需用循环或工具类：
  • for循环/增强for循环遍历输出
  • 使用Arrays.toString(arr)

示例：

1
import java.util.Arrays;
2
int[] arr = {1, 2, 3};
3
System.out.println(Arrays.toString(arr)); // 输出：[1, 2, 3]

直接输出数组变量看到的是”地址信息”，不是数组元素本身。建议用Arrays.toString()等方法查看内容。

数组是Java中最基础的数据结构，后续可学习ArrayList等集合类实现更灵活的数据管理。

13.8 动态初始化时的默认值#

• 使用new关键字动态初始化数组时，数组中的每个元素都会被自动赋予默认值。
• 不同类型的数组默认值如下：
  • 整型（int、byte、short、long）：默认值为0
  • 浮点型（float、double）：默认值为0.0
  • 字符型（char）：默认值为’\u0000’（空字符）
  • 布尔型（boolean）：默认值为false
  • 引用类型（如String、对象）：默认值为null

示例：

1
int[] arr = new int[3];
2
System.out.println(Arrays.toString(arr)); // [0, 0, 0]
3

4
boolean[] flags = new boolean[2];
5
System.out.println(Arrays.toString(flags)); // [false, false]
6

7
String[] names = new String[2];
8
System.out.println(Arrays.toString(names)); // [null, null]

动态初始化时，数组元素的默认值由类型决定，无需手动赋值。

1. 方法区（Method Area）#

• 存储类的结构信息（如类的元数据、静态变量、常量、运行时常量池等）。
• 所有线程共享。

2. 堆（Heap）#

• 存储所有对象实例和数组。
• 由垃圾回收器统一管理。
• 所有线程共享。

3. 虚拟机栈（Stack）#

• 每个线程独有，存储方法调用时的局部变量、操作数栈、方法返回地址等。
• 局部变量包括基本类型、对象引用等。

4. 本地方法栈（Native Method Stack）#

• 为JVM调用本地（Native）方法服务。
• 每个线程独有。

5. 程序计数器（Program Counter Register）#

• 记录当前线程所执行字节码的行号指示器。
• 每个线程独有。

6. 内存分布结构图#

1
graph TD
2
  A[方法区 Method Area]
3
  B[堆 Heap]
4
  C[虚拟机栈 Stack]
5
  D[本地方法栈 Native Method Stack]
6
  E[程序计数器 PC Register]
7
  subgraph 线程1
8
    C
9
    D
10
    E
11
  end
12
  subgraph 线程2
13
    C2[虚拟机栈 Stack]
14
    D2[本地方法栈 Native Method Stack]
15
    E2[程序计数器 PC Register]
16
  end
17
  A -->|共享| B
18
  B -->|共享| C
19
  B -->|共享| D
20
  B -->|共享| E

7. 总结#

• 堆和方法区是所有线程共享的，栈、本地方法栈、程序计数器是线程私有的。
• 对象实例存储在堆，局部变量存储在栈。
• 合理理解内存分布有助于掌握对象生命周期、垃圾回收、线程安全等核心知识。

1. 方法的概念#

• 方法（Method）是完成特定功能的代码块，可以重复调用。
• 方法有名称、参数列表、返回值类型和方法体。
• 方法有助于代码复用、结构清晰和模块化。

2. 方法的定义格式#

1
修饰符 返回值类型 方法名(参数列表) {
2
    // 方法体
3
    // 可选：return 返回值;
4
}

• 常见修饰符：public、private、static、final、abstract等。
• 返回值类型：可以是基本类型、引用类型或void（无返回值）。
• 参数列表：0个或多个参数，类型+名称，用逗号分隔。

3. 方法的调用#

• 语法：方法名(实参列表);
• 静态方法可用类名调用：ClassName.methodName();
• 非静态方法需通过对象调用：obj.methodName();

示例：

1
public static int add(int a, int b) {
2
    return a + b;
3
}
4

5
public void sayHello(String name) {
6
    System.out.println("Hello, " + name);
7
}
8

9
// 调用
10
int sum = add(3, 5); // 静态方法
11
MyClass obj = new MyClass();
12
obj.sayHello("Tom"); // 实例方法

4. 方法的重载（Overload）#

• 同一个类中，方法名相同但参数列表不同（类型、个数、顺序不同），构成方法重载。
• 返回值类型不同不能单独构成重载。

示例：

1
public int max(int a, int b) {
2
    return a > b ? a : b;
3
}
4
public double max(double a, double b) {
5
    return a > b ? a : b;
6
}

5. 常见修饰符说明#

• public：公有方法，任何类都可访问。
• private：私有方法，仅本类可访问。
• static：静态方法，属于类本身。
• final：最终方法，不能被子类重写。
• abstract：抽象方法，无方法体，需子类实现。

6. void方法和return#

• void方法无返回值，可用return;提前结束方法。
• 有返回值方法必须用return返回对应类型的值。

7. 参数传递#

• 基本类型参数：值传递，方法内修改不影响外部变量。
• 引用类型参数：传递对象引用，方法内可修改对象内容。

8. 方法参数传递机制详解#

Java方法参数传递采用”值传递”机制，但根据参数类型（基本类型或引用类型），在堆和栈上的表现和影响不同。

1
public static void change(int x) {
2
    x = 100;
3
}
4
int a = 10;
5
change(a);
6
System.out.println(a); // 输出10，a未被改变

1
public static void modify(int[] arr) {
2
    arr[0] = 99;
3
}
4
int[] nums = {1, 2, 3};
5
modify(nums);
6
System.out.println(nums[0]); // 输出99，原数组被修改

1
public static void reassign(int[] arr) {
2
    arr = new int[]{7, 8, 9};
3
}
4
int[] nums = {1, 2, 3};
5
reassign(nums);
6
System.out.println(nums[0]); // 仍输出1，原数组未被替换

1. 二维数组的声明#

• 语法：

  1
  int[][] matrix;
  2
  String[][] table;
  

2. 二维数组的创建#

• 指定行和列：

  1
  int[][] arr = new int[3][4]; // 3行4列，所有元素默认值为0
  

• 只指定行，列可后续单独分配（不规则数组）：

  1
  int[][] arr = new int[3][];
  2
  arr[0] = new int[2]; // 第一行2列
  3
  arr[1] = new int[4]; // 第二行4列
  4
  arr[2] = new int[3]; // 第三行3列
  

3. 二维数组的静态初始化#

• 声明+赋值：

  1
  int[][] nums = {
  2
      {1, 2, 3},
  3
      {4, 5, 6},
  4
      {7, 8, 9}
  5
  };
  

4. 访问和遍历二维数组#

• 访问元素：arr[i][j] 表示第i行第j列元素。
• 遍历方式：

  1
  for (int i = 0; i < arr.length; i++) {
  2
      for (int j = 0; j < arr[i].length; j++) {
  3
          System.out.print(arr[i][j] + " ");
  4
      }
  5
      System.out.println();
  6
  }
  

• 增强for循环：

  1
  for (int[] row : arr) {
  2
      for (int val : row) {
  3
          System.out.print(val + " ");
  4
      }
  5
      System.out.println();
  6
  }
  

5. 特点说明#

• Java二维数组本质上是”数组的数组”，每一行可以有不同的列数（不规则数组）。
• 默认值规则与一维数组一致。

二维数组常用于矩阵、表格、棋盘等场景，是多维数据结构的基础。

1. 类与对象#

• 类（Class）：对象的模板或蓝图，定义属性和行为。
• 对象（Object）：类的实例，实际存在的实体。

示例：

1
class Person {
2
    String name;
3
    int age;
4
    void sayHello() {
5
        System.out.println("Hello, my name is " + name);
6
    }
7
}
8
Person p = new Person();
9
p.name = "Tom";
10
p.age = 20;
11
p.sayHello();

2. 封装（Encapsulation）#

• 将属性和方法封装在类内部，属性私有（private），通过公有方法（getter/setter）访问。
• 提高安全性和可维护性。

示例：

1
class Student {
2
    private int score;
3
    public int getScore() { return score; }
4
    public void setScore(int s) { score = s; }
5
}

3. 继承（Inheritance）#

• 子类通过extends继承父类，获得父类的属性和方法。
• 支持单继承。

示例：

1
class Animal {
2
    void eat() { System.out.println("吃东西"); }
3
}
4
class Dog extends Animal {
5
    void bark() { System.out.println("汪汪"); }
6
}
7
Dog d = new Dog();
8
d.eat();
9
d.bark();

4. 多态（Polymorphism）#

• 父类引用指向子类对象，调用方法时表现出不同形态。
• 体现为方法重写（Override）和接口实现。

示例：

1
Animal a = new Dog();
2
a.eat(); // 调用Dog的eat方法（如果重写）

5. 构造方法（Constructor）#

• 与类名相同，无返回值，用于对象初始化。
• 可重载多个构造方法。

示例：

1
class Person {
2
    String name;
3
    Person() { name = "无名"; }
4
    Person(String n) { name = n; }
5
}

6. this与super关键字#

• this：当前对象的引用，区分成员变量和局部变量，调用本类方法/构造器。
• super：父类对象的引用，调用父类属性、方法、构造器。

示例：

1
class Parent {
2
    int x = 1;
3
}
4
class Child extends Parent {
5
    int x = 2;
6
    void print() {
7
        System.out.println(this.x); // 2
8
        System.out.println(super.x); // 1
9
    }
10
}

7. 方法重写（Override）与重载（Overload）#

• 重写：子类重写父类方法，方法名、参数、返回值完全一致，需加@Override注解。
• 重载：同类中方法名相同，参数列表不同。

8. final与abstract#

• final类不能被继承，final方法不能被重写，final变量为常量。
• abstract类不能实例化，抽象方法无方法体，子类必须实现。

9. 接口（Interface）#

• 用interface定义，所有方法默认public abstract，属性默认public static final。
• 类用implements实现接口，可多实现。

示例：

1
interface USB {
2
    void connect();
3
}
4
class Mouse implements USB {
5
    public void connect() { System.out.println("鼠标连接"); }
6
}

10. 静态成员（static）#

• static变量/方法属于类本身，不依赖对象。
• 可用类名直接访问。

11. 内部类#

• 类中定义的类，分为成员内部类、静态内部类、局部内部类、匿名内部类。

12. 对象的创建与内存分布#

• new对象时，属性分配在堆，引用变量在栈。
• 构造方法初始化对象。

13. 常见OOP原则#

• 单一职责、开闭原则、里氏替换、依赖倒置、接口隔离、迪米特法则等。

面向对象是Java的核心思想，掌握OOP有助于开发高内聚、低耦合、易维护的系统。

面向对象的内存分布说明#

• 栈内存（Stack）：用于存储方法调用时的局部变量，包括对象引用变量（如Person p）。每个线程有自己的栈空间。
• 堆内存（Heap）：用于存储所有new出来的对象实例和数组。对象的实际内容（属性等）都在堆中，所有线程共享。
• 方法区（Method Area）：用于存储类的结构信息（如类的元数据、静态变量、常量、方法代码等），所有线程共享。

对象引用与内存分布关系：

• 当你写Person p = new Person();时：
  • p变量在栈内存，保存的是堆中Person对象的地址（引用）。
  • 堆内存中存放Person对象的实际内容。
  • 类的结构信息（如方法、静态变量）在方法区。
• 多个引用变量可以在栈中分别保存同一个对象的地址，实现对象共享。
• 对象的生命周期由是否有引用指向它决定，无引用时会被垃圾回收。

这种分布方式有助于实现对象的共享、封装和高效管理，是Java面向对象内存模型的基础。

Java对象与引用的内存分布详解#

1. 基本数据类型（Primitive Types）#

• Java共有8种基本数据类型，直接存储具体的数值，分配在栈内存。
• 包括：
  • 整型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）
  • 浮点型：float（4字节）、double（8字节）
  • 字符型：char（2字节，存储单个字符）
  • 布尔型：boolean（1字节，true/false）

示例：

1
int a = 10;
2
double d = 3.14;
3
char c = 'A';
4
boolean flag = true;

• 基本类型变量直接存储值，赋值和传参时是值的拷贝。

2. 引用数据类型（Reference Types）#

• 包括：类（对象）、数组、接口、枚举、String等。
• 变量存储的是对象在堆内存的地址（引用），实际内容在堆内存。

示例：

1
String s = "Hello";
2
int[] arr = {1, 2, 3};
3
Person p = new Person();

• 引用类型变量存储在栈，指向堆中的实际对象。
• 赋值和传参时是引用的拷贝（地址），可通过引用修改堆中对象内容。

3. 区别总结#

• 基本类型：存储值本身，内存分配在栈，速度快，不能为null。
• 引用类型：存储地址，实际内容在堆，变量可为null，功能更丰富。
• 基本类型有对应的包装类（如int对应Integer），用于集合等只能存引用类型的场景。

理解两者区别有助于掌握Java的内存管理、参数传递、对象操作等核心机制。

1. this的本质#

• this是Java中每个实例方法内部的一个隐式引用，指向当前调用该方法的对象本身。
• 本质上，this是一个指向当前对象的引用变量，存储在栈帧的局部变量表中。

2. 内存表现#

• 当调用实例方法时，JVM会自动将当前对象的引用（即this）作为第一个参数传递给方法。
• 在方法执行期间，this指向堆内存中当前对象实例。
• 每个对象的方法调用时，this的值不同，始终指向当前操作的对象。

3. 作用和常见用法#

• 区分成员变量和局部变量（如构造方法参数与成员变量同名时）。
• 在对象方法内部引用当前对象。
• 在构造方法中调用其他构造方法（this(…)）。
• 在链式调用中返回当前对象（如return this;）。

示例：

1
class Person {
2
    String name;
3
    Person(String name) {
4
        this.name = name; // 区分成员变量和参数
5
    }
6
    void printName() {
7
        System.out.println(this.name); // this可省略
8
    }
9
    Person setName(String name) {
10
        this.name = name;
11
        return this; // 支持链式调用
12
    }
13
}

4. 注意事项#

• 静态方法中不能使用this，因为没有具体对象。
• this只能在实例方法和构造方法中使用。

理解this的内存原理有助于掌握对象方法的调用机制、链式编程和构造方法重载等高级用法。

1. 概念#

• 对象数组是存放对象引用的数组，每个元素都是某个类的对象引用。
• 本质上是”引用类型数组”，数组本身在堆，元素为对象引用。

2. 声明与创建#

• 声明：

  1
  Person[] people;
  

• 创建数组空间：

  1
  people = new Person[3]; // 创建长度为3的对象数组，每个元素默认值为null
  

• 创建并初始化对象：

  1
  people[0] = new Person("Tom");
  2
  people[1] = new Person("Jerry");
  3
  people[2] = new Person("Alice");
  

• 声明+静态初始化：

  1
  Person[] group = {
  2
      new Person("Tom"),
  3
      new Person("Jerry"),
  4
      new Person("Alice")
  5
  };
  

3. 遍历对象数组#

• for循环或增强for循环：

  1
  for (int i = 0; i < people.length; i++) {
  2
      if (people[i] != null) {
  3
          people[i].sayHello();
  4
      }
  5
  }
  6
  // 或
  7
  for (Person p : group) {
  8
      p.sayHello();
  9
  }
  

4. 内存分布说明#

• 对象数组本身在堆内存，数组元素为对象引用（地址）。
• 每个元素指向堆中的实际对象实例。
• 未初始化的元素为null。

5. 注意事项#

• 创建对象数组时，只分配了引用空间，需逐个new对象。
• 访问未初始化的元素会抛出NullPointerException。

对象数组常用于批量管理同类对象，如学生列表、商品清单等，是面向对象编程的重要应用。

1. 字符串的创建#

• 直接赋值：

  1
  String s1 = "Hello";
  

• 使用构造方法：

  1
  String s2 = new String("World");
  

2. 字符串的不可变性#

• String对象一旦创建，内容不可更改，所有修改操作都会生成新字符串。
• 适合做常量、作为Map的key等。

3. 常用API方法#

• length()：获取字符串长度
• charAt(int index)：获取指定位置字符
• equals(String other)：内容比较
• equalsIgnoreCase(String other)：忽略大小写比较
• compareTo(String other)：字典序比较
• isEmpty()：是否为空串
• toUpperCase()/toLowerCase()：转大/小写
• substring(int begin, int end)：截取子串
• indexOf(String str)：查找子串首次出现位置
• lastIndexOf(String str)：查找子串最后出现位置
• contains(String str)：是否包含子串
• replace(old, new)：替换内容
• split(String regex)：分割字符串
• trim()：去除首尾空白
• startsWith()/endsWith()：前缀/后缀判断
• getBytes()：转为字节数组
• toCharArray()：转为字符数组

4. 示例代码#

1
String str = "  Hello, Java!  ";
2
System.out.println(str.length()); // 15
3
System.out.println(str.trim()); // "Hello, Java!"
4
System.out.println(str.substring(2, 7)); // "Hello"
5
System.out.println(str.toUpperCase()); // "  HELLO, JAVA!  "
6
System.out.println(str.replace("Java", "World")); // "  Hello, World!  "
7
String[] arr = str.split(",");
8
System.out.println(arr[0]); // "  Hello"

5. 字符串拼接与效率#

• 使用+拼接字符串简单但效率低，建议多次拼接时用StringBuilder或StringBuffer。

6. String构造方法参数说明#

• String s = new String() 这句代码中的括号内可以写多种内容，取决于String类的构造方法重载。
• 常见构造方法有：
  • new String()：创建空字符串，等价于""
  • new String(String original)：根据已有字符串创建新字符串
  • new String(char[] value)：由字符数组创建字符串
  • new String(char[] value, int offset, int count)：由字符数组的部分内容创建字符串
  • new String(byte[] bytes)：由字节数组创建字符串（按平台默认编码）
  • new String(byte[] bytes, String charsetName)：由字节数组按指定编码创建字符串
  • new String(StringBuffer buffer)、new String(StringBuilder builder)：由可变字符串对象创建

示例：

1
String s1 = new String(); // 空字符串
2
String s2 = new String("abc");
3
char[] arr = {'H', 'e', 'l', 'l', 'o'};
4
String s3 = new String(arr); // "Hello"
5
String s4 = new String(arr, 1, 3); // "ell"
6
byte[] bytes = {65, 66, 67};
7
String s5 = new String(bytes); // "ABC"（默认编码）
8
String s6 = new String(bytes, "UTF-8"); // "ABC"
9
StringBuffer sb = new StringBuffer("hi");
10
String s7 = new String(sb);

• 通过不同构造方法，可以实现字符串与字符数组、字节数组、StringBuffer/StringBuilder等类型的灵活转换。

熟练掌握String API是Java开发的基础，能高效处理文本数据。

1. 概念与区别#

• StringBuilder 和 StringBuffer 都是可变字符串类，适合频繁修改字符串内容的场景。
• 区别：
  • StringBuilder：线程不安全，效率高，JDK 1.5后推荐单线程场景使用。
  • StringBuffer：线程安全，效率略低，适合多线程环境。
• 二者都比String拼接效率高，避免产生大量无用字符串对象。

2. 常用API#

• append(xxx)：追加内容
• insert(offset, xxx)：插入内容
• delete(start, end)：删除指定区间内容
• replace(start, end, str)：替换内容
• reverse()：反转字符串
• toString()：转为不可变String
• setCharAt(index, ch)：修改指定位置字符
• length()：获取长度

3. 示例代码#

1
StringBuilder sb = new StringBuilder("Hello");
2
sb.append(", Java!");
3
sb.insert(5, " World");
4
sb.delete(0, 6);
5
sb.replace(0, 4, "Hi");
6
sb.reverse();
7
System.out.println(sb.toString());
8

9
StringBuffer sbf = new StringBuffer();
10
sbf.append("abc").append(123);
11
System.out.println(sbf);

4. 适用场景#

• StringBuilder：推荐用于单线程环境下的大量字符串拼接、修改，如循环拼接、临时字符串处理等。
• StringBuffer：用于多线程环境下对同一字符串变量的并发修改。

总结：字符串频繁拼接、修改时优先考虑StringBuilder，需线程安全时用StringBuffer，普通不可变字符串用String。

StringBuilder和StringBuffer的区别#

1. 线程安全性

   • StringBuffer：线程安全。其大多数方法都用synchronized修饰，多线程环境下可安全操作同一个StringBuffer对象。
   • StringBuilder：线程不安全。没有同步机制，适合单线程环境，效率更高。

2. 执行效率

   • StringBuffer：由于线程安全，方法有同步开销，效率略低。
   • StringBuilder：无同步开销，执行速度更快，推荐在单线程下使用。

3. JDK版本

   • StringBuffer：JDK 1.0就有。
   • StringBuilder：JDK 1.5引入，作为StringBuffer的高效替代。

4. 用法和API

   • 二者API几乎完全一致，如append()、insert()、delete()、reverse()等。
   • 用法相同，唯一差别在于线程安全性和效率。

5. 适用场景

   • StringBuffer：多线程环境下字符串频繁修改。
   • StringBuilder：单线程环境下字符串频繁修改（如循环拼接、临时字符串处理等）。

示例对比：

1
StringBuffer sbf = new StringBuffer("abc");
2
sbf.append(123);
3

4
StringBuilder sbd = new StringBuilder("abc");
5
sbd.append(123);

总结：

• 需要线程安全时用StringBuffer，否则优先用StringBuilder。
• 普通不可变字符串用String，频繁拼接/修改用Builder或Buffer。

1. 概念#

• 链式编程（Fluent Interface/Method Chaining）是指通过连续调用对象的方法，每个方法返回当前对象自身（this），从而实现多个操作的连贯书写。
• 常见于构建器模式、StringBuilder、集合操作等。

2. 实现原理#

• 方法返回this（当前对象），使得可以继续调用该对象的其他方法。
• 适用于需要对同一对象连续操作的场景。

示例：

1
class Person {
2
    private String name;
3
    private int age;
4
    public Person setName(String name) {
5
        this.name = name;
6
        return this;
7
    }
8
    public Person setAge(int age) {
9
        this.age = age;
10
        return this;
11
    }
12
    public void show() {
13
        System.out.println(name + ", " + age);
14
    }
15
}
16

17
Person p = new Person().setName("Tom").setAge(20);
18
p.show();

3. 常见场景#

• StringBuilder/StringBuffer的append、insert等方法：

  1
  StringBuilder sb = new StringBuilder().append("Hello").append(", ").append("World");
  

• Java集合的add、remove等方法（部分实现支持）：

  1
  List<String> list = new ArrayList<>();
  2
  list.add("a").add("b"); // 需返回this
  

• 构建器模式（Builder Pattern）：用于复杂对象的灵活构建。

4. 优缺点#

• 优点：代码简洁、可读性强、便于批量设置属性。
• 缺点：不适合所有场景，方法需返回this，易导致调试困难。

链式编程是现代Java开发中常用的风格，尤其适合配置、构建、批量操作等场景。

1. 概念#

• StringJoiner是Java 8引入的字符串连接工具类，位于java.util包。
• 用于高效拼接多个字符串，并可自定义分隔符、前缀和后缀。

2. 构造方法#

• StringJoiner(CharSequence delimiter)：指定分隔符。
• StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)：指定分隔符、前缀和后缀。

3. 常用API#

• add(String element)：添加元素。
• toString()：返回拼接后的字符串。
• setEmptyValue(String emptyValue)：设置无元素时的返回值。
• length()：当前拼接字符串的长度。

4. 示例代码#

1
import java.util.StringJoiner;
2

3
StringJoiner sj = new StringJoiner(", ");
4
sj.add("Java").add("Python").add("C++");
5
System.out.println(sj.toString()); // Java, Python, C++
6

7
StringJoiner sj2 = new StringJoiner(", ", "[", "]");
8
sj2.add("A").add("B");
9
System.out.println(sj2); // [A, B]
10

11
StringJoiner sj3 = new StringJoiner("-");
12
System.out.println(sj3.setEmptyValue("空").toString()); // 空

5. 适用场景#

• 拼接集合、数组等多个字符串，需自定义分隔符、前后缀时。
• 替代手动循环拼接，代码更简洁高效。

StringJoiner常与Stream API结合使用，也可用于String.join()等场景，是现代Java字符串拼接的推荐方式之一。

1. 不可变性#

• String对象一旦创建，内容不可更改（final修饰的char[]数组存储字符）。
• 修改字符串（如拼接、替换）会生成新的String对象，原对象不变。
• 不可变性带来线程安全、可缓存、可作为Map的key等优势。

2. 内存结构#

• String底层由一个final char[]数组存储字符内容（JDK 9+为byte[]，支持压缩存储）。
• String对象本身在堆内存，char[]数组也在堆内存。

3. 字符串常量池#

• Java为提高效率和节省内存，维护一个字符串常量池（String Pool）。
• 直接赋值的字符串字面量会被放入常量池，池中相同内容的字符串只存一份。
• new String(“abc”)会在堆中新建对象，不会自动放入常量池。
• 可用intern()方法将字符串加入常量池。

示例：

1
String s1 = "hello";
2
String s2 = "hello";
3
System.out.println(s1 == s2); // true，指向常量池同一对象
4
String s3 = new String("hello");
5
System.out.println(s1 == s3); // false，s3为新对象
6
System.out.println(s1 == s3.intern()); // true

4. 字符串比较#

• == 比较的是引用（地址），equals()比较的是内容。
• 推荐用equals()判断字符串内容是否相等。

5. 字符串拼接机制#

• 字符串拼接（+）在编译期会优化为StringBuilder.append()，但多次拼接建议手动用StringBuilder。
• 字符串常量拼接会在编译期合并，变量拼接则在运行时生成新对象。

示例：

1
String a = "he" + "llo"; // 编译期合并为"hello"
2
String b = "he";
3
String c = b + "llo"; // 运行时拼接
4
System.out.println(a == "hello"); // true
5
System.out.println(c == "hello"); // false

6. 性能影响#

• 频繁修改字符串建议用StringBuilder/StringBuffer，避免生成大量无用String对象。
• 字符串不可变性有利于安全和性能优化，但需注意拼接和创建方式。

理解String的底层原理有助于编写高效、健壮的Java代码，避免常见性能和内存问题。

7. 字符串拼接的底层原理#

• 编译期优化：

  • 对于字符串常量的拼接（如”a” + “b”），编译器会在编译阶段直接合并为一个常量（“ab”），不会生成多余对象。
  • 例如：

    1
    String s = "a" + "b" + "c"; // 编译后等价于 String s = "abc";
    

• 运行时机制：

  • 对于包含变量的拼接（如a + b），编译器会将其转换为StringBuilder的append()方法链式调用，最后toString()生成新字符串。
  • 例如：

    1
    String a = "hello";
    2
    String b = "world";
    3
    String s = a + b;
    4
    // 实际等价于：
    5
    // String s = new StringBuilder().append(a).append(b).toString();
    

• 多次拼接建议：

  • 在循环或大量拼接场景下，建议手动使用StringBuilder/StringBuffer，避免生成大量临时String对象，提升性能。
  • 例如：

    1
    StringBuilder sb = new StringBuilder();
    2
    for (int i = 0; i < 1000; i++) {
    3
        sb.append(i);
    4
    }
    5
    String result = sb.toString();
    

• 常量拼接与变量拼接的区别：

  • 常量拼接在编译期完成，结果在常量池。
  • 变量拼接在运行期完成，结果在堆内存。

• 性能影响：

  • 频繁使用+拼接字符串会导致性能下降，尤其是在循环中。
  • 推荐用StringBuilder进行高效拼接。

理解字符串拼接的底层原理有助于写出高效、可维护的Java代码，避免无谓的内存浪费和性能瓶颈。

8. 直接赋值字符串与变量拼接字符串的==比较#

• 直接赋值字符串（如String s1 = “abc”;）会被放入字符串常量池，池中相同内容的字符串只存一份。
• 变量拼接字符串（如String s2 = a + b;）即使内容相同，结果是运行时新创建的对象，存放在堆内存，不会自动进入常量池。
• 因此，内容相同但创建方式不同的字符串，用==比较时结果通常为false。
• == 比较的是引用（地址），不是内容。内容比较应使用equals()。

示例：

1
String s1 = "hello";
2
String s2 = "he" + "llo"; // 编译期常量拼接，等价于"hello"，与s1同一对象
3
System.out.println(s1 == s2); // true
4

5
String a = "he";
6
String b = "llo";
7
String s3 = a + b; // 运行时拼接，生成新对象
8
System.out.println(s1 == s3); // false
9
System.out.println(s1.equals(s3)); // true

重点总结：

• 直接赋值或常量拼接的字符串，内容相同==为true。
• 变量拼接的字符串，即使内容相同==为false。
• 判断字符串内容相等，必须用equals()方法。

1. 集合的概念#

• 集合（Collection）是存储、操作一组数据的容器，支持动态扩容、去重、排序等功能。
• Java集合框架（Collection Framework）提供了丰富的数据结构和算法，位于java.util包。
• 集合只能存引用类型（对象），基本类型需用包装类（如Integer、Double）。

2. 主要接口与体系结构#

• Collection接口：单值集合的根接口，子接口有List、Set、Queue等。
• List接口：有序、可重复元素，如ArrayList、LinkedList。
• Set接口：无序、不可重复元素，如HashSet、TreeSet。
• Map接口：键值对集合，如HashMap、TreeMap，不继承Collection。

1
Collection
2
  ├── List（有序、可重复）
3
  │     ├── ArrayList
4
  │     └── LinkedList
5
  └── Set（无序、不可重复）
6
        ├── HashSet
7
        └── TreeSet
8
Map（键值对）
9
  ├── HashMap
10
  └── TreeMap

3. 常用实现类#

• ArrayList：基于数组，查询快，增删慢，常用。
• LinkedList：基于链表，增删快，查询慢。
• HashSet：基于哈希表，无序、唯一。
• TreeSet：基于红黑树，自动排序、唯一。
• HashMap：基于哈希表，键值对，无序，key唯一。
• TreeMap：基于红黑树，键值对，自动按key排序。

4. 基本用法与常见操作#

• 添加元素：add()/put()
• 删除元素：remove()
• 判断包含：contains()/containsKey()
• 获取元素：get()/iterator()/for-each
• 清空集合：clear()
• 获取大小：size()

5. 示例代码#

1
import java.util.*;
2

3
List<String> list = new ArrayList<>();
4
list.add("A");
5
list.add("B");
6
System.out.println(list.get(0)); // A
7

8
Set<Integer> set = new HashSet<>();
9
set.add(1);
10
set.add(2);
11
System.out.println(set.contains(1)); // true
12

13
Map<String, Integer> map = new HashMap<>();
14
map.put("Tom", 18);
15
map.put("Jerry", 20);
16
System.out.println(map.get("Tom")); // 18

6. 遍历集合#

• for-each循环：

  1
  for (String s : list) {
  2
      System.out.println(s);
  3
  }
  

• 迭代器遍历：

  1
  Iterator<Integer> it = set.iterator();
  2
  while (it.hasNext()) {
  3
      System.out.println(it.next());
  4
  }
  

• Map遍历：

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

集合是Java开发中最常用的数据结构，掌握其用法有助于高效管理和处理数据。

1. 概念#

• 泛型是JDK 1.5引入的特性，用于在类、接口、方法中定义和使用类型参数，实现类型安全和代码复用。
• 常用于集合类、工具类等，避免强制类型转换和运行时类型错误。

2. 基本语法#

• 泛型类/接口：

  1
  class Box<T> {
  2
      private T value;
  3
      public void set(T value) { this.value = value; }
  4
      public T get() { return value; }
  5
  }
  6
  Box<Integer> box = new Box<>();
  7
  box.set(123);
  

• 泛型方法：

  1
  public <T> void print(T t) {
  2
      System.out.println(t);
  3
  }
  

• 泛型接口：

  1
  interface Converter<F, T> {
  2
      T convert(F from);
  3
  }