一、类的组成结构

Java类（.java文件）由两大核心要素构成：

public class Person {
    // 1. 属性（成员变量）
    String name;    // 姓名
    double height;  // 身高
    int age;        // 年龄

    // 2. 方法
    public void speak() { 
        System.out.println("正在说话"); 
    }
    
    public void run() { 
        System.out.println("正在跑步"); 
    }
    
    public int calculate(int a, int b) { 
        return a * b; 
    }
}

---

二、方法定义与调用

1. 基本语法

访问修饰符 返回值类型 方法名(参数列表) {
    // 方法体
    return 返回值; // 若返回值类型非void
}

示例：

public int sum(int a, int b) {
    return a + b;
}

2. 调用方式

Person p = new Person();
int result = p.sum(5, 3); // 通过对象调用

---

三、构造方法

1. 定义格式

public class Person {
    public Person() { } // 无参构造
    
    public Person(String name, int age) { // 有参构造 作用：new对象时调用，给属性赋值
        this.name = name;
        this.age = age;
    }
}

2. 核心特性

特性	说明
默认无参构造	未定义任何构造方法时，编译器自动生成
有参构造覆盖无参构造	若已定义有参构造，需显式添加无参构造才能使用

---

四、this关键字

1. 核心作用

    this可以理解为当前类的实例

• this.属性 → 如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性而非形参
• this.方法() → 调用当前类方法（通常可省略）
• this() → 调用构造方法时必须显式的使用"this(形参列表)"的方式

2. 典型场景

​
public class Person {
    private String name;
    
    public Person(String name) {
        this.name = name; // 如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性而非形参
    }
    
    public void introduce() {
        System.out.println("我叫" + this.name); // 显式调用属性
    }
}

​

---

五、方法重载（Overload）

1. 定义原则

    一个类中方法名相同，方法的参数类型 和 个数不同(同名不同参)

2. 实用案例

public class AreaCalculator {
    // 计算圆面积
    public double calculate(double radius) {
        return Math.PI * radius * radius;
    }
    
    // 计算三角形面积
    public double calculate(double base, double height) {
        return base * height / 2;
    }
    
    // 计算矩形面积
    public double calculate(int width, int height) {
        return width * height;
    }
}

---

六、参数传递机制

类型	数据类别	传递内容	方法内修改影响
值传递	基本数据类型	值副本	❌ 不影响实参
引用传递	对象类型	对象地址副本	✅ 影响到实参

示例对比：

---

七、变量作用域

变量类型	声明位置	生命周期
局部变量	方法/代码块内部	方法/代码块执行期间
成员变量	类内部，方法外部	对象存在期间

---

八、static关键字

1. 静态变量特性

特性	说明
类加载时初始化	早于对象创建
在内存空间只有一份	所有对象共享同一份数据

2. 与成员变量对比

特性	静态变量	成员变量
声明方式	static修饰	直接声明
访问方式	类名.变量名、对象.变量名（不推荐）	对象.变量名
数据共享性	所有对象共享	对象独享

代码示例：

public class Counter {
    static int count = 0; // 静态变量
    int id;               // 成员变量
    
    public Counter() {
        count++;
        id = count;
    }
}

3、静态方法

静态方法是隶属于类的方法，而非隶属于对象，是 Java 工具类的核心组成部分。

3.1 静态方法的特点

• ① 随着类的加载而加载，优先于对象存在，可通过类名.静态方法直接调用（推荐方式）；
• ② 静态方法中，只能调用静态的方法 / 属性；而非静态方法可调用静态 + 非静态的方法 / 属性；
• ③ 同类中的静态方法之间，可直接通过方法名调用。

3.2 静态方法的语法

public class 类名 {
    访问修饰符 static 返回类型 方法名称([参数列表]) {
        // 方法体
    }
}

3.3 静态方法示例

public class Car {
    // 定义静态方法
    public static void init() {
        System.out.println("这是一个静态方法");
    }

    // 程序入口，测试静态方法调用
    public static void main(String[] args) {
        Car.init(); // 类名.方法名 调用（推荐）
        Car c = new Car();
        c.init(); // 对象调用（不推荐）
        init(); // 同类静态方法间直接调用
    }
}

3.4 静态方法实战练习：MathUtils 工具类

需求：创建 MathUtils 工具类，提供通用的数学运算功能（如求和、求最大值、求阶乘）。

public class MathUtils {
    // 私有构造方法，避免创建对象（工具类无需实例化）
    private MathUtils() {}

    // 静态方法：求两个整数的和
    public static int sum(int a, int b) {
        return a + b;
    }

    // 静态方法：求两个整数的最大值
    public static int max(int a, int b) {
        return a > b ? a : b;
    }

    // 静态方法：求n的阶乘
    public static long factorial(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("阶乘参数不能为负数");
        }
        long result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }

    // 测试
    public static void main(String[] args) {
        System.out.println("10+20=" + MathUtils.sum(10, 20)); // 30
        System.out.println("10和20的最大值：" + MathUtils.max(10, 20)); // 20
        System.out.println("5的阶乘：" + MathUtils.factorial(5)); // 120
    }
}

九、代码块

代码块是 Java 中用于初始化类 / 对象的特殊语法，无需显式调用，会在特定时机自动执行。

1 为什么需要代码块

以 JDBC 工具类为例：数据库连接的驱动、URL、用户名、密码等配置，需要在类加载时仅初始化一次，而非每次创建对象都初始化。如果用普通方法，需要手动调用且容易重复执行；而静态代码块可完美解决这个问题。

示例（JDBC 工具类）：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

public class JdbcUtils {
    // 静态属性：数据库连接参数
    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    // 静态代码块：仅在类加载时执行一次，初始化连接参数
    static {
        try {
            Properties prop = new Properties();
            // 读取配置文件
            prop.load(JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            // 赋值静态属性
            driver = prop.getProperty("driver");
            url = prop.getProperty("url");
            username = prop.getProperty("username");
            password = prop.getProperty("password");
            // 加载驱动
            Class.forName(driver);
        } catch (Exception e) {
            throw new RuntimeException("初始化JDBC配置失败", e);
        }
    }

    // 静态方法：获取数据库连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
}

配置文件jdbc.properties内容：

properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
username=root
password=123456

2 代码块的定义与作用

• 定义：介于{}和}之间的一段代码，无需显式调用；
• 作用：用于初始化类的静态属性，或对象的实例属性。

3 代码块的分类

Java 代码块主要分为非静态代码块（构造代码块） 和静态代码块，核心区别如下表：

代码块类别	简称	定义	核心特点	执行特点
静态代码块	静态块	直接定义在类中，有 static 修饰	隶属于类，与对象无关	JVM 加载类时执行，仅执行一次
非静态代码块	构造块	直接定义在类中，无 static 修饰	隶属于对象	每次创建对象时执行，创建一次执行一次

3.1 非静态代码块（构造代码块）

核心特点

1. 用于初始化对象的属性；
2. 随对象创建而执行，每创建一个对象执行一次；
3. 多个非静态代码块按声明先后顺序执行；
4. 执行时机：在构造方法执行前执行。

示例

public class BlockTest {
    public static void main(String[] args) {
        // 创建两个Person对象，观察非静态代码块执行次数
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

class Person {
    // 构造方法
    public Person() {
        System.out.println("hello, Person()");
    }

    // 非静态代码块1（后声明）
    {
        System.out.println("hello, block-2");
    }

    // 非静态代码块2（先声明）
    {
        System.out.println("hello, block-1");
    }
}

运行结果

plaintext

hello, block-2
hello, block-1
hello, Person()
hello, block-2
hello, block-1
hello, Person()

3.2 静态代码块

核心特点

1. 用于初始化类的静态属性；
2. 随类的加载而执行，仅执行一次；
3. 多个静态代码块按声明先后顺序执行；
4. 执行时机：优先于非静态代码块和构造方法。

示例

public class BlockTest {
    public static void main(String[] args) {
        // 两次访问静态属性，观察静态代码块执行次数
        String desc1 = Person.desc;
        String desc2 = Person.desc;
    }
}

class Person {
    // 静态属性
    static String desc = "我是一个人";

    // 静态代码块1（后声明）
    static {
        System.out.println("hello, static block-2");
    }

    // 静态代码块2（先声明）
    static {
        System.out.println("hello, static block-1");
    }
}

运行结果

plaintext

hello, static block-2
hello, static block-1

4 代码块执行顺序练习（附答案）

题目

写出以下程序的运行结果：

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

    // 非静态代码块
    {
        System.out.println("22222222222");
    }

    // 构造方法
    public Demo() {
        System.out.println("33333333333");
    }

    public static void main(String[] args) {
        System.out.println("444444444444444");
        new Demo(); // 创建第一个Demo对象
        System.out.println("55555555555555");
        new Demo(); // 创建第二个Demo对象
    }
}

答案与解析

运行结果：

plaintext

11111111111
444444444444444
22222222222
33333333333
55555555555555
22222222222
33333333333

执行顺序解析：

• 静态代码块：在类加载时执行（仅执行一次），多个静态代码块按代码书写顺序依次执行；
• 非静态代码块：每次创建对象时，在构造方法执行前执行，多个非静态代码块也按代码书写顺序依次执行；
• 构造方法：非静态代码块执行完毕后，才执行构造方法。

1. JVM 加载 Demo 类 → 执行静态代码块 → 输出11111111111；
2. 执行 main 方法 → 输出444444444444444；
3. 创建第一个 Demo 对象 → 先执行非静态代码块（输出22222222222）→ 再执行构造方法（输出33333333333）；
4. 执行 main 方法后续代码 → 输出55555555555555；
5. 创建第二个 Demo 对象 → 再次执行非静态代码块（输出22222222222）→ 执行构造方法（输出33333333333）。