Java 面向对象入门：类、对象与封装核心详解

② 创建对象的标准语法

类名 对象名 = new 类名 ();
// 举例：Phone p = new Phone ();
// 左边：Phone p → 声明一个 Phone 类型的变量 p
// 右边：new Phone () → 真正创建 Phone 对象，在内存中开辟空间
// = → 把对象的内存地址赋值给变量 p，p 就指向了这个对象

③ 对象的使用

创建对象后，通过对象操作它的「属性」和「行为」，语法固定：

1. 访问/赋值成员变量：对象名。成员变量名
   • 赋值：p.brand = "小米";
   • 取值：System.out.println(p.brand);
2. 调用成员方法：对象名。成员方法名 (参数)
   • 调用：p.call();

3. 完整代码示例

开发规范：Java 中分为「JavaBean 类」和「测试类」，各司其职，必须分开写！

示例 1：JavaBean 类 - Phone.java

描述手机事物，无 main 方法。

public class Phone {
    // 成员变量：属性（特征）
    String brand; // 手机品牌
    double price; // 手机价格

    // 成员方法：行为（功能）
    public void call () {
        System.out.println("手机在打电话");
    }

    public void playGame () {
        System.out.println("手机在玩游戏");
    }
}

示例 2：测试类 - PhoneTest.java

写 main 方法，创建对象并使用。

public class PhoneTest {
    public static void main (String [] args) {
        // 1. 创建手机对象
        Phone p = new Phone ();

        // 2. 给对象的成员变量赋值
        p.brand = "小米";
        p.price = 1999.98;

        // 3. 获取对象的成员变量值并打印
        System.out.println(p.brand); // 输出：小米
        System.out.println(p.price); // 输出：1999.98

        // 4. 调用对象的成员方法
        p.call(); // 输出：手机在打电话
        p.playGame(); // 输出：手机在玩游戏

        // ========== 再创建一个对象，互不影响 ==========
        Phone p2 = new Phone ();
        p2.brand = "荣耀";
        p2.price = 3700.0;
        System.out.println(p2.brand); // 输出：荣耀
        System.out.println(p2.price); // 输出：3700.0
        p2.call(); // 输出：手机在打电话
    }
}

✅ 运行结果：每个对象都是独立的，修改 p 的属性不会影响 p2，这是对象的核心特性！

4. 关键概念：JavaBean 类 & 测试类

这是 Java 开发的基础规范，严格遵守，养成好习惯。

✔ JavaBean 类

• 作用：专门用来描述一类事物的类，只写属性和行为，永远不写 main 方法。
• 特点：纯描述，无业务逻辑，是项目中最基础的类，比如 Phone、Student、User。

✔ 测试类

• 作用：专门用来测试 JavaBean 类的类，里面只有 main 方法。
• 特点：在测试类中，可以创建 JavaBean 类的对象、给对象赋值、调用对象的方法，执行业务逻辑。

5. 类的定义注意事项

1. 一个 .java 源文件中，可以定义多个 class 类，但只能有一个类被 public 修饰；
2. 被 public 修饰的类，类名必须和文件名完全一致（大小写都要一致）；
3. 实际开发中，强烈建议一个文件只定义一个 class 类，可读性更高，便于维护；
4. 成员变量的完整格式：修饰符 数据类型 变量名 = 初始化值;，但一般不写初始化值，Java 会给成员变量赋默认值（和数组默认值一致）：
   • 整数：0
   • 小数：0.0
   • 布尔：false
   • 字符：\u0000
   • 引用类型：null

6. 开发技巧：如何设计一个类？

开发中拿到需求，不知道怎么设计类？记住这个万能公式，永远不会错。

属性 → 找名词：从需求中提取描述事物的名词，就是成员变量 行为 → 找动词：从需求中提取描述事物的动词，就是成员方法

比如：设计一个 GirlFriend 类 → 名词：姓名、年龄、性别 → 属性；动词：吃饭、睡觉 → 行为。

三、封装

1. 封装的核心思想

封装是 Java 面向对象的三大核心特征之首（封装、继承、多态），核心思想一句话概括：

✨ 对象代表什么，就要封装对应的数据，并提供该数据对应的行为 ✨

简单理解：谁的属性，就归谁管；谁的行为，就归谁做，职责分明，各司其职。

经典案例理解封装

1. 人画圆 → 画圆这个行为，是圆的行为，不是人的行为 → 人调用圆的画圆方法
2. 人关门 → 关门这个行为，是门的行为，不是人的行为 → 人调用门的关门方法
3. 张三砍李四 → 被砍这个行为，是李四的行为，不是张三的行为 → 张三调用李四的被砍方法

这个思想贯穿 Java 开发的始终，Java 官方设计的所有对象（比如 Scanner、String）都严格遵循这个原则，学会封装，你才算真正入门面向对象！

2. 封装的好处

封装是面向对象的精髓，学会封装，能让你的代码更优秀，好处非常多：

1. 让程序员学会自己设计合理的对象，职责分明，代码逻辑更清晰；
2. Java 官方按照封装思想设计了大量的对象（JDK API），我们可以直接拿来用，降低学习成本；
3. 封装可以保护成员变量，避免外部随意修改，提高代码的安全性；
4. 提高代码的复用性和可维护性，修改内部逻辑不会影响外部调用。

3. private 关键字：封装的核心实现手段

要实现封装，必须用到 private 关键字，这是 Java 中最常用的权限修饰符。

✔ private 关键字的核心特点

1. private 可以修饰成员变量和成员方法（类的成员）；
2. 被 private 修饰的成员，只能在当前类中访问和使用，在其他类中完全不可见；
3. private 的权限范围：本类可见，外部类不可见，是 Java 中权限最小的修饰符。

✔ 为什么要用 private？

在没有封装之前，我们直接通过 对象名。成员变量 给属性赋值，外部可以随意修改属性的值，没有任何限制，会导致数据不安全。比如：给 GirlFriend 的 age 赋值为 -18，这是非法数据，但代码不会报错，这就是数据泄露的问题。

而用 private 修饰成员变量后，外部无法直接访问，必须通过我们提供的方法来赋值和取值，我们可以在方法中添加数据校验逻辑，保证数据的合法性，这就是封装的核心价值！

4. 封装的标准步骤

当我们用 private 修饰成员变量后，外部无法访问，此时必须提供对应的访问方法，这是封装的固定步骤。

1. 用 private 关键字修饰所有的成员变量，私有化属性；
2. 为每一个私有化的成员变量，提供一对 public 修饰的方法：
   • setXxx(参数) 方法：给成员变量赋值，方法名必须是 set+ 变量名首字母大写
   • getXxx() 方法：获取成员变量的值，方法名必须是 get+ 变量名首字母大写
3. 在 setXxx 方法中，可以添加数据校验逻辑，保证数据的合法性；
4. 在 getXxx 方法中，直接返回成员变量的值即可。

5. 封装的完整代码示例

这是企业开发的标准写法，必须熟练掌握，能默写出来！

示例 1：JavaBean 类 - GirlFriend.java

私有化属性 + 提供 get/set 方法。

public class GirlFriend {
    // 1. 私有化所有成员变量，封装属性
    private String name;
    private int age;
    private String gender;

    // 2. 为每个私有化的成员变量，提供对应的 get/set 方法
    // name 的 set/get 方法
    public void setName (String name) {
        this.name = name;
    }

    public String getName () {
        return name;
    }

    // age 的 set/get 方法 + 数据校验逻辑（核心）
    public void setAge (int age) {
        // 校验年龄是否合法：只允许 18~25 岁
        if (age >= 18 && age <= 25) {
            this.age = age;
        } else {
            System.out.println("年龄非法！请输入 18~25 之间的数字");
        }
    }

    public int getAge () {
        return age;
    }

    // gender 的 set/get 方法
    public void setGender (String gender) {
        this.gender = gender;
    }

    public String getGender () {
        return gender;
    }

    // 成员方法：行为
    public void sleep () {
        System.out.println("女朋友在睡觉");
    }

    public void eat () {
        System.out.println("女朋友在吃饭");
    }
}

示例 2：测试类 - GirlFriendTest.java

调用 get/set 方法使用对象。

public class GirlFriendTest {
    public static void main (String [] args) {
        // 创建对象
        GirlFriend gf = new GirlFriend ();

        // 调用 set 方法给属性赋值
        gf.setName("小浔浔");
        gf.setAge(18);
        gf.setGender("女");

        // 调用 get 方法获取属性的值并打印
        System.out.println(gf.getName()); // 输出：小浔浔
        System.out.println(gf.getAge()); // 输出：18
        System.out.println(gf.getGender()); // 输出：女

        // 调用成员方法
        gf.eat(); // 输出：女朋友在吃饭
        gf.sleep(); // 输出：女朋友在睡觉

        // 测试非法数据：赋值年龄为 30
        gf.setAge(30); // 输出：年龄非法！请输入 18~25 之间的数字
        System.out.println(gf.getAge()); // 输出：0（默认值，未赋值成功）
    }
}

✅ 运行结果：非法数据被拦截，数据安全性得到保障，这就是封装的魅力！

6. 封装核心总结

1. private 是权限修饰符，可修饰成员变量和成员方法；
2. 被 private 修饰的成员，仅本类可见，外部类无法直接访问；
3. 封装的标准实现：私有化成员变量 + 提供 public 的 setXxx/getXxx 方法；
4. setXxx 方法：负责给成员变量赋值，可加数据校验，无返回值，有参数；
5. getXxx 方法：负责获取成员变量的值，有返回值，无参数；
6. 封装的核心价值：保护数据安全，提高代码可维护性。

核心知识点总结

✅ 面向对象核心

1. 面向对象编程：拿对象做事情，核心是「找对象、用对象」；
2. 学习阶段：先使用已有对象，再自定义类创建对象。

✅ 类与对象核心

1. 类是设计图，对象是具体实例，先有类后有对象；
2. 类的组成：成员变量（属性，名词）+ 成员方法（行为，动词）；
3. 对象的创建：类名 对象名 = new 类名 ();
4. 对象的使用：对象名。属性 赋值/取值，对象名。方法 () 调用行为；
5. JavaBean 类：描述事物，无 main 方法；测试类：测试对象，有 main 方法。

✅ 封装核心

1. 封装思想：对象代表什么，就封装对应的数据和行为；
2. 封装实现：private 私有化成员变量 + public 的 get/set 方法；
3. 封装好处：数据安全、逻辑清晰、提高复用性和可维护性；
4. setXxx 赋值 + 校验，getXxx 取值，是封装的标准写法。

面向对象不是一门语法，而是一种编程思想。从面向过程到面向对象，是程序员思维的一次质的飞跃。本节课的知识点，看似简单，但却是 Java 的根基：类与对象的关系、封装的思想、private 的使用，这些内容会贯穿整个 Java 学习生涯。

很多同学初学面向对象会觉得抽象、迷茫，这是正常的。面向对象的思想，不是靠记，而是靠练：多写几个类，多创建几个对象，多体会封装的思想，慢慢的你就会发现，面向对象的代码比面向过程的代码更简洁、更优雅、更符合现实世界的逻辑。