JAVA学习 DAY10 类和对象【万字长文！一篇搞定！】

哈喽，各位CSDN的小伙伴们～今天给大家带来一篇超全的Java核心知识点解析——《类和对象》。不管你是刚入门Java的小白，还是正在进阶的程序员，类和对象都是Java编程的基石，是面向对象编程（OOP）的核心载体。这篇博客会从基础概念入手，逐步深入到封装、代码块、内部类等高级特性，每个知识点都搭配详细案例、易错点提醒和实际应用场景，全文篇幅超18000字，建议收藏后慢慢研读，文末还有完整案例代码和学习路线总结，助力大家彻底吃透类和对象！

在开始正文之前，先和大家明确几个核心问题：为什么Java是纯面向对象语言？类和对象的关系是什么？掌握类和对象对后续学习继承、多态有什么帮助？带着这些问题，我们一步步揭开面向对象编程的神秘面纱～

一、面向对象的初步认知：从生活到代码

1.1 什么是面向对象？

Java是一门纯面向对象的编程语言（Object Oriented Program，简称OOP），在面向对象的世界里，一切皆为对象。这句话听起来很抽象，我们结合生活场景来理解：生活中的每一个实体，比如手机、电脑、洗衣机、身边的人、甚至是一只小狗，都可以看作是一个“对象”。而面向对象，就是一种解决问题的思想——我们不再像面向过程那样关注“步骤”，而是关注“对象之间的交互”，通过多个对象的配合来完成一件事情。

举个例子：我们每天使用的手机，它就是一个对象。它有自己的属性（品牌、型号、颜色、内存、电池容量等），也有自己的功能（打电话、发短信、拍照、上网等）。我们使用手机时，不需要关心手机内部的芯片如何工作、信号如何传输，只需要和手机的“接口”（屏幕、按键、触摸屏）进行交互，就能完成我们想要的操作。这种“屏蔽细节、关注交互”的思想，就是面向对象的核心。

用面向对象的思想设计程序，更符合人们对事物的认知规律。对于大型程序的设计、扩展以及维护来说，面向对象思想的优势尤为明显——比如我们要开发一个电商系统，里面的用户、商品、订单、购物车等，都可以抽象成独立的对象，每个对象负责自己的核心功能，后续修改某个模块时，不会对其他模块造成太大影响，极大地提高了代码的可维护性和可扩展性。

1.2 面向对象与面向过程的对比：两种解决问题的思路

为了更清晰地理解面向对象，我们对比一下它和“面向过程”的区别。面向过程（Procedure Oriented Program，简称POP）是一种传统的编程思想，它关注的是“完成任务的步骤”，就像我们按照菜谱做菜，一步一步执行，少了任何一步都不行。而面向对象关注的是“参与任务的对象”，以及对象之间的配合，就像一家餐厅做菜，有厨师、服务员、采购员等多个对象，每个对象负责自己的工作，通过配合完成客人的点餐需求。

我们以“洗衣服”这个场景为例，详细对比两种思想的差异：

1.2.1 传统洗衣服过程（面向过程）

面向过程的洗衣服，核心是“步骤”，每一个步骤都需要我们亲自执行，具体流程如下：

准备一个盆子；
往盆子里放水（控制水量和水温）；
把衣服放进盆子里；
倒入适量洗衣粉（根据衣服数量和脏污程度调整）；
用手搓洗衣服（重点搓洗领口、袖口等脏污部位）；
如果衣服太脏，需要再添加洗衣粉，重复搓洗步骤；
把盆子里的脏水倒掉；
重新往盆子里放清水，漂洗衣服；
再次搓洗衣服，去除残留的洗衣粉；
重复漂洗步骤，直到衣服上没有洗衣粉残留；
把衣服拧干；
把衣服挂起来晾干。

从这个流程可以看出，面向过程的特点是：注重步骤的完整性，每一步都需要明确执行，一旦某个步骤出错（比如水放多了、洗衣粉放少了），整个流程都会受到影响。而且，不同的衣服（比如毛衣、衬衫、牛仔裤），洗的方式、时间长度、拧干方式都不同，处理起来非常麻烦。如果将来要洗鞋子，那又是一套全新的步骤，代码的扩展性和维护性非常差。

1.2.2 现代洗衣服过程（面向对象）

面向对象的洗衣服，核心是“对象”，我们不需要关注具体的步骤，只需要找到合适的对象，通过对象之间的交互来完成任务。现代洗衣服涉及四个核心对象：人、衣服、洗衣粉、洗衣机。具体流程如下：

人（对象）把衣服（对象）放进洗衣机（对象）；
人（对象）倒入适量洗衣粉（对象）；
人（对象）启动洗衣机（对象）；
洗衣机（对象）自动完成洗衣、漂洗、甩干等步骤；
洗衣机（对象）完成工作后，人（对象）把衣服（对象）取出来晾干。

这个流程的特点是：不关注具体的执行步骤，只关注对象之间的交互。人不需要知道洗衣机是如何洗衣服的、如何甩干的，只需要通过“启动开关”这个接口和洗衣机进行交互即可；洗衣机也不需要知道衣服是谁的、洗衣粉是什么品牌的，只需要完成自己的核心功能（洗衣、甩干）即可。即使将来要洗鞋子，只要鞋子能放进洗衣机，或者有专门的洗鞋机对象，只需要调整对象之间的交互方式，不需要修改整个流程的核心代码，扩展性和维护性大大提升。

1.2.3 面向对象与面向过程的核心区别总结

为了方便大家记忆，我整理了一张对比表，清晰列出两种思想的核心差异：

对比维度	面向过程（POP）	面向对象（OOP）
核心关注	完成任务的步骤和过程	参与任务的对象和交互
代码组织方式	以函数/方法为核心，代码碎片化	以类和对象为核心，代码模块化
扩展性	差，修改一个步骤可能影响整个流程	好，新增/修改对象不影响其他模块
维护性	差，代码碎片化，难以定位问题	好，模块独立，问题定位清晰
适用场景	简单程序、小型项目（比如计算器、小游戏）	复杂程序、大型项目（比如电商系统、办公软件）
代表语言	C、Fortran、Basic	Java、Python、C++、C#

这里需要特别提醒大家：面向过程和面向对象并不是对立的，也没有好坏之分，它们都是解决问题的方法，有各自的适用场景。在实际开发中，我们往往会结合两种思想——比如在一个面向对象的项目中，某个对象的核心方法内部，可能会采用面向过程的思路来实现具体的步骤。

二、类定义和使用：把现实世界抽象成代码

通过上一节的学习，我们知道面向对象的核心是“对象”，而对象是现实世界中的实体。但计算机并不认识现实中的实体（比如洗衣机、小狗、学生），这就需要我们开发人员把这些实体“抽象”成计算机能识别的形式——这就是“类”的作用。

简单来说：类是对现实世界中某一类实体的抽象描述，它定义了这类实体具有哪些属性（外观、特征）和哪些方法（功能、行为）。而对象，就是根据类创建出来的具体实例。比如：“洗衣机”是一个类，它描述了洗衣机的属性（品牌、型号、重量、尺寸等）和方法（洗衣、脱水、定时等）；而你家客厅里的那台樱花XPB150-150S型号洗衣机，就是“洗衣机”类的一个具体对象。

2.1 简单认识类：属性和方法

任何一个类，都包含两个核心部分：属性（成员变量）和方法（成员方法）。

属性（成员变量）：用来描述类的特征，比如洗衣机的品牌、型号、重量，小狗的名字、颜色、年龄，学生的姓名、性别、成绩等。属性在类中是“静态”的描述，不需要执行就能存在。
方法（成员方法）：用来描述类的功能或行为，比如洗衣机的洗衣、脱水功能，小狗的汪汪叫、摇尾巴行为，学生的上课、写作业、考试行为等。方法需要被调用才能执行，执行后会完成特定的功能。

我们以“洗衣机”为例，拆解它的属性和方法：

洗衣机类的属性（成员变量）

产品品牌：樱花、海尔、美的等；
产品型号：XPB150-150S、MB100-6200WIDQCG等；
洗涤功率：540W、300W等；
脱水功率：250W、150W等；
洗涤容量：15KG、10KG等；
脱水容量：6.8KG、5KG等；
洗涤模式：半自动、全自动、滚筒等；
内桶材质：PP环保塑料、不锈钢等；
产品净重：30KG、25KG等；
主机尺寸：850×500×1000mm、600×550×850mm等；
颜色：白色、灰色、银色等。

洗衣机类的方法（成员方法）

洗衣功能：washClothes()，执行洗衣操作；
脱水功能：dryClothes()，执行脱水操作；
定时功能：setTime()，设置洗衣/脱水的时间；
启动功能：start()，启动洗衣机；
暂停功能：pause()，暂停洗衣机运行；
关闭功能：stop()，关闭洗衣机。

通过这些属性和方法，我们就完成了对“洗衣机”这个实体的抽象描述，计算机就能通过这个类，识别出“洗衣机”是什么、能做什么。

2.2 类的定义格式：Java中的语法规范

在Java中，定义类需要使用class关键字，语法格式非常固定。我们先来看最基本的定义格式，再逐步拆解每个部分的含义：

// 类的定义格式
class 类名 {
    // 字段（属性/成员变量）：用来描述类的特征
    访问修饰符 数据类型 变量名1;
    访问修饰符 数据类型 变量名2;
    // ... 更多成员变量
    
    // 方法（成员方法）：用来描述类的功能
    访问修饰符 返回值类型 方法名1(参数列表) {
        // 方法体：具体的功能实现
        代码语句;
        return 返回值; // 如果返回值类型不是void，必须有return语句
    }
    
    访问修饰符 返回值类型 方法名2(参数列表) {
        // 方法体
        代码语句;
        return 返回值;
    }
    // ... 更多成员方法
}

我们对这个格式中的核心部分进行拆解说明：

2.2.1 核心关键字和标识符

class关键字：专门用来定义类的关键字，必须放在类名前面，告诉编译器“接下来要定义一个类”。
类名：类的名称，相当于给这个抽象描述起一个名字。Java中类名的命名有严格规范：采用大驼峰命名法（每个单词的首字母大写，其余字母小写），比如WashMachine、PetDog、Student，不能以数字开头，不能使用Java中的关键字（比如class、public、static等）。
{}（类体）：类的主体部分，所有的成员变量和成员方法都必须定义在类体内部。

2.2.2 访问修饰符

访问修饰符用来控制成员变量和成员方法的“可见范围”，也就是哪些地方可以访问这些成员。Java中提供了四种访问修饰符：private、default（默认，不写任何修饰符）、protected、public。在类和对象的入门阶段，我们暂时统一使用public修饰成员（后续讲解封装时，会详细介绍四种修饰符的区别和使用场景）。

2.2.3 成员变量（属性）的定义

成员变量的定义格式：public 数据类型变量名;。比如：

public String brand; // 品牌（字符串类型）
public int washPower; // 洗涤功率（整数类型）
public double weight; // 重量（浮点数类型）
public boolean isAuto; // 是否全自动（布尔类型）

成员变量的命名规范：采用小驼峰命名法（第一个单词首字母小写，后续单词首字母大写），比如washPower、dryCapacity、innerBucketMaterial，变量名要见名知意，不能使用拼音或无意义的字符（比如a、b、x1等）。

2.2.4 成员方法（功能）的定义

成员方法的定义格式：public 返回值类型方法名(参数列表) { 方法体; return 返回值; }。比如：

public void washClothes() { ... } // 洗衣功能，无返回值，无参数
public void setTime(int time) { ... } // 定时功能，无返回值，有一个int类型参数
public int getWashPower() { return washPower; } // 获取洗涤功率，返回值为int类型，无参数

成员方法的核心部分说明：

返回值类型：方法执行完成后是否返回结果。如果不返回任何结果，返回值类型写void；如果返回结果，需要指定返回结果的数据类型（比如int、double、String等），并且方法体内部必须有return语句，返回对应类型的值。
方法名：方法的名称，命名规范和成员变量一致（小驼峰命名法），要见名知意，比如washClothes（洗衣）、dryClothes（脱水）。
参数列表：方法执行时需要传入的参数，格式为“数据类型参数名1, 数据类型参数名2, ...”，如果没有参数，括号内留空即可。
方法体：方法的核心逻辑，具体的功能实现代码都写在这里。
return语句：如果返回值类型不是void，必须有return语句，返回一个和返回值类型匹配的值；如果返回值类型是void，return语句可以省略（或者写return; 表示结束方法执行）。

2.2.5 注意事项（入门必看）

1. 类名必须采用大驼峰命名法，这是Java的编码规范，也是企业开发中的必备要求，比如WashMachine不能写成washMachine、Washmachine。

2. 成员变量和成员方法的访问修饰符，入门阶段统一用public，后续讲解封装时会详细介绍private和protected的使用场景。

3. 成员方法不要加static关键字（static修饰的是静态方法，属于类，不属于对象，后续讲解static成员时会详细说明），入门阶段的成员方法都是“对象的方法”，需要通过对象调用。

4. 一个Java文件中可以定义多个类，但最多只能有一个类被public修饰，并且被public修饰的类名必须和文件名相同（比如文件名是WashMachine.java，那么public修饰的类名必须是WashMachine）。

5. 成员变量可以先定义不赋值，Java会给它一个默认值（后续讲解默认初始化时会详细介绍），而局部变量（定义在方法内部的变量）必须先赋值再使用，否则编译报错。

2.3 完整案例：定义洗衣机类（WashMachine）

结合上面的语法格式，我们来定义一个完整的洗衣机类，包含属性和方法，大家可以直接复制到IDE中运行（比如Eclipse、IDEA）：

// 定义洗衣机类，类名采用大驼峰命名法
public class WashMachine {
    // 成员变量（属性）：描述洗衣机的特征
    public String brand;        // 产品品牌
    public String type;         // 产品型号
    public int washPower;       // 洗涤功率（单位：W）
    public int dryPower;        // 脱水功率（单位：W）
    public double washCapacity; // 洗涤容量（单位：KG）
    public double dryCapacity;  // 脱水容量（单位：KG）
    public String washMode;     // 洗涤模式（半自动/全自动/滚筒）
    public String innerMaterial;// 内桶材质
    public double weight;       // 产品净重（单位：KG）
    public double length;       // 主机长度（单位：mm）
    public double width;        // 主机宽度（单位：mm）
    public double height;       // 主机高度（单位：mm）
    public String color;        // 颜色
    
    // 成员方法（功能）：洗衣功能
    public void washClothes() {
        System.out.println(brand + "牌" + type + "洗衣机正在洗衣...");
        System.out.println("洗涤功率：" + washPower + "W，洗涤容量：" + washCapacity + "KG");
    }
    
    // 成员方法（功能）：脱水功能
    public void dryClothes() {
        System.out.println(brand + "牌" + type + "洗衣机正在脱水...");
        System.out.println("脱水功率：" + dryPower + "W，脱水容量：" + dryCapacity + "KG");
    }
    
    // 成员方法（功能）：定时功能（有参数，无返回值）
    public void setTime(int time) {
        System.out.println("已设置洗衣/脱水时间：" + time + "分钟");
    }
    
    // 成员方法（功能）：获取洗衣机的尺寸信息（无参数，有返回值）
    public String getSize() {
        return "主机尺寸：" + length + "mm × " + width + "mm × " + height + "mm";
    }
    
    // 成员方法（功能）：显示洗衣机的完整信息（无参数，无返回值）
    public void showInfo() {
        System.out.println("====================洗衣机信息====================");
        System.out.println("品牌：" + brand);
        System.out.println("型号：" + type);
        System.out.println("洗涤功率：" + washPower + "W");
        System.out.println("脱水功率：" + dryPower + "W");
        System.out.println("洗涤容量：" + washCapacity + "KG");
        System.out.println("脱水容量：" + dryCapacity + "KG");
        System.out.println("洗涤模式：" + washMode);
        System.out.println("内桶材质：" + innerMaterial);
        System.out.println("产品净重：" + weight + "KG");
        System.out.println("主机尺寸：" + length + "×" + width + "×" + height + "mm");
        System.out.println("颜色：" + color);
        System.out.println("================================================");
    }
}

这个案例中，我们定义了一个WashMachine类，包含11个成员变量（属性）和5个成员方法（功能），每个方法都有具体的逻辑实现。大家可以观察一下：成员变量的命名都是小驼峰，类名是大驼峰，方法名也是小驼峰，符合Java的编码规范。

2.4 课堂练习：定义狗类（PetDog）和学生类（Student）

为了巩固类的定义语法，我们做两个课堂练习，大家可以先自己动手写，再对照下面的答案。

练习1：定义狗类（PetDog）

需求：定义一个PetDog类，包含以下属性和方法：

属性：名字（name，String类型）、颜色（color，String类型）、年龄（age，int类型）、品种（breed，String类型）；
方法：
- 汪汪叫（bark()）：输出“[名字]：旺旺旺～～～”；
- 摇尾巴（wag()）：输出“[名字]：摇尾巴～～～”；
- 吃食物（eat(String food)）：输出“[名字]正在吃[食物]”；
- 显示狗的信息（showInfo()）：输出狗的名字、颜色、年龄、品种。

参考代码：

// 定义狗类
public class PetDog {
    // 成员变量（属性）
    public String name;   // 名字
    public String color;  // 颜色
    public int age;       // 年龄
    public String breed;  // 品种
    
    // 汪汪叫方法
    public void bark() {
        System.out.println(name + "：旺旺旺～～～");
    }
    
    // 摇尾巴方法
    public void wag() {
        System.out.println(name + "：摇尾巴～～～");
    }
    
    // 吃食物方法（有参数）
    public void eat(String food) {
        System.out.println(name + "正在吃" + food);
    }
    
    // 显示狗的信息方法
    public void showInfo() {
        System.out.println("====================狗狗信息====================");
        System.out.println("名字：" + name);
        System.out.println("颜色：" + color);
        System.out.println("年龄：" + age + "岁");
        System.out.println("品种：" + breed);
        System.out.println("================================================");
    }
}

练习2：定义学生类（Student）

需求：定义一个Student类，包含以下属性和方法：

属性：姓名（name，String类型）、性别（gender，String类型）、年龄（age，short类型）、学号（studentId，String类型）、学分（score，double类型）；
方法：
- 来上课（doClass()）：输出“[姓名]：按时上课，不要迟到，如果请假，及时补学”；
- 写作业（doHomework()）：输出“[姓名]：登录教务系统，完成作业，一旦拖沓，神仙难救”；
- 参加考试（exam()）：输出“[姓名]：考试目的，了解学情，人人必考，暴露问题”；
- 获取学分（getScore()）：返回学生的学分（返回值类型为double）；
- 显示学生信息（showInfo()）：输出学生的姓名、性别、年龄、学号、学分。

参考代码：

// 定义学生类
public class Student {
    // 成员变量（属性）
    public String name;      // 姓名
    public String gender;    // 性别
    public short age;        // 年龄（short类型比int节省空间）
    public String studentId; // 学号
    public double score;     // 学分
    
    // 来上课方法
    public void doClass() {
        System.out.println(name + "：按时上课，不要迟到，如果请假，及时补学");
    }
    
    // 写作业方法
    public void doHomework() {
        System.out.println(name + "：登录教务系统，完成作业，一旦拖沓，神仙难救");
    }
    
    // 参加考试方法
    public void exam() {
        System.out.println(name + "：考试目的，了解学情，人人必考，暴露问题");
    }
    
    // 获取学分方法（有返回值）
    public double getScore() {
        return score;
    }
    
    // 显示学生信息方法
    public void showInfo() {
        System.out.println("====================学生信息====================");
        System.out.println("姓名：" + name);
        System.out.println("性别：" + gender);
        System.out.println("年龄：" + age + "岁");
        System.out.println("学号：" + studentId);
        System.out.println("学分：" + score);
        System.out.println("================================================");
    }
}

大家可以对比自己写的代码和参考代码，看看有没有哪里不一致。重点关注：类名的命名规范、成员变量的定义、方法的参数和返回值类型、方法体的逻辑实现。如果有错误，比如类名用了小驼峰、方法名用了大驼峰、局部变量没赋值就使用等，要及时修正，养成良好的编码习惯。

三、类的实例化：从类到对象的蜕变

通过上一节的学习，我们已经掌握了类的定义方法——类是对现实实体的抽象描述，是一种“模板”或者“设计图”。但类本身并不能直接使用，就像建筑设计图不能直接住人一样，我们需要根据类这个“设计图”，创建出具体的“实例”——也就是对象。这个创建对象的过程，就叫做“类的实例化”。

简单来说：类是模板，对象是根据模板创建出来的具体实例；类不占用物理空间，对象占用物理空间。比如：WashMachine类是“洗衣机模板”，我们根据这个模板创建出“樱花XPB150-150S洗衣机”这个对象，这个对象有具体的品牌、型号、重量等属性值，也能执行洗衣、脱水等功能。

3.1 什么是实例化？

在Java中，类是一种“自定义类型”，和Java自带的内置类型（int、double、String等）类似。比如int类型可以定义整数变量，double类型可以定义浮点数变量，而我们自定义的WashMachine类、PetDog类、Student类，也可以用来定义“对象变量”。

用类类型创建对象的过程，就是“类的实例化”。Java中实例化对象必须使用new关键字，配合类名来完成。实例化对象后，我们就可以通过对象访问类中的成员变量（赋值、取值）和成员方法（调用执行）。

举个例子：int a = 10; 这里的int是内置类型，a是int类型的变量，10是int类型的具体值；而WashMachine washMachine = new WashMachine(); 这里的WashMachine是自定义类型（类），washMachine是WashMachine类型的对象变量，new WashMachine()是WashMachine类的具体实例（对象）。

3.2 实例化对象的语法格式

Java中实例化对象的语法格式有两种（本质上是一样的，只是写法不同），最常用的是第一种：

格式1：声明对象变量 + 实例化对象（推荐）

// 语法格式：类名 对象变量名 = new 类名();
类名 对象变量名 = new 类名();

// 示例：实例化WashMachine类的对象
WashMachine washMachine = new WashMachine();

// 示例：实例化PetDog类的对象
PetDog petDog = new PetDog();

// 示例：实例化Student类的对象
Student student = new Student();

格式2：先声明对象变量，后实例化对象

// 语法格式：
类名 对象变量名; // 第一步：声明对象变量（此时对象变量为null，未指向任何实例）
对象变量名 = new 类名(); // 第二步：实例化对象（给对象变量赋值，指向具体的实例）

// 示例：
WashMachine washMachine; // 声明对象变量，washMachine = null
washMachine = new WashMachine(); // 实例化对象，washMachine指向具体的洗衣机实例

这里需要特别提醒大家：如果只声明对象变量而不实例化（比如WashMachine washMachine;），此时对象变量的值是null（空引用），代表它没有指向任何具体的对象。如果此时通过对象变量访问成员变量或成员方法，会抛出NullPointerException（空指针异常），这是Java开发中最常见的异常之一，一定要避免。

3.3 访问对象的成员：.（点运算符）的使用

实例化对象后，我们需要通过对象访问类中的成员变量和成员方法，这时候就需要使用.（点运算符）。点运算符的语法格式非常固定：

3.3.1 访问成员变量（赋值和取值）

// 1. 给成员变量赋值：对象变量名.成员变量名 = 值;
对象变量名.成员变量名 = 值;

// 2. 获取成员变量的值：变量类型 变量名 = 对象变量名.成员变量名;
变量类型 变量名 = 对象变量名.成员变量名;

// 示例（给WashMachine对象的成员变量赋值）
WashMachine washMachine = new WashMachine();
washMachine.brand = "樱花"; // 给brand属性赋值
washMachine.type = "XPB150-150S"; // 给type属性赋值
washMachine.washPower = 540; // 给washPower属性赋值
washMachine.color = "白色"; // 给color属性赋值

// 示例（获取WashMachine对象的成员变量值）
String brand = washMachine.brand; // 获取brand属性值，brand = "樱花"
int power = washMachine.washPower; // 获取washPower属性值，power = 540
System.out.println("洗衣机品牌：" + brand); // 输出：洗衣机品牌：樱花

3.3.2 调用成员方法

// 语法格式：对象变量名.方法名(参数列表);
对象变量名.方法名(参数列表);

// 示例（调用WashMachine对象的成员方法）
washMachine.washClothes(); // 调用洗衣方法，无参数
washMachine.setTime(30); // 调用定时方法，传入参数30（分钟）
String size = washMachine.getSize(); // 调用获取尺寸方法，有返回值
System.out.println(size); // 输出：主机尺寸：850.0mm × 500.0mm × 1000.0mm

// 示例（调用PetDog对象的成员方法）
PetDog petDog = new PetDog();
petDog.name = "阿黄";
petDog.bark(); // 调用汪汪叫方法，输出：阿黄：旺旺旺～～～
petDog.eat("骨头"); // 调用吃食物方法，输出：阿黄正在吃骨头

这里需要注意：调用方法时，参数的数量、类型和顺序，必须和方法定义时的参数列表一致，否则会编译报错。比如setTime方法定义的是int类型的参数，调用时就必须传入int类型的值（比如30、20），不能传入字符串（比如"30"）。

3.4 完整案例：实例化对象并使用

我们结合之前定义的WashMachine、PetDog、Student类，写一个完整的案例，演示如何实例化对象、给成员变量赋值、调用成员方法：

// 主类（包含main方法，程序入口）
public class Main {
    public static void main(String[] args) {
        // --------------- 实例化洗衣机对象 ---------------
        System.out.println("=== 洗衣机对象使用演示 ===");
        // 1. 实例化WashMachine对象
        WashMachine washMachine = new WashMachine();
        // 2. 给成员变量赋值
        washMachine.brand = "樱花";
        washMachine.type = "XPB150-150S";
        washMachine.washPower = 540;
        washMachine.dryPower = 250;
        washMachine.washCapacity = 15.0;
        washMachine.dryCapacity = 6.8;
        washMachine.washMode = "半自动";
        washMachine.innerMaterial = "PP环保塑料";
        washMachine.weight = 30.0;
        washMachine.length = 850.0;
        washMachine.width = 500.0;
        washMachine.height = 1000.0;
        washMachine.color = "白色";
        // 3. 调用成员方法
        washMachine.showInfo(); // 显示洗衣机信息
        washMachine.washClothes(); // 调用洗衣功能
        washMachine.dryClothes(); // 调用脱水功能
        washMachine.setTime(30); // 设置定时30分钟
        String size = washMachine.getSize(); // 获取尺寸信息
        System.out.println("洗衣机尺寸：" + size);
        
        // --------------- 实例化狗狗对象 ---------------
        System.out.println("\n=== 狗狗对象使用演示 ===");
        // 1. 实例化PetDog对象
        PetDog petDog = new PetDog();
        // 2. 给成员变量赋值
        petDog.name = "阿黄";
        petDog.color = "黑黄色";
        petDog.age = 2;
        petDog.breed = "中华田园犬";
        // 3. 调用成员方法
        petDog.showInfo(); // 显示狗狗信息
        petDog.bark(); // 汪汪叫
        petDog.wag(); // 摇尾巴
        petDog.eat("骨头"); // 吃骨头
        
        // --------------- 实例化学生对象 ---------------
        System.out.println("\n=== 学生对象使用演示 ===");
        // 1. 实例化Student对象
        Student student = new Student();
        // 2. 给成员变量赋值
        student.name = "李雷";
        student.gender = "男";
        student.age = 18;
        student.studentId = "20260001";
        student.score = 3.8;
        // 3. 调用成员方法
        student.showInfo(); // 显示学生信息
        student.doClass(); // 来上课
        student.doHomework(); // 写作业
        student.exam(); // 参加考试
        double score = student.getScore(); // 获取学分
        System.out.println(student.name + "的学分：" + score);
    }
}

大家可以把这个Main类和之前定义的WashMachine、PetDog、Student类放在同一个包中，然后运行Main类的main方法，观察输出结果。输出结果应该如下：

=== 洗衣机对象使用演示 ===
====================洗衣机信息====================
品牌：樱花
型号：XPB150-150S
洗涤功率：540W
脱水功率：250W
洗涤容量：15.0KG
脱水容量：6.8KG
洗涤模式：半自动
内桶材质：PP环保塑料
产品净重：30.0KG
主机尺寸：850.0×500.0×1000.0mm
颜色：白色
================================================
樱花牌XPB150-150S洗衣机正在洗衣...
洗涤功率：540W，洗涤容量：15.0KG
樱花牌XPB150-150S洗衣机正在脱水...
脱水功率：250W，脱水容量：6.8KG
已设置洗衣/脱水时间：30分钟
洗衣机尺寸：主机尺寸：850.0mm × 500.0mm × 1000.0mm

=== 狗狗对象使用演示 ===
====================狗狗信息====================
名字：阿黄
颜色：黑黄色
年龄：2岁
品种：中华田园犬
================================================
阿黄：旺旺旺～～～
阿黄：摇尾巴～～～
阿黄正在吃骨头

=== 学生对象使用演示 ===
====================学生信息====================
姓名：李雷
性别：男
年龄：18岁
学号：20260001
学分：3.8
================================================
李雷：按时上课，不要迟到，如果请假，及时补学
李雷：登录教务系统，完成作业，一旦拖沓，神仙难救
李雷：考试目的，了解学情，人人必考，暴露问题
李雷的学分：3.8

从输出结果可以看出，我们成功实例化了三个对象，并且通过对象访问了类中的成员变量和成员方法，实现了预期的功能。这就是类和对象的核心使用场景——通过类定义模板，通过对象实现具体的功能。

3.5 多个对象的实例化：同一类可以创建多个对象

一个类可以实例化出多个对象，每个对象都是独立的，有自己的成员变量值（属性），但共享类中的成员方法（功能）。比如我们可以通过PetDog类，创建“阿黄”、“赛虎”两个不同的狗狗对象，它们的名字、颜色、年龄等属性可以不同，但都能执行汪汪叫、摇尾巴等功能。

我们通过一个案例来演示多个对象的实例化：

public class Main2 {
    public static void main(String[] args) {
        System.out.println("=== 多个狗狗对象演示 ===");
        // 实例化第一个狗狗对象：阿黄
        PetDog dog1 = new PetDog();
        dog1.name = "阿黄";
        dog1.color = "黑黄色";
        dog1.age = 2;
        dog1.breed = "中华田园犬";
        
        // 实例化第二个狗狗对象：赛虎
        PetDog dog2 = new PetDog();
        dog2.name = "赛虎";
        dog2.color = "棕色";
        dog2.age = 3;
        dog2.breed = "德牧";
        
        // 实例化第三个狗狗对象：小白
        PetDog dog3 = new PetDog();
        dog3.name = "小白";
        dog3.color = "白色";
        dog3.age = 1;
        dog3.breed = "比熊";
        
        // 调用三个对象的方法
        System.out.println("--- 阿黄的行为 ---");
        dog1.bark();
        dog1.wag();
        dog1.eat("骨头");
        
        System.out.println("\n--- 赛虎的行为 ---");
        dog2.bark();
        dog2.wag();
        dog2.eat("狗粮");
        
        System.out.println("\n--- 小白的行为 ---");
        dog3.bark();
        dog3.wag();
        dog3.eat("火腿肠");
    }
}

运行这个案例，输出结果如下：

=== 多个狗狗对象演示 ===
--- 阿黄的行为 ---
阿黄：旺旺旺～～～
阿黄：摇尾巴～～～
阿黄正在吃骨头

--- 赛虎的行为 ---
赛虎：旺旺旺～～～
赛虎：摇尾巴～～～
赛虎正在吃狗粮

--- 小白的行为 ---
小白：旺旺旺～～～
小白：摇尾巴～～～
小白正在吃火腿肠

从结果可以看出，dog1、dog2、dog3是三个独立的对象，它们的name、color等属性值不同，调用bark()方法时输出的内容也不同，但它们都共享PetDog类中的bark()、wag()、eat()方法。这就是类和对象的核心特性之一：多个对象共享类的方法，但每个对象有自己独立的属性。

3.6 类和对象的核心说明（必背）

为了帮助大家彻底理解类和对象的关系，这里总结了5个核心说明，建议大家牢记：

类只是一个“模板”或“设计图”，用来对一个实体进行描述，限定了类有哪些成员（属性和方法），但类本身不占用物理空间，也不能直接使用。
类是一种自定义的类型，可以像int、double等内置类型一样，用来定义变量（对象变量）。
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，用来存储类的成员变量（每个对象的成员变量值是独立的）。
类中的成员方法是所有对象共享的，多个对象调用同一个方法时，执行的是同一个方法逻辑，但方法中操作的是各自对象的成员变量（比如dog1.bark()操作的是dog1的name属性，dog2.bark()操作的是dog2的name属性）。
类和对象的关系：类是对象的抽象，对象是类的具体实例；没有类，就不能创建对象；没有对象，类的方法就无法执行（除非是静态方法）。

这里给大家举一个形象的比喻：类就像是建筑设计图，对象就像是根据设计图建造出来的房子。设计图只是一张纸，描述了房子的结构（卧室、客厅、厨房等，对应类的属性）和功能（住人、做饭等，对应类的方法），但设计图本身不能住人；而房子是根据设计图建造出来的具体实例，占用物理空间，可以实际使用（住人、做饭）。一张设计图可以建造出多栋房子，每栋房子的内部装修、家具摆放（对应对象的属性值）可以不同，但房子的结构和功能（对应类的方法）是相同的。

四、this引用：解决对象的“身份识别”问题

通过上一节的学习，我们已经掌握了类的实例化和对象成员的访问。但在实际开发中，我们会遇到两个非常棘手的问题，比如：

形参名不小心和成员变量名相同，函数体中到底是谁给谁赋值？比如：public void setDay(int year, int month, int day) { year = year; }，这里的year到底是成员变量还是形参？
多个对象调用同一个成员方法时，方法如何知道要操作哪个对象的成员变量？比如：dog1.bark()和dog2.bark()都调用bark()