哈喽小伙伴们～ 今天聊聊 Java 的灵魂：类和对象

作为面向对象编程（OOP）的核心，类和对象是 Java 一切功能的基础。很多新手入门时会混淆概念，这篇文章就用通俗的语言 + 实战代码，带你吃透这些核心知识点～

---

一、先搞懂：面向过程 vs 面向对象

咱们先从思想上区分两种编程范式，用「做饭」举例最直观：

• 面向过程：按步骤执行 → 买菜→洗菜→切菜→炒菜→洗碗（一步不落自己干）
• 面向对象：模块化分工 → 买菜工（负责采购）、厨师（负责烹饪）、洗碗工（负责清洁）（各司其职，调用即可）

敲黑板：面向对象的底层还是面向过程，但通过抽象封装，让代码更易维护、可复用～

---

二、类：对象的 “模板说明书”

类是对现实事物的抽象描述，包含「属性（字段）」和「行为（方法）」，还藏着一个特殊的「构造方法」。

实战代码：定义一个 Person 类

public class Person {
    // 1. 字段（成员变量：类内部+方法外部）
    String name; // 姓名
    int age;     // 年龄
    private String idCard; // 私有字段（仅类内部访问）

    // 2. 构造方法（无参默认构造：可缺省）
    public Person() {}

    // 带参构造方法（用于初始化对象）
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 3. 普通方法（行为）
    public void sayHello() {
        String greeting = "Hi～"; // 临时变量：方法内部
        System.out.println(greeting + "我是" + name + "，今年" + age + "岁");
    }

    // 访问私有字段的getter方法
    public String getIdCard() {
        return idCard;
    }
}

关键点：

• 成员变量 vs 临时变量：前者属于对象，后者仅在方法执行时存在
• 构造方法名必须和类名一致，无返回值
• 若未定义构造方法，Java 会自动生成无参默认构造

---

三、new 一个对象：从模板到实例

有了类模板，就可以用new关键字创建对象（堆内存分配空间），还需要main()方法作为程序入口。

实战代码：创建和使用 Person 对象

public class TestPerson {
    public static void main(String[] args) {
        // 方式1：无参构造创建对象
        Person person1 = new Person();
        // 方式2：带参构造创建对象
        Person person2 = new Person("云扬", 28);

        // 调用对象方法
        person2.sayHello(); // 输出：Hi～我是云扬，今年28岁

        // 匿名对象（无引用变量，仅使用一次）
        new Person("匿名用户", 0).sayHello();
    }
}

---

四、对象初始化：3 种常用方式

创建对象后，给字段赋值（初始化）有 3 种经典方式：

public class InitDemo {
    public static void main(String[] args) {
        // 方式1：直接通过引用变量赋值
        Person p1 = new Person();
        p1.name = "张三";
        p1.age = 25;

        // 方式2：通过方法初始化
        Person p2 = new Person();
        p2.setInfo("李四", 30); // 需在Person类中添加setInfo方法

        // 方式3：通过带参构造方法（最常用）
        Person p3 = new Person("王五", 35);
    }
}

// 补充setInfo方法到Person类
public void setInfo(String name, int age) {
    this.name = name;
    this.age = age;
}

---

五、Object 类：所有类的 “老祖宗”

Java 中所有类都默认继承Object类，它提供了 11 个核心方法，咱们重点掌握最常用的 5 个：

1. equals () + hashCode ()：对象比较的黄金法则

@Override
public boolean equals(Object o) {
    // 1. 地址相同直接返回true
    if (this == o) return true;
    // 2. 对象为null或类不同返回false
    if (o == null || getClass() != o.getClass()) return false;
    // 3. 比较属性值
    Person person = (Person) o;
    return age == person.age && Objects.equals(name, person.name);
}

@Override
public int hashCode() {
    // 用Objects.hash()生成哈希码（避免手动计算）
    return Objects.hash(name, age);
}

约定：重写 equals () 必须重写 hashCode ()，否则 HashMap 等集合会出问题！

2. toString ()：让对象 “自我介绍”

默认实现是类名@哈希码，重写后更有意义：

@Override
public String toString() {
    return "Person{name='" + name + "', age=" + age + "}";
}

// 使用：System.out.println(person2); 
// 输出：Person{name='云扬', age=28}

3. clone ()：对象拷贝（需实现 Cloneable 接口）

public class Person implements Cloneable {
    // 其他代码不变...

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }

    // 测试拷贝
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p = new Person("张三", 25);
        Person pClone = (Person) p.clone();
        System.out.println(pClone.name); // 输出：张三
    }
}

4. wait () + notify ()：线程协作（简单示例）

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1等待...");
                    lock.wait(); // 释放锁并等待
                    System.out.println("线程1被唤醒！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Thread.sleep(1000);
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
}

---

六、对象的关键特性

1. 访问权限修饰符（保护数据安全）

修饰符	类内部	同包	子类	全局
public	✅	✅	✅	✅
protected	✅	✅	✅	❌
default	✅	✅	❌	❌
private	✅	❌	❌	❌

2. 组合（has-a 关系）：复用已有类

// 引擎类
class Engine {
    public void start() {
        System.out.println("发动机启动");
    }
}

// 汽车类（组合引擎）
class Car {
    private Engine engine = new Engine(); // 组合关系

    public void startCar() {
        engine.start(); // 调用引擎的方法
        System.out.println("汽车启动成功");
    }
}

3. 继承（is-a 关系）：扩展类功能

// 学生类继承Person类
class Student extends Person {
    String studentId; // 新增字段

    // 重写父类方法
    @Override
    public void sayHello() {
        System.out.println("我是学生" + name + "，学号：" + studentId);
    }

    // 新增方法
    public void study() {
        System.out.println("正在学习Java");
    }
}

4. 多态：父类引用指向子类对象

public static void main(String[] args) {
    Person student = new Student(); // 多态体现
    student.name = "李四";
    student.sayHello(); // 调用子类重写的方法
    // student.study(); // 报错：父类引用无法调用子类新增方法
}

---

总结

类是对象的模板，对象是类的实例，这是 Java OOP 的核心思想。重点掌握：

1. 类的结构（字段、方法、构造方法）
2. 对象的创建与初始化方式
3. Object 类的核心方法（equals、hashCode、toString 等）
4. 访问权限、组合、继承、多态的应用场景

建议大家多敲代码实践，比如用今天的例子扩展一个「员工管理系统」，把这些知识点串联起来～ 有疑问欢迎在评论区交流呀！