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

② 创建对象的标准语法

类名 对象名 = new 类名();
// 示例：Phone p = new Phone();
// 左侧：声明一个 Phone 类型的引用变量 p
// 右侧：在堆内存中开辟空间，创建 Phone 对象
// =：将对象的内存地址赋值给变量 p

③ 对象的使用

创建对象后，可通过 . 运算符操作其属性与行为：

• 访问/赋值成员变量：对象名.成员变量名（如 p.brand = "小米";）
• 调用成员方法：对象名.成员方法名(参数)（如 p.call();）

2.4 完整代码示例

JavaBean类 - Phone.java

public class Phone {
    // 成员变量：属性
    String brand;
    double price;

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

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

测试类 - PhoneTest.java

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); // 输出：荣耀
        p2.call();                    // 输出：手机在打电话
    }
}

注：每个对象在内存中独立存在，修改一个对象的属性不会影响其他对象。

2.5 JavaBean类与测试类规范

• JavaBean类：专门用于描述一类事物。仅包含属性和行为，不编写 main 方法。
• 测试类：专门用于测试 JavaBean 类。包含 main 方法，负责创建对象、赋值、调用方法及执行测试逻辑。

2.6 类的定义注意事项

1. 一个 .java 源文件中可定义多个 class，但只能有一个类被 public 修饰。
2. 被 public 修饰的类，类名必须与文件名完全一致（区分大小写）。
3. 实际开发中，强烈建议一个文件只定义一个类，以提高可读性与可维护性。
4. 成员变量若不手动初始化，Java 会赋予默认值（与数组默认值一致）：
   • 整数：0 | 小数：0.0 | 布尔：false | 字符：\u0000 | 引用类型：null

2.7 设计类的技巧

从需求中提取：

• 属性 → 找名词：描述事物的特征即为成员变量。
• 行为 → 找动词：描述事物的操作即为成员方法。

三、封装

封装是面向对象三大特征（封装、继承、多态）之首。

3.1 封装的核心思想

对象代表什么，就封装对应的数据，并提供该数据对应的行为。 即：谁的属性归谁管，谁的行为归谁做，职责分明。

• 例如：画圆是「圆」的行为，关门是「门」的行为。外部对象只需调用对应方法，无需关心内部实现细节。

3.2 封装的好处

1. 明确职责，使代码逻辑更清晰。
2. 保护成员变量，防止外部随意修改，提高数据安全性。
3. 隐藏内部实现细节，提高代码的复用性与可维护性。

3.3 private 关键字

private 是Java中最常用的权限修饰符，是实现封装的核心手段。

• 作用范围：仅在当前类内部可见，外部类无法直接访问。
• 解决的问题：未封装前，外部可通过 对象.属性 随意赋值（如设置年龄为负数），导致数据不安全。使用 private 后，必须通过指定方法访问，从而可在方法中加入数据校验逻辑。

3.4 封装的标准步骤

1. 使用 private 修饰所有成员变量，实现属性私有化。
2. 为每个私有变量提供一对 public 方法：
   • setXxx(参数)：用于赋值，方法名为 set + 变量名首字母大写。
   • getXxx()：用于取值，方法名为 get + 变量名首字母大写。
3. 在 setXxx 方法中添加数据校验逻辑，确保数据合法性。
4. 在 getXxx 方法中直接返回成员变量值。

3.5 封装完整示例

JavaBean类 - GirlFriend.java

public class GirlFriend {
    // 1. 私有化成员变量
    private String name;
    private int age;
    private String gender;

    // 2. 提供 get/set 方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setAge(int age) {
        // 添加数据校验
        if (age >= 18 && age <= 25) {
            this.age = age;
        } else {
            System.out.println("年龄非法！请输入18~25之间的数字");
        }
    }
    public int getAge() {
        return age;
    }

    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("女朋友在吃饭");
    }
}

测试类 - GirlFriendTest.java

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();

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

3.6 封装核心总结

1. private 修饰的成员仅本类可见。
2. 标准实现：私有化成员变量 + 提供 public 的 get/set 方法。
3. setXxx 负责赋值与校验（无返回值，有参数）；getXxx 负责取值（有返回值，无参数）。
4. 核心价值：保护数据安全，提升代码可维护性。

核心知识点总结

• 面向对象：核心是「找对象、用对象」。先使用内置对象，再自定义类创建对象。
• 类与对象：类是模板，对象是实例。先有类后有对象。通过 对象名.属性 和 对象名.方法() 进行操作。
• 封装：通过 private 隐藏内部数据，通过 public get/set 提供安全访问。是保障数据安全与代码健壮性的基石。