面向对象基础

如果你写过 ES6 的 class，Java 的类你会觉得很亲切——语法高度相似。 差异主要在"更严格"：字段必须声明类型、构造器名等于类名、一个文件一个 public 类。

定义一个类

public class User {
    String name;      // 字段：必须写类型
    int age;

    // 构造器：名字 = 类名（不是 constructor 关键字）
    User(String name, int age) {
        this.name = name;   // this 指向当前实例
        this.age = age;
    }

    void introduce() {      // 实例方法
        System.out.println("我是 " + name);
    }
}

创建对象

User u = new User("Tom", 18);   // 对标 JS 的 new User("Tom", 18)
u.introduce();
u.name;   // 访问字段，点语法

this 的差别

• JS：this "飘"——谁调用指向谁，箭头函数又另说，是面试重灾区。
• Java：this 稳定指向当前对象实例，不会"飘"。行为可预测。

三条铁律

Java 类的硬规矩

1. 一个 .java 文件只能有一个 public 类，且文件名必须和它同名。
2. 字段必须声明类型：String name; 不能写成 name;。
3. 构造器名 = 类名，没有 constructor 关键字，也没有返回类型。

完整可运行示例

package com.javaglm.language.ch07;

/**
 * 第 07 章 · 面向对象基础。
 * 对标 JS 的 class：语法高度相似，但 Java 更严格——字段必须声明类型、构造器名=类名。
 * 一个 .java 文件只能有一个 public class，且文件名必须与它同名。
 */
public class OopBasicsDemo {

    public static void main(String[] args) {
        // new 创建对象，对标 JS 的 new User("Tom", 18)
        User u1 = new User("Tom", 18);
        User u2 = new User("Jerry");     // 用第二个构造器

        u1.introduce();   // 我是 Tom，今年 18 岁
        u2.introduce();   // 我是 Jerry，今年 0 岁

        // 访问字段 / 方法（. 语法，和 JS 一样）
        System.out.println("u1 的名字 = " + u1.name);
    }
}

/** 一个简单的类：字段 + 构造器 + 方法。 */
class User {

    // 字段：必须声明类型（对标 JS class 里的字段，但 Java 不写类型会报错）
    String name;
    int age;

    // 构造器：方法名就是类名，没有返回类型。对标 JS 的 constructor(name, age)
    User(String name, int age) {
        // this 指向当前对象实例，区分参数 name 和字段 name
        this.name = name;
        this.age = age;
    }

    // 构造器重载：只传名字时，年龄默认 0
    User(String name) {
        this.name = name;   // age 默认为 int 的默认值 0
    }

    // 实例方法（不带 static）：必须通过对象调用
    void introduce() {
        System.out.println("我是 " + name + "，今年 " + age + " 岁");
    }
}

为什么 demo 里有 User 但没 public

User 类没有 public 修饰符（包级可见），这样它和 OopBasicsDemo 能共存于同一文件。 实际项目里一个类一个文件更规范，教程为了集中展示才放一起。

---

:octicons-arrow-left-16: 上一章：方法与数组 ｜ 下一章：封装·继承·多态