Java-第二章-面向对象（上）

Note

继Java基础语法后，我们正式进入Java核心特性——面向对象编程（OOP）的学习。面向对象是Java的灵魂，掌握对象、类、封装等核心概念，是理解后续复杂特性的关键！

面向对象编程（OOP）的核心思想是将现实世界中的事物抽象为程序中的 “对象”，通过封装、继承、多态等特性，让程序更贴近现实逻辑，也更易于维护和扩展。本节我们重点讲解面向对象的基础核心：对象和类、修饰符、构造方法、封装、this关键字。

对象和类#

现实世界中，“类”是对一类事物的抽象描述，“对象”是这类事物的具体实例。

1. 核心概念#

类（Class）：定义了对象的属性和行为，是创建对象的“模板”。
- 属性：对应类的成员变量。
- 行为：对应类的方法。
对象（Object）：类的具体实例，拥有类定义的所有属性和行为。

2. 语法规则#

（1）定义类

1
// 类名首字母大写，遵循驼峰命名法
2
public class 类名 {
3
    // 成员变量（属性）：定义在类中、方法外
4
    数据类型 变量名1;
5
    数据类型 变量名2;
6

7
    返回值类型 方法名() {
8
        // 方法体
9
    }
10
}

（2）创建对象

1
// 格式：类名 对象名 = new 类名();
2
类名 对象名 = new 类名();
3

4
// 访问对象的属性和方法
5
对象名.成员变量名;
6
对象名.成员方法名();

示例

1
// 定义Person类
2
public class Person {
3
    String name;
4
    int age;
5
    double height;
6

7
    public void eat() {
8
        System.out.println(name + "正在吃饭！");
9
    }
10

11
    public void speak() {
12
        System.out.println("大家好，我是" + name + "，今年" + age + "岁！");
13
    }
14

15
    public static void main(String[] args) {
16
        // 创建第一个Person对象
17
        Person zhangsan = new Person();
18
        zhangsan.name = "张三";
19
        zhangsan.age = 20;
20
        zhangsan.height = 1.75;
21
        zhangsan.eat();
22
        zhangsan.speak();
23

24
        // 创建第二个Person对象
25
        Person lisi = new Person();
26
        lisi.name = "李四";
27
        lisi.age = 22;
28
        lisi.height = 1.80;
29
        lisi.eat();
30
        lisi.speak();
31
    }
32
}

运行效果

1
张三正在吃饭！
2
大家好，我是张三，今年20岁！
3
李四正在吃饭！
4
大家好，我是李四，今年22岁！

修饰符#

Java修饰符用于限定类、变量、方法的访问权限和特性，核心分为访问修饰符和非访问修饰符两类。

1. 访问修饰符#

控制类/变量/方法的“可见范围”，是封装的核心基础，共4种：

修饰符	同一类中	同一包中	不同包的子类	不同包的非子类	常用场景
private	√	×	×	×	类的成员变量、私有方法（封装）
default	√	√	×	×	同包内的类/方法/变量（默认）
protected	√	√	√	×	子类需要访问的成员
public	√	√	√	√	对外提供的接口、主类

2. 非访问修饰符#

static：静态修饰符，修饰的变量/方法属于类本身，而非对象。
final：最终修饰符，修饰类则类不能被继承，修饰变量则变量值不可修改，修饰方法则方法不能被重写。
abstract：抽象修饰符，修饰抽象类/抽象方法。

示例

1
// 公共类：可被所有包访问
2
public class ModifierDemo {
3
    // 私有成员变量：仅本类可访问
4
    private String privateVar = "私有变量";
5

6
    // 默认修饰符：同包可访问
7
    String defaultVar = "默认变量";
8

9
    // 受保护变量：同包+子类可访问
10
    protected String protectedVar = "受保护变量";
11

12
    // 公共变量：所有地方可访问
13
    public String publicVar = "公共变量";
14

15
    // 静态变量：属于类，所有对象共享
16
    public static String staticVar = "静态变量";
17

18
    // 最终常量：值不可修改
19
    public final String FINAL_VAR = "最终常量";
20

21
    // 私有方法：仅本类可调用
22
    private void privateMethod() {
23
        System.out.println("调用私有方法：" + privateVar);
24
    }
25

26
    // 公共方法：对外提供访问私有成员的接口
27
    public void accessPrivate() {
28
        privateMethod(); // 本类内可调用私有方法
29
    }
30

31
    public static void main(String[] args) {
32
        ModifierDemo demo = new ModifierDemo();
33

34
        // 访问不同修饰符的变量
35
        System.out.println(demo.defaultVar);
36
        System.out.println(demo.protectedVar);
37
        System.out.println(demo.publicVar);
38

39
        // 访问静态变量
40
        System.out.println(ModifierDemo.staticVar);
41

42
        // 访问最终常量
43
        System.out.println(demo.FINAL_VAR);
44

45
        // 调用公共方法访问私有成员
46
        demo.accessPrivate();
47
    }
48
}

运行效果

1
默认变量
2
受保护变量
3
公共变量
4
静态变量
5
最终常量
6
调用私有方法：私有变量

构造方法#

构造方法（构造器）是创建对象时自动调用的特殊方法，用于初始化对象的属性。

1. 核心规则#

构造方法名必须与类名完全相同。
构造方法没有返回值类型。
若类中未定义构造方法，Java会自动提供一个无参默认构造方法。
若定义了构造方法，默认构造方法会失效。
构造方法支持重载。

2. 语法规则#

1
// 无参构造方法
2
public 类名() {
3
    // 初始化逻辑
4
}
5

6
// 有参构造方法
7
public 类名(参数类型1 参数名1, 参数类型2 参数名2) {
8
    // 给成员变量赋值
9
    this.参数名1 = 参数名1;
10
    this.参数名2 = 参数名2;
11
}

示例

1
public class ConstructorDemo {
2
    String name;
3
    int age;
4

5
    // 无参构造方法
6
    public ConstructorDemo() {
7
        System.out.println("调用无参构造方法，初始化对象！");
8
        this.name = "未知姓名";
9
        this.age = 0;
10
    }
11

12
    // 有参构造方法
13
    public ConstructorDemo(String name, int age) {
14
        System.out.println("调用有参构造方法，初始化对象！");
15
        this.name = name;
16
        this.age = age;
17
    }
18

19
    public void showInfo() {
20
        System.out.println("姓名：" + name + "，年龄：" + age);
21
    }
22

23
    public static void main(String[] args) {
24
        // 使用无参构造创建对象
25
        ConstructorDemo obj1 = new ConstructorDemo();
26
        obj1.showInfo();
27

28
        // 使用有参构造创建对象
29
        ConstructorDemo obj2 = new ConstructorDemo("张三", 20);
30
        obj2.showInfo();
31
    }
32
}

运行效果

1
调用无参构造方法，初始化对象！
2
姓名：未知姓名，年龄：0
3
调用有参构造方法，初始化对象！
4
姓名：张三，年龄：20

封装#

封装是面向对象的三大特性之一（封装、继承、多态），核心思想是：将对象的属性私有化，仅通过公共方法（getter/setter）访问和修改，隐藏内部实现细节，保证数据安全性。

1. 封装的实现步骤#

将类的成员变量用 private 修饰，使其私有化。
提供公共的 getXxx() 方法（获取属性值）和 setXxx() 方法。
在setter方法中可添加数据校验逻辑，保证数据的合法性。

示例

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

5
    // 无参构造
6
    public EncapsulationDemo() {}
7

8
    // 有参构造
9
    public EncapsulationDemo(String name, int age) {
10
        this.setName(name);
11
        this.setAge(age);
12
    }
13

14
    // getName()：获取姓名
15
    public String getName() {
16
        return name;
17
    }
18

19
    // setName()：设置姓名
20
    public void setName(String name) {
21
        if (name != null && !name.isEmpty()) {
22
            this.name = name;
23
        } else {
24
            System.out.println("姓名不能为空！");
25
            this.name = "默认姓名";
26
        }
27
    }
28

29
    // getAge()：获取年龄
30
    public int getAge() {
31
        return age;
32
    }
33

34
    // setAge()：设置年龄
35
    public void setAge(int age) {
36
        if (age >= 0 && age <= 150) {
37
            this.age = age;
38
        } else {
39
            System.out.println("年龄不合法（0-150）！");
40
            this.age = 0;
41
        }
42
    }
43

44
    // 展示信息
45
    public void showInfo() {
46
        System.out.println("姓名：" + name + "，年龄：" + age);
47
    }
48

49
    public static void main(String[] args) {
50
        EncapsulationDemo person = new EncapsulationDemo();
51

52
        person.setName("");
53
        person.setAge(200);
54
        person.showInfo();
55

56
        person.setName("李四");
57
        person.setAge(25);
58
        person.showInfo();
59

60
        // 使用有参构造创建对象
61
        EncapsulationDemo person2 = new EncapsulationDemo(null, -5);
62
        person2.showInfo();
63
    }
64
}

运行效果

1
姓名不能为空！
2
年龄不合法（0-150）！
3
姓名：默认姓名，年龄：0
4
姓名：李四，年龄：25
5
姓名不能为空！
6
年龄不合法（0-150）！
7
姓名：默认姓名，年龄：0

this关键字#

this 代表当前对象的引用，主要用于解决变量命名冲突、调用构造方法、访问当前对象的成员。

1. this的核心用法#

用法	场景说明
`this.成员变量`	区分成员变量和局部变量
`this.成员方法()`	调用当前对象的成员方法
`this(参数)`	在构造方法中调用本类的其他构造方法（必须是第一行）

示例

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

5
    // 无参构造
6
    public ThisDemo() {
7
        // 调用有参构造（this(参数)必须是第一行）
8
        this("默认姓名", 0);
9
        System.out.println("调用无参构造方法");
10
    }
11

12
    // 有参构造
13
    public ThisDemo(String name, int age) {
14
        this.name = name;
15
        this.age = age;
16
        System.out.println("调用有参构造方法");
17
    }
18

19
    // 成员方法：使用this调用其他方法
20
    public void showInfo() {
21
        this.print();
22
        System.out.println("姓名：" + this.name + "，年龄：" + this.age);
23
    }
24

25
    public void print() {
26
        System.out.println("=== 个人信息 ===");
27
    }
28

29
    public static void main(String[] args) {
30
        // 创建对象1：调用无参构造
31
        ThisDemo obj1 = new ThisDemo();
32
        obj1.showInfo();
33

34
        // 创建对象2：调用有参构造
35
        ThisDemo obj2 = new ThisDemo("王五", 30);
36
        obj2.showInfo();
37
    }
38
}

运行效果

1
调用有参构造方法
2
调用无参构造方法
3
=== 个人信息 ===
4
姓名：默认姓名，年龄：0
5
调用有参构造方法
6
=== 个人信息 ===
7
姓名：王五，年龄：30

代码块#

1. 核心概念#

代码块：用{}包裹的一段代码，是执行特定功能的代码区域，Java中根据位置和修饰符分为：局部代码块、构造代码块、静态代码块。
核心作用：初始化数据、隔离代码作用域、统一执行初始化逻辑。

2. 分类与语法规则#

（1）局部代码块

定义在方法内部，用于限制变量作用域，执行完后变量立即释放，节省内存。

1
public class Test {
2
    public static void main(String[] args) {
3
        // 局部代码块
4
        {
5
            int num = 10; // 仅在代码块内有效
6
            System.out.println(num);
7
        }
8
        // System.out.println(num); 报错，超出作用域
9
    }
10
}

（2）构造代码块（成员代码块）

定义在类中、方法外，每次创建对象时都会执行，优先于构造方法执行，用于抽取所有构造方法的公共初始化逻辑。

1
public class 类名 {
2
    // 构造代码块
3
    {
4
        // 初始化代码
5
    }
6

7
    // 构造方法
8
    public 类名(){
9
    }
10
}

（3）静态代码块

用static修饰，定义在类中、方法外，类加载时执行一次，优先于所有代码执行，用于加载驱动、初始化静态资源。

1
public class 类名 {
2
    // 静态代码块
3
    static {
4
        // 静态资源初始化代码
5
    }
6
}

3. 执行优先级总结#

静态代码块 > 构造代码块 > 构造方法 > 局部代码块

静态代码块：只执行1次（类加载时）
构造代码块：每创建一个对象，执行1次

示例

1
public class CodeBlockDemo {
2
    // 1. 静态代码块：类加载时执行，只执行1次
3
    static {
4
        System.out.println("① 静态代码块执行");
5
    }
6

7
    // 2. 构造代码块：每次创建对象都会执行
8
    {
9
        System.out.println("② 构造代码块执行");
10
    }
11

12
    // 构造方法
13
    public CodeBlockDemo() {
14
        System.out.println("③ 构造方法执行");
15
    }
16

17
    public static void main(String[] args) {
18
        // 3. 局部代码块：方法内，限制变量作用域
19
        {
20
            System.out.println("局部代码块执行");
21
        }
22

23
        // 创建第一个对象
24
        System.out.println("\n--- 创建第一个对象 ---");
25
        new CodeBlockDemo();
26

27
        // 创建第二个对象
28
        System.out.println("\n--- 创建第二个对象 ---");
29
        new CodeBlockDemo();
30
    }
31
}

运行效果

1
① 静态代码块执行
2
局部代码块执行
3

4
--- 创建第一个对象 ---
5
② 构造代码块执行
6
③ 构造方法执行
7

8
--- 创建第二个对象 ---
9
② 构造代码块执行
10
③ 构造方法执行

static关键字#

1. 核心概念#

static（静态）：是修饰符，用于修饰类的成员（成员变量、方法、代码块、内部类）。
核心特点：被static修饰的资源属于类本身，不属于单个对象，优先于对象加载，所有对象共享一份。

2. 语法规则#

（1）静态成员变量

定义：static 数据类型变量名;
调用：类名.变量名（推荐），也可以用对象名调用
特点：所有对象共享同一个值

（2）静态方法

定义：public static 返回值类型方法名(){}
调用：类名.方法名()（推荐）
注意：静态方法只能直接访问静态成员，不能访问非静态成员；静态方法中不能用this关键字

（3）静态代码块

上文已介绍，类加载时执行一次。

示例

1
public class StaticDemo {
2
    // 普通成员变量（属于对象）
3
    String name;
4
    // 静态成员变量（属于类，所有对象共享）
5
    static String school = "第一中学";
6

7
    // 普通方法
8
    public void showInfo() {
9
        System.out.println("姓名：" + name + "，学校：" + school);
10
    }
11

12
    // 静态方法
13
    public static void showSchool() {
14
        // 静态方法只能访问静态成员
15
        System.out.println("学校统一为：" + school);
16
    }
17

18
    public static void main(String[] args) {
19
        // 静态方法：直接用 类名.方法名() 调用
20
        StaticDemo.showSchool();
21

22
        // 创建对象1
23
        StaticDemo s1 = new StaticDemo();
24
        s1.name = "小明";
25
        s1.showInfo();
26

27
        // 创建对象2
28
        StaticDemo s2 = new StaticDemo();
29
        s2.name = "小红";
30
        s2.showInfo();
31

32
        // 修改静态变量（所有对象共享）
33
        StaticDemo.school = "实验中学";
34
        System.out.println("\n修改学校后：");
35
        s1.showInfo();
36
        s2.showInfo();
37
    }
38
}

运行效果

1
学校统一为：第一中学
2
姓名：小明，学校：第一中学
3
姓名：小红，学校：第一中学
4

5
修改学校后：
6
姓名：小明，学校：实验中学
7
姓名：小红，学校：实验中学

总结#

类与对象：类是对象的模板，对象是类的具体实例；创建对象的核心是 new 类名()。
修饰符：访问修饰符控制可见范围，static修饰类成员，final修饰不可变元素。
构造方法：与类名同名、无返回值，用于初始化对象，支持重载，无自定义构造时Java提供默认无参构造。
封装：核心是private私有化属性，通过getter/setter访问修改，可添加数据校验保证安全性。
this关键字：代表当前对象，用于区分重名变量、调用本类构造方法/成员方法。
代码块：静态代码块（类加载执行1次）、构造代码块（创建对象执行）、局部代码块（限制变量作用域）。
static关键字：修饰的资源属于类、共享、优先加载，推荐用类名.成员调用，静态方法不能直接访问非静态资源。
执行顺序：静态代码块 → 局部代码块 → 构造代码块 → 构造方法。

音乐

Pigeons2023

音乐

Java-第二章-面向对象（上）

对象和类#

1. 核心概念#

2. 语法规则#

修饰符#

1. 访问修饰符#

2. 非访问修饰符#

构造方法#

1. 核心规则#

2. 语法规则#

封装#

1. 封装的实现步骤#

this关键字#

1. this的核心用法#

代码块#

1. 核心概念#

2. 分类与语法规则#

3. 执行优先级总结#

static关键字#

1. 核心概念#

2. 语法规则#

总结#

支持与分享

评论区

音乐

目录