JavaSE 核心知识点全解：从基础语法到多线程实战

注意：= 是赋值，== 才是等于。

逻辑运算符：

注意 && 和 & 的区别：

• &：无论左边真假，右边都运算
• &&：若左边为假，右边不运算（短路特性）

实际开发中推荐使用 && 和 ||。

位运算符：

条件运算符：

4. 循环语句

分类： while 循环、do/while 循环、for 循环

用法：

• 不知道循环次数用 while 循环

• 至少循环一次用 do/while 循环

• 知道循环次数用 for 循环

5. 定义方法

所有方法都要定义在类里。Java 中的方法类似函数，对完成某个功能的代码进行封装并命名，最终可重复调用。

方法定义示例：

public static void menu() { ... }

• public：访问权限
• static：静态
• void：返回值类型
• menu：方法名
• ( )：参数列表
• { ... }：方法体

6. 数组

概述：

• 数组是一组相同数据类型的集合，是一个容器。
• 可以存储基本数据类型，也可以存储引用数据类型。
• 数组本身是引用数据类型，是一个对象。
• 创建时必须指明长度，且长度不可变。
• 元素空间连续。

如何创建数组：

// 方式 1：指定长度
int[] a = new int[5];

// 方式 2：初始化赋值
int[] b = new int[]{1, 2, 3, 4, 5, 6, 7};

// 方式 3：简化写法
int[] c = {1, 2, 3, 4};

访问数组元素通过下标（索引），下标从 0 开始，最大索引 = 长度 - 1。

打印数组元素建议使用 Arrays 类：

int[] a = new int[5];
System.out.println(Arrays.toString(a)); // 输出数组内容

**前言：**面向过程 (POP) 强调具体步骤，结构简单但扩展性差；面向对象 (OOP) 从宏观分析功能，将不同功能封装在不同类中，便于维护。两者并非对立，OOP 实现细节仍依赖 POP。

二、面向对象

1. 类和对象

什么是类？ 具有相同特征事物的抽象描述，如人类、车类、学生类等。

类的结构：

• 变量：事物属性（名词）
• 方法：事物行为（动词）
• 构造方法：初始化对象
• 代码块：无名称的代码段
• 内部类：类中声明的类

如何写一个类？

1. 发现类
2. 定义成员变量
3. 定义成员方法
4. 创建对象使用

/* 定义学生类 */
public class Student {
    String name;
    int age;
    String gender;

    public void study() {
        System.out.println("学生要好好学习");
    }

    public void exercise() {
        System.out.println("学生要多运动");
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.study();
        student.name = "小王";
    }
}

什么是对象？ 对象是类的实例。使用 new 关键字在内存中创建实际存在的实例。

Student student = new Student();

2. 构造方法

**分类：**无参构造方法、有参构造方法。

特点：

• 方法名与类名相同，无返回值，不需要 void 修饰。
• 一个类可有多个构造方法（重载）。
• 若未定义构造方法，Java 提供默认无参构造；一旦定义了构造方法，默认构造消失。
• 使用 new 时自动调用。

**作用：**初始化对象状态。

public class Student {
    String name;
    int age;

    // 无参构造
    public Student() {
        name = "小张";
        age = 18;
    }

    // 有参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student("小魏", 20);
    }
}

3. 方法的重载

在一个类中有多个同名方法，通过参数的个数、类型、顺序区分。与返回值类型无关。

public class Student {
    public Student(String name, int age, String gender) {}
    public Student(int age, String name, String gender) {} // 参数顺序不同
    public Student(String name, int age) {}              // 参数个数不同
}

4. this 关键字

在类内部引用成员变量，区分局部变量。表示当前正在访问的对象。

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

5. static 关键字

介绍：

• 修饰成员变量（类变量）：内存中只有一份，所有对象共享。
• 修饰成员方法（类方法）：可直接用类名访问。

特点：

• 随类加载而加载，优先于对象存在。
• 静态方法中只能访问静态成员变量。

public class Demo {
    static int count = 0; // 类变量
    
    public static void show() {
        System.out.println(count); // 合法
    }
}

6. 代码块

**概念：**类中声明的无名称代码块。

分类：

• 实例代码块：每次创建对象时执行。
• 静态代码块：类被加载时自动执行。

public class Demo {
    { System.out.println("实例代码块"); }
    static { System.out.println("静态代码块"); }

    public static void main(String[] args) {
        new Demo();
        new Demo();
    }
}

7. 访问权限修饰符

• public：公共权限，任何地方可访问。
• protected：受保护权限，本类、同包、不同包子类可访问。
• default：默认权限，本类、同包可访问。
• private：私有权限，仅本类可访问。

8. 面向对象的三大特征

封装

**概念：**隐藏信息，通过特定方法访问，控制权在类手中。

**案例：**将成员变量私有化，提供 getter/setter。

public class Student {
    private String name;
    private int age;

    public String getName() { return name; }
    public void setName(String name) {
        if (name.length() > 1 && name.length() < 5) {
            this.name = name;
        }
    }
}

**单例模式：**确保程序只创建一个对象。

public class Window {
    static Window window = new Window();
    private Window() {}
    public static Window getWindow() { return window; }
}

继承

**概念：**抽取共性定义基类，子类继承拥有功能。

**条件：**符合 is-a 关系。一个类只能直接继承一个类。

public class Cat extends Animal { }

注意：未显式继承则默认继承 Object 类。

多态

**前提：**存在直接或间接继承关系。

**概念：**父类引用指向子类对象。

**口诀：**编译看左边，运行看右边（静态方法除外）。

Animal dog = new Dog();
dog.makeSound(); // 调用 Dog 重写的 makeSound()

9. 方法的重写

子类对父类方法进行覆盖，满足子类需求。

注意：

• 方法签名必须一致。
• 访问权限不能小于父类。
• 构造方法、静态方法不能重写。
• 建议添加 @Override 注解。

10. final 关键字

• 修饰类：不能被继承（如 String）。
• 修饰方法：不能被重写。
• 修饰参数：值不可变。
• 修饰变量：常量。

final static int A = 10;
final int COUNT;

11. 抽象类

**概念：**包含抽象方法的类，用 abstract 修饰。

特点：

• 不能实例化。
• 子类必须实现所有抽象方法，否则子类也必须是抽象类。

abstract class Animal {
    abstract void sound();
    void sleep() { System.out.println("睡觉"); }
}

12. 接口

**介绍：**特殊的抽象类，用 interface 定义，类用 implements 实现。

特点：

• 方法默认抽象。
• 类可实现多个接口。
• 接口可继承多个接口。

public interface MyInterface {
    int num = 10;
    void eat();
    default void test1() {}
}

三、API 常用类

Object 类

所有 Java 类的祖先。每个类都继承 Object。

1. toString 方法

默认返回哈希值。建议重写以输出对象信息。

@Override
public String toString() {
    return "Person{name='" + name + "', age=" + age + '}';
}

2. equals 方法

Object 中默认比较地址。通常重写为比较内容。

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

Arrays 类

操作数组的工具类。

• equals()：比较内容是否相等。
• copyOf()：复制数组。
• fill()：填充数组。
• sort()：排序。
• binarySearch()：二分查找。
• toString()：转字符串。

String 类

不可变的字符序列。

常用方法：

• length(), charAt(), indexOf(), substring()
• toUpperCase(), toLowerCase(), concat(), split()
• replace(), replaceAll(), trim()

StringBuffer 类

可变的字符序列，适合频繁修改字符串。

**区别：**String 每次拼接创建新对象，耗时；StringBuffer 原地修改，效率高。

Math 类 & Random 类

• Math.abs(), sqrt(), pow(), random()
• Random.nextInt(), nextLong()

Date 类

处理时间。getTime() 获取毫秒值。可用于测试性能。

四、集合

集合用于动态存储数据。

体系图

List 接口及实现类

有序、可重复。

• **ArrayList：**底层数组，查询快，增删慢。
• **LinkedList：**底层链表，查询慢，增删快。
• **Vector：**线程安全，效率低。

**遍历：**for 循环、增强 for、迭代器 (Iterator)。

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if (s.equals("a")) it.remove();
}

Set 接口及实现类

无序、不可重复。

• **HashSet：**基于哈希表，无序。
• **TreeSet：**基于树，可排序。

Map 接口

键值对存储，键唯一。

• **HashMap：**无序，允许 null 键值。
• **TreeMap：**按键排序。
• **Hashtable：**线程安全，不允许 null。

**遍历：**entrySet 推荐。

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

Collections 类

集合工具类，提供 sort、shuffle、reverse 等方法。

五、IO 流

File 类

表示文件或目录路径。无法直接读写文件内容。

File file = new File("E:/demo.txt");
file.createNewFile();

字节流与字符流

• **字节流：**InputStream/OutputStream，处理二进制。
• **字符流：**Reader/Writer，处理文本。

读写文件

字节流：

FileInputStream in = new FileInputStream("src.txt");
FileOutputStream out = new FileOutputStream("dst.txt");
byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) != -1) {
    out.write(buffer, 0, len);
}

**字符流：**支持续写和换行。

序列化

对象持久化。类需实现 Serializable 接口。

Student student = new Student("小魏", 20);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(student);

六、异常处理机制

异常概述

程序运行时的非正常情况。分为 Error（虚拟机错误）和 Exception（可处理异常）。

常见异常

• ArithmeticException（算术异常）
• NullPointerException（空指针异常）
• ArrayIndexOutOfBoundsException（数组越界）

异常处理

使用 try-catch-finally。

try {
    int c = a / b;
} catch (ArithmeticException e) {
    e.printStackTrace();
} finally {
    // 资源关闭
}

七、网络编程

核心要素

IP、端口号、通信协议。

TCP 协议

可靠连接，三次握手建立，四次挥手断开。

UDP 协议

无连接，速度快但不保证可靠性。

TCP 编程

服务器端：

ServerSocket server = new ServerSocket(8888);
Socket socket = server.accept();

客户端：

Socket socket = new Socket("127.0.0.1", 8888);

八、线程

基本概念

• **进程：**运行中的程序。
• **线程：**CPU 调度的最小单元。

创建线程

1. 继承 Thread 类，重写 run()。
2. 实现 Runnable 接口，避免单继承限制。

Thread t = new Thread(new Runnable() {
    public void run() { /* 任务 */ }
});
t.start();

线程同步

多线程访问共享资源时需同步，防止数据不一致。

**synchronized：**隐式锁，可修饰方法或代码块。

**ReentrantLock：**显式锁，需手动释放。

模拟卖票：

synchronized (obj) {
    if (num > 0) {
        System.out.println(Thread.currentThread().getName() + " 买到了第" + num-- + "张票");
    }
}

本文涵盖了 JavaSE 的核心内容，从基础语法到高级并发，旨在帮助开发者构建扎实的 Java 基础。