Java 中的类与对象

在 Java 编程中，类（Class） 与 对象（Object） 是面向对象编程（OOP）的核心概念。它们帮助开发者将现实世界中的实体抽象为程序结构，并以模块化、可维护的方式组织代码。

学习目标

理解类与对象的基本定义及其关系
掌握如何在 Java 中定义类和创建对象
了解对象的三大特性：状态、行为与身份
熟悉 Java 中创建对象的四种方式
认识匿名对象与多引用机制的应用场景

什么是类（Class）

类是创建对象的蓝图或模板。它定义了一组具有相同属性（字段）和行为（方法）的对象应具备的结构。

类的特点

将相关的字段（变量）和方法封装在一个单元中
本身不占用内存（字段的内存仅在对象实例化时分配）
可包含：字段、方法、构造函数、内部类、接口等

示例

定义一个 Student 类

class Student {
    int id;
    String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student(10, "Alice");
        System.out.println(s1.id);    // 输出：10
        System.out.println(s1.name);  // 输出：Alice
    }
}

说明：Student 是类，s1 是该类的一个具体对象（实例）。

什么是对象（Object）

对象是类的具体实例，代表现实世界中的某个实体（如一只狗、一个用户、一个商品）。每个对象具有三个核心特征：

特征	说明
状态	由字段（成员变量）的值表示，如 `name = "Tommy"`
行为	由方法定义，如 `bark()`、`run()`
身份	每个对象在内存中有唯一地址，用于区分不同对象

对象存储在 堆内存（Heap） 中，而对象的引用变量存储在 栈内存（Stack） 中。

对象的创建

创建对象的过程称为 实例化，使用 new 关键字完成。

1. 声明引用（未创建对象）

Dog tuffy;  // 仅声明引用，tuffy == null

2. 实例化对象

tuffy = new Dog("Tuffy", "Papillon", 5, "White");

new 操作符：分配内存 + 调用构造函数

完整示例

Dog 类

public class Dog {
    String name;
    String breed;
    int age;
    String color;

    public Dog(String name, String breed, int age, String color) {
        this.name = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    }

    public String getName() { return name; }
    public String getBreed() { return breed; }
    public int getAge() { return age; }
    public String getColor() { return color; }

    @Override
    public String toString() {
        return "Name is: " + name +
               "\nBreed, age and color are: " +
               breed + " " + age + " " + color;
    }

    public static void main(String[] args) {
        Dog tuffy = new Dog("Tuffy", "Papillon", 5, "White");
        System.out.println(tuffy);
    }
}

输出：

Name is: Tuffy
Breed, age and color are: Papillon 5 White

注意：如果类中未显式定义构造函数，Java 会提供一个默认无参构造函数。

通过方法初始化对象

静态方式

有时我们使用静态方法来设置类的状态（尤其适用于工具类或单例模式）：

public class Software {
    static String name;
    static float price;

    static void set(String n, float p) {
        name = n;
        price = p;
    }

    static void get() {
        System.out.println("Software name is: " + name);
        System.out.println("Software price is: " + price);
    }

    public static void main(String[] args) {
        Software.set("Visual Studio", 0.0f);
        Software.get();
    }
}

输出：

Software name is: Visual Studio
Software price is: 0.0

此方式适用于全局共享状态，但不推荐用于常规对象建模，因为它破坏了封装性。

创建对象的四种方式

方式	描述	典型应用场景
`new` 关键字	最常用、最直接的方式	日常开发
反射	动态加载类并创建实例	Spring、Hibernate 等框架
`clone()` 方法	复制已有对象（需实现 `Cloneable`）	快速复制对象
反序列化	从文件或网络流中重建对象	持久化、RPC 通信

1. 使用 `new` 关键字

标准方式

Test t = new Test();

2. 使用反射

Class<?> c = Class.forName("Student");
Student s = (Student) c.getDeclaredConstructor().newInstance();

3. 使用 `clone()`

class Tool implements Cloneable {
    String name = "CodeMaster";

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public static void main(String[] args) {
        try {
            Tool t1 = new Tool();
            Tool t2 = (Tool) t1.clone();
            System.out.println(t2.name); // 输出：CodeMaster
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

4. 使用反序列化

详情请参考《Java 序列化与反序列化》

// 序列化
try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("student.ser"))) {
    out.writeObject(new Student("Alice"));
}

// 反序列化
try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("student.ser"))) {
    Student s = (Student) in.readObject();
    System.out.println(s); // 输出：Student: Alice
}

所有被序列化的类必须实现 Serializable 接口。

一个引用指向多个对象

Java 允许同一个引用变量在不同时间指向不同的对象：

Test test = new Test();  // 第一次创建
test = new Test();       // 引用指向新对象，原对象变为垃圾回收候选

在继承中的典型用法

Animal obj = new Dog();  // 多态：父类引用指向子类对象
obj = new Cat();         // 同一引用可指向另一子类

当对象不再被任何引用指向时，会被 JVM 的垃圾回收器（GC）回收。

匿名对象

匿名对象是没有引用变量的对象，通常用于一次性操作。

特点

创建后立即使用，无法再次访问
节省内存（适合短生命周期任务）
常用于事件处理、测试调用等场景

示例

// 直接调用方法，不保存引用
new Dog("Max", "Labrador", 3, "Black").getName();

应用场景

GUI 编程中的按钮点击事件
单次验证或计算
单元测试中的临时对象

重点总结

类是模板，对象是实例
对象具有 状态、行为、身份 三大特征
使用 new 创建对象是最常见方式
Java 支持 4 种对象创建机制：new、反射、克隆、反序列化
匿名对象适用于一次性操作，提升代码简洁性
引用变量可动态指向不同对象，支持多态与资源复用

思考题

为什么说“类不占用内存，而对象占用内存”？请结合 JVM 内存模型解释。
在什么情况下你会选择使用 clone() 而不是 new 来创建对象？
匿名对象是否可以调用多个方法？如果可以，如何实现？如果不可以，为什么？