一、请解释面向对象与面向过程的核心区别？用生活例子说明两者的适用场景
面向过程和面向对象是解决问题的两种核心思路，本质区别在于"关注'步骤'还是'关注角色'"------就像准备一顿家常晚饭，有人盯着"买菜→洗菜→切菜→炒菜"的步骤，有人盯着"负责买菜的人、负责做饭的人、负责摆碗筷的人"这些参与的角色。
- 面向过程："按步骤做事，一步都不能乱"
面向过程是"把解决问题的步骤拆解开，用函数实现每个步骤，再按顺序调用"------比如你第一次自己做晚饭，会严格按"食谱步骤"执行：
-
列清单：买番茄、鸡蛋、青菜、大米；
-
去菜市场：按清单买齐食材；
-
回家处理：大米洗干净下锅煮，番茄洗干净切块，鸡蛋打散，青菜洗干净；
-
炒菜：先炒番茄炒蛋，再炒青菜；
-
收尾：把菜端上桌，摆好碗筷。
整个过程只关心"步骤有没有做完"，不用管"番茄是本地的还是外地的""锅是铁锅还是不粘锅"，只要步骤对，就能做出晚饭。
适用场景：简单、流程固定的问题。比如计算"一家三口一天的生活费总和"（步骤：记录早餐、午餐、晚餐花费→相加求和）、给手机设置闹钟（步骤：打开时钟APP→选择闹钟→设置时间→保存），这些问题步骤固定，改一个步骤对整体影响小。
- 面向对象："找对角色，让角色做擅长的事"
面向对象是"把问题中的'角色'拆成对象，描述每个对象的'特点'（属性）和'能做的事'（行为），让对象协作完成任务"------还是准备晚饭，面向对象会先确定"核心角色（对象）"：
• 采购对象：特点（预算50元、清单有番茄/鸡蛋/青菜）、能做的事（去菜市场挑新鲜食材、核对花费不超预算）；
• 厨师对象：特点（会做家常菜、知道煮米饭要放多少水）、能做的事（洗食材、切菜、炒番茄炒蛋、炒青菜、煮米饭）；
• 摆盘对象：特点（有4个碗4双筷子、知道菜要摆整齐）、能做的事（洗碗筷、把菜端上桌、摆好碗筷）。
你不用记死步骤，而是让每个角色各司其职：采购对象负责买新鲜食材，厨师对象负责把食材做成菜，摆盘对象负责把饭桌上的东西摆好，最后一起完成晚饭。
适用场景：复杂、需求多变的问题。比如开发一款家庭记账APP（涉及"记账人、收支记录、报表"等对象，记账人可以新增收支、查看报表，后续想加"月度预算提醒"功能，只需给"收支记录"对象加个"预算额度"属性）、设计一个家庭相册系统（涉及"照片、相册、家庭成员"对象，后续想加"照片分类"功能，只需给"照片"对象加个"分类标签"属性）。
- 核心区别总结
• 面向过程关注"怎么做"（步骤优先），面向对象关注"谁来做"（对象优先）；
• 面向过程代码复用性差（比如想换个口味的菜，得重新改"炒菜"步骤），面向对象复用性强（换个厨师对象，就能做不同口味的菜，不用改采购和摆盘）；
• 面向过程适合小需求（如简单计算），面向对象适合大项目（如APP开发）。
二、面向对象的三大特性是什么？用生活例子分别说明每个特性的作用
面向对象的三大特性是封装、继承、多态，它们就像"对象的三大能力"，让代码更安全、更灵活、更易维护------就像人有"保护自己隐私、继承父母习惯、灵活应对不同场景"的能力。
- 封装："把隐私藏起来，只留有用的入口"
封装是"将对象的'隐私信息'（属性）藏起来，只提供对外的'操作入口'（方法），控制外部怎么操作这些信息"------就像你家的存钱罐：
• 存钱罐里的钱（属性）是"隐私"的，你不会让外人随便打开存钱罐拿钱；
• 存钱罐的"投币口"和"取钱口"（方法）是对外的入口，你只能通过投币口存钱、通过取钱口拿钱，不能直接砸开存钱罐（直接访问属性）。
比如"手机对象"：
• 手机里的"通讯录""相册"（属性）是隐私的，不能让别人直接删你的联系人或照片；
• 手机提供"添加联系人""查看相册""删除照片"（方法）这些入口，你通过这些方法操作，还能设置密码（控制访问），避免误操作或恶意修改------比如删除照片前会提示"确定要删吗"，防止手滑删错。
封装的核心作用：保护数据安全，隐藏复杂细节。就像你用手机拍照时，不用知道"摄像头如何捕捉光线、如何处理图像"（复杂细节），只需要点"拍照按钮"（方法）就行，简单又安全。
- 继承："孩子像父母，还能有自己的特点"
继承是"子类（孩子）继承父类（父母）的'特点'（属性）和'习惯'（行为），同时可以新增自己的特点或修改父母的习惯"------就像你继承了父母的"黑头发、双眼皮"（父类属性），也继承了"每天早上喝牛奶"的习惯（父类方法），但你还新增了"每天晚上看书"的习惯（子类新增行为），并且把"喝牛奶"改成了"喝豆浆"（子类修改父类方法）。
比如"动物父类"和"小狗子类"：
• 父类（动物）的特点：有名字、有年龄；能做的事：吃饭、睡觉；
• 子类（小狗）继承了父类的特点（名字叫"旺财"、年龄2岁）和能做的事（吃狗粮、每天睡10小时），还新增了特点（毛色是黄色）、新增了能做的事（摇尾巴、看门），并且把"吃饭"改成了"边吃边摇尾巴"（修改父类方法）。
继承的核心作用：减少重复代码，实现复用。不用给"小狗、小猫、小兔"每个动物都写"吃饭、睡觉"的代码，只需要让它们继承"动物父类"，再补充自己的特色（比如小猫会抓老鼠、小兔会啃胡萝卜）。
- 多态："同一件事，不同对象有不同做法"
多态是"同一行为（方法），不同对象执行时会有不同的结果"------就像"'打招呼'这件事"：
• 你对朋友打招呼："嗨，最近咋样？"；
• 你对老师打招呼："老师好！"；
• 你对爷爷奶奶打招呼："爷爷奶奶身体好吗？"；
同样是"打招呼"（行为/方法），但根据对象（朋友、老师、长辈）不同，说法（实现）不同，不用手动判断"对方是谁"，自然就能做出合适的反应。
比如"家电父类"和"冰箱、空调子类"：
• 父类（家电）的行为：制冷；
• 子类（冰箱）的"制冷"：降低冰箱内部温度，保存食物；
• 子类（空调）的"制冷"：降低房间内部温度，让人凉快；
当你说"让家电制冷"（调用方法）时，如果是冰箱，就会保存食物；如果是空调，就会降温，不用手动区分"这是冰箱还是空调"。
多态的核心作用：灵活应对变化，降低代码耦合。比如家里新增"冰柜"（子类），不用改原有代码，只要让冰柜继承"家电父类"并实现"制冷"（冻肉），就能直接用，不用重新写"让冰柜制冷"的代码。
三、重载（Overload）和重写（Override）的区别是什么？用生活例子说明两者的使用场景
重载和重写都是实现多态的方式，但核心区别在"发生的位置"和"实现的逻辑"------就像妈妈做面条（重载是同一类里不同做法，重写是孩子改妈妈的做法）。
- 重载（Overload）："妈妈做面条，不同配料不同做法"
重载是"在同一个类中，方法名相同，但'输入的东西'（参数列表）不同"------就像妈妈做面条：
• 做清汤面：不用额外配料（无参数），做法是"水煮面条，加少许盐"；
• 做番茄鸡蛋面：要番茄和鸡蛋（2个参数），做法是"先炒番茄鸡蛋，再煮面条，混合拌匀"；
• 做牛肉青菜面：要牛肉和青菜（2个参数，类型和番茄鸡蛋不同），做法是"先煮牛肉，再煮面条，最后加青菜"；
它们都是"做面条"（方法名相同），但"配料（参数列表）"不同，做法和味道也不同。
比如"计算器类"的"加法"方法：
• 算两个整数的和（比如1+2）：方法名add，输入两个int；
• 算两个小数的和（比如1.5+2.5）：方法名add，输入两个double；
• 算三个整数的和（比如1+2+3）：方法名add，输入三个int；
这三个方法名都是add，但"输入的东西"不同，属于重载。
重载的核心特点：
• 发生在同一个类中；
• 方法名必须相同，参数列表必须不同（个数、类型、顺序，只要有一个不同就行）；
• 与返回值无关（比如不能一个返回int、一个返回double就叫重载，必须参数列表不同）；
• 是"编译时多态"（写代码时就知道要调用哪个方法）。
适用场景：同一功能有不同的"输入需求"。比如"妈妈做粥"------做白粥（无参数）、做小米粥（1个参数）、做南瓜小米粥（2个参数），都用"做粥"这个方法名，不用记"做白粥、做小米粥"多个名字，简单好记。
- 重写（Override）："孩子学妈妈做红烧肉，改了步骤"
重写是"子类继承父类后，对父类的方法进行重新实现，方法名、输入的东西（参数列表）、返回的东西（返回值）完全相同"------就像妈妈做红烧肉的步骤是"先炒糖色，再放肉炖1小时"（父类方法），你继承后觉得"先把肉炒香，再炒糖色，炖40分钟"更好吃（子类重写方法），方法名（做红烧肉）、输入的东西（肉、糖、酱油）、返回的东西（红烧肉）都相同，但步骤（实现）不同。
比如"交通工具父类"和"自行车、电动车子类"的"前进"方法：
• 父类（交通工具）的"前进"：只说"要向前动"，没说具体怎么动；
• 子类（自行车）的"前进"："人踩踏板，带动轮子转，向前走"；
• 子类（电动车）的"前进"："拧油门，电机带动轮子转，向前走"；
三个方法的方法名（前进）、输入的东西（无参数）、返回的东西（无）完全相同，只是步骤不同，属于重写。
重写的核心特点（必须遵循"里氏代换原则"，保证子类能替代父类）：
• 发生在子类和父类之间；
• 方法名、参数列表、返回值必须完全相同（子类返回值可以是父类返回值的"子类"，比如父类返回"水果"，子类返回"苹果"）；
• 子类方法的"访问权限"不能比父类更严格（比如父类方法是"全家能看"，子类不能改成"只有自己能看"）；
• 是"运行时多态"（运行时才知道要调用哪个方法）。
适用场景：子类需要"改父类方法的步骤"，但保持"方法的入口和出口不变"。比如"爸爸修自行车"的方法是"用扳手拧螺丝"，你学会后改成"用电动扳手拧螺丝"（更快），别人还是叫"修自行车"（调用同一个方法名），不用管你用的是普通扳手还是电动扳手。
四、Java 中的访问修饰符有哪些？它们的可见范围有什么区别？用生活例子说明每种修饰符的使用场景
Java 有四种访问修饰符：public（公开）、protected（受保护）、默认（不写修饰符）、private（私有），它们的作用是"控制'谁能访问'类、变量、方法"------就像你家的不同区域，有的谁都能进，有的只有家人能进。
- private（私有）："自己的日记本，只有自己能看"
• 可见范围：只能在同一个类中访问，其他类（包括子类）都不能直接碰；
• 生活例子：你抽屉里的日记本（private变量），只有你自己能打开看（同一个类中的方法），爸妈（子类）、朋友（其他类）都不能直接翻------就算爸妈想知道内容，也得问你要钥匙（通过你提供的方法）；
• 使用场景：修饰"对象的核心隐私数据"，比如"Person类"的"银行卡密码""健康记录"，这些数据不能让外部直接改，只能通过类中的方法（比如"查密码""改密码"）间接操作，避免被篡改。
比如"手机类"的"电量"属性：用private修饰，外部不能直接写"手机.电量=100%"，只能通过"充电"方法增加电量，通过"耗电"方法减少电量，保证电量不会出现"负数""超过100%"的异常。
- 默认（不写修饰符）："家里的客厅，同单元邻居能进"
• 可见范围：只能在同一个包中访问，不同包的类（包括子类）都不能访问；
• 生活例子：你家的客厅（默认修饰的区域），同单元的邻居（同一个包的类）来串门能进，其他单元的人（不同包的类）不能进------就算是你外地的表哥（不同包的子类），也得先按门铃让你开门才能进；
• 使用场景：修饰"同一个包内共享的工具"，比如"家庭记账APP"的"计算工具包"中的"汇率转换类"，只需要包内的"收支记录类""报表类"使用，不用对外公开，就用默认修饰符，避免外部误用。
比如"math包"中的"求和工具类"，包内的"成绩统计类"需要用它算"全班总分"，其他包的"购物类"用不到，就用默认修饰符，保证包内代码的独立性。
- protected（受保护）："爸妈的房间，家人和亲戚能进"
• 可见范围：同一个包中的类能访问，不同包的子类也能访问，其他类不能访问；
• 生活例子：爸妈的房间（protected区域），家人（同一个包的类）能随便进，外地来的表哥（不同包的子类）来做客也能进，但陌生人（不同包的非子类）不能进------房间里的保健品（protected变量），家人和表哥能吃，陌生人不能吃；
• 使用场景：修饰"父类中需要被子类继承，但不想让外人碰的东西"，比如"Animal父类"的"心跳频率"属性，子类"Dog""Cat"需要用它算"寿命"，但外部的"Car类"（非子类）用不到，就用protected修饰。
比如"Person父类"的"家庭地址"方法：用protected修饰，不同包的"Student子类"（你的孩子）能继承这个方法，知道家庭地址方便回家；但不同包的"Stranger类"（陌生人）不能调用，保护隐私。
- public（公开）："小区的健身区，谁都能进"
• 可见范围：所有类都能访问，不管是否在同一个包、是否是子类；
• 生活例子：小区的健身区（public区域），小区居民（同一个包的类）、外来访客（不同包的类）、你的亲戚（子类）都能进，没有限制------健身区的跑步机（public方法），谁都能用来锻炼；
• 使用场景：修饰"需要对外公开的功能"，比如"家庭购物APP"的"下单"方法，需要被"用户类""商家类""快递类"调用，就用public修饰，保证所有相关类都能使用。
比如"外卖平台"的"查询订单"方法：用public修饰，用户能查自己的订单状态，商家能查订单是否已接单，快递员能查订单要送哪里，所有相关角色都能访问。
- 可见范围总结（从"最严格"到"最宽松"）
private → 默认 → protected → public
• 私有：仅自己（同一类）可见；
• 默认：同单元（同包）可见；
• 受保护：同单元+亲戚（同包+不同包子类）可见；
• 公开：所有人（所有类）可见。
五、this 关键字有什么作用？用生活例子说明每种作用的使用场景
this 关键字代表"当前对象的引用"，可以理解为代码中的"我"------就像你说话时用"我"指代自己，this 就是对象在代码中称呼"自己"的方式。它主要有三种核心作用：
- 直接引用当前对象的属性或方法："用'我'说自己的事"
• 作用：明确调用当前对象的属性或方法，避免和其他变量混淆；
• 生活例子：你和朋友聊天时说"我今天去公园散步了"，"我"就是this，指代你自己；你说"我的书包是蓝色的"，就是"this.书包=蓝色"，明确是"你自己的书包"，不是朋友的；
• 使用场景：当需要清晰区分"当前对象的属性"和"其他变量"时。比如"Person类"的"自我介绍"方法："我叫小明，今年20岁"，对应代码就是"System.out.println("我叫" + this.name + "，今年" + this.age + "岁");"，这里的this.name、this.age就是"当前对象的名字和年龄"，不管方法里有没有其他同名变量，都不会乱。
比如你在"Student类"中写"学习"方法："我今天学了数学"，代码是"public void study() { System.out.println("我今天学了" + this.subject); }"，this.subject就是"当前学生的学习科目"，清晰又明确。
- 区分成员变量和局部变量："'我的钱'和'妈妈给的钱'"
• 作用：当方法的"临时变量"（局部变量）和类的"固有变量"（成员变量）重名时，用this区分；
• 生活例子：你自己有10元钱（成员变量this.money=10），妈妈又给你5元钱（局部变量money=5），你说"我的钱是10元，妈妈给的是5元"，这里的"我的钱"就是this.money，区分了"自己的钱"和"妈妈给的钱"；
• 使用场景：构造方法或"设置属性"的方法中，局部变量（参数）和成员变量重名时。比如"Person类"的构造方法："创建一个叫'小红'、18岁的人"，参数名和成员变量名都叫name、age，代码就需要用this区分："public Person(String name, int age) { this.name = name; this.age = age; }"，这里的this.name是"对象的名字"，右边的name是"传入的参数"，避免赋值错误。
比如"Phone类"的"设置颜色"方法："public void setColor(String color) { this.color = color; }"，this.color是手机本身的颜色（成员变量），参数color是用户想设置的颜色（局部变量），用this区分后，才能正确把用户要的颜色赋给手机。
- 调用本类的其他构造方法："'我'小时候的样子，变成现在的样子"
• 作用：在一个构造方法中，用"this(参数)"调用本类的其他构造方法，避免重复写代码；
• 生活例子：你现在的样子（构造方法A：有名字、年龄、地址），是基于"小时候的样子"（构造方法B：只有名字、年龄）发展来的，你说"我小时候叫小兰、5岁，现在住幸福街1号"，相当于用"this(小兰,5)"调用小时候的构造方法，再补充地址（现在的信息）；
• 使用场景：类有多个构造方法，且方法之间有"包含关系"时。比如"Student类"有两个构造方法：
◦ 简单版：只需要名字（"创建一个叫'小刚'的学生"）；
◦ 完整版：需要名字和学号（"创建一个叫'小刚'、学号2023001的学生"）；
完整版构造方法可以调用简单版，避免重复写"给名字赋值"的代码："public Student(String name, String studentId) { this(name); this.studentId = studentId; }"，这里的this(name)调用了简单版构造方法（给学生赋名字），再补充学号，代码更简洁。
比如"Book类"的构造方法：简单版"只有书名"，完整版"有书名和作者"，完整版就可以调用简单版："public Book(String title, String author) { this(title); this.author = author; }"，先给书赋书名，再赋作者，逻辑更清晰。
注意点
this 不能在静态方法中使用------因为静态方法属于"类"，不属于"对象"，就像"学校的广播通知"（静态方法），不是某个学生（对象）发出的，不能用"我"（this）指代，否则会报错。
六、抽象类（Abstract Class）和接口（Interface）有什么区别？用生活例子说明两者的设计思路
抽象类和接口都是"定义规范的工具"，但核心区别在"是'类的模板'还是'行为的规范'"------就像"家电使用说明书"（抽象类）和"社区文明公约"（接口），前者是模板，后者是规范。
- 方法与实现："模板有具体步骤，规范只有要求"
• 抽象类：可以包含"抽象方法（只有要求，没有步骤）"和"非抽象方法（有具体步骤）"------就像"家电使用模板"：写了"插上电源就能工作"（非抽象方法，有步骤），但"如何制冷/制热"（抽象方法）没写，让不同家电（子类）自己定步骤；
比如"家电抽象类"：有非抽象方法"通电()"（"插上电源，指示灯亮"），有抽象方法"工作()"（不同家电工作步骤不同，不写具体内容）；
• 接口：Java 8 前只能有"抽象方法（只有要求）"和"固定不变的常量"，Java 8 后可加"默认方法（有步骤，可选）"------就像"社区文明公约"：写了"必须垃圾分类"（抽象方法，只有要求），还写了"扔垃圾要戴手套"（默认方法，有步骤，可选做），让每个居民（实现类）自己执行；
比如"可回收接口"：有抽象方法"分类垃圾()"（必须做，没步骤），有默认方法"戴手套()"（"戴一次性手套，避免脏手"，可选做或改步骤）。
- 继承与实现："只能用一个模板，可遵守多个规范"
• 抽象类：一个类只能继承一个抽象类（单继承）------就像你只能有一个亲生妈妈（抽象类），继承她的习惯（方法），不能同时有两个亲生妈妈；
比如"冰箱类"只能继承"家电抽象类"，不能同时继承"家电"和"家具"两个抽象类；
• 接口：一个类可以实现多个接口（多实现）------就像你可以同时遵守"社区公约""交通规则""学校纪律"，多个规范不冲突；
比如"电动车类"可以同时实现"可骑行接口""可充电接口""可载人接口"，既会跑，又能充电，还能载人。
- 成员变量："模板有可变属性，规范只有固定常量"
• 抽象类：可以有"可变的属性"（比如当前电量）、"固定的常量"（比如额定电压）------就像"家电模板"里有"当前电量"（可变，用久了会减少）、"额定电压220V"（固定，不能改）；
• 接口：只能有"固定不变的常量"（默认public static final），不能有可变属性------就像"社区公约"里只有"垃圾投放时间7:00-9:00"（固定），不能有"今天投放时间"（可变）。
比如"可载人接口"里的"最大载人数"是常量："int MAX_PEOPLE = 2;"（固定只能载2人），所有实现该接口的类（电动车、自行车）都不能改；而"电动车抽象类"里的"当前载人数"是可变属性："int currentPeople = 0;"（可从0变到2），每个电动车对象的载人数不同。
- 设计思路："模板回答'是什么'，规范回答'能做什么'"
• 抽象类：是"对类的抽象"，回答"这个类是什么"------比如"家电抽象类"定义了"这是家电"，有家电的共性（通电、工作），子类（冰箱、空调）是"具体的家电"；
• 接口：是"对行为的抽象"，回答"这个类能做什么"------比如"可充电接口"定义了"能充电"，不管实现类是电动车还是手机，只要能充电，就可以实现。
比如：
• 用抽象类定义"动物"（是什么：是动物，有呼吸、吃饭的共性）；
• 用接口定义"会游泳"（能做什么：能游泳，不管是鱼还是鸭子，只要会游泳就实现）；
• 子类"鸭子"继承"动物抽象类"（是动物），同时实现"会游泳接口"（能游泳），既符合"动物"的模板，又遵守"会游泳"的规范。
七、成员变量与局部变量的区别有哪些？用生活例子说明两者的核心差异
成员变量和局部变量是Java中两种不同"生命周期"的变量，核心区别在"属于谁""存哪里""活多久"------就像"家里的电视"（成员变量）和"临时用的充电宝"（局部变量）。
- 定义位置与归属："属于家还是属于出门这件事"
• 成员变量：定义在类中、方法外，属于"对象或类"------就像家里的电视（属于"家"这个类），只要家在（对象存在），电视就一直在，不会因为你出门（调用方法）就消失；
比如"Person类"的"名字""年龄"，定义在类中，属于每个Person对象，只要对象没被删，名字和年龄就存在；
• 局部变量：定义在方法内、方法参数、代码块中，属于"当前方法或代码块"------就像你出门时带的充电宝（属于"出门"这个方法），回家后（方法执行完），充电宝就收起来了（变量消失）；
比如"Person类"的"出门"方法中的"地铁卡"，定义在方法内，出门时用，回家后就不用了，方法执行完"地铁卡"变量就消失。
- 访问修饰符："电视能上锁，充电宝不能"
• 成员变量：可以用public、private、protected、默认修饰符，还能加static------就像家里的电视可以设置密码（private），只有家人能看；也可以不设密码（public），谁都能看；
比如"Person类"的"身份证号"用private修饰（只有自己能看），"名字"用public修饰（谁都能看）；
• 局部变量：不能用任何访问修饰符，也不能加static------就像充电宝是临时用的，不能上锁，也不属于"家"（类），只是出门时用，用完就收，不用设权限；
比如"算电费"方法中的"临时变量total"，直接定义"int total = 0;"，不能写"private int total = 0;"，会报错。
- 内存存储位置："电视在客厅，充电宝在包里"
• 成员变量：若用static修饰，存在"方法区的静态区"（属于类，所有对象共享）；若不用static修饰，存在"堆内存"（属于对象）------就像家里的公共Wi-Fi（static），所有家人共享；家里的电视（非static），只属于你家，放在客厅（堆内存）；
• 局部变量：基本数据类型（int、double等）存在"栈内存"（直接存值）；引用数据类型（比如String）的"引用"存在栈内存，对象存在堆内存------就像充电宝里的电量（基本类型）存在包里（栈），充电宝里的充电线（引用类型），线本身（对象）在包里，你手里拿的是线的"头"（引用）。
比如：
• 成员变量"int age = 25;"（非static）：存在堆内存，属于Person对象；
• 局部变量"String cardNo = "123456";"：cardNo的引用存在栈内存，"123456"对象存在常量池（堆的一部分）。
- 生命周期："电视长期在，充电宝临时用"
• 成员变量：static修饰的随"类的加载"存在，随"类的卸载"消失；非static修饰的随"对象的创建"存在，随"对象的回收"消失------就像公共Wi-Fi（static）小区建好就有，拆了才没；家里的电视（非static）你买房就有，卖房就没；
• 局部变量：随"方法的调用"存在，随"方法的结束"消失------就像充电宝（局部变量）你出门时拿，回家后收，方法执行完就不存在了。
比如：
• 成员变量"name"：创建Person对象时存在，对象被删时消失；
• 局部变量"cardNo"：调用"出门"方法时存在，回家后方法结束，"cardNo"消失。
- 默认值："电视买来能开机，充电宝买来要充电"
• 成员变量：会自动赋默认值（int默认0，String默认null，boolean默认false）------就像电视买来插上电就能开机（默认值），不用手动设置；
比如"int num;"（成员变量）：默认值0，直接打印不会报错；
• 局部变量：不会自动赋默认值，必须手动赋值才能用------就像充电宝买来没电（无默认值），必须先充电（赋值）才能用，不然开不了机；
比如"int total;"（局部变量）：直接打印会报错，必须先赋值"total = 100;"。
八、静态变量与实例变量、静态方法与实例方法的区别是什么？用生活例子说明各自的使用场景
静态（static）相关的变量和方法属于"类"，实例相关的属于"对象"，核心区别在"是'所有对象共享'还是'每个对象专属'"------就像"家里的户口本地址"（静态）和"每个人的身份证号"（实例），前者全家共享，后者每人独有。
- 静态变量（类变量）与实例变量（对象变量）
• 静态变量：用static修饰，属于"类"，所有对象共享，内存中只有一个副本------就像家里的户口本地址（静态变量），不管家里有3口人还是5口人（对象），地址只有一个，改一次所有人的户口本地址都变；
比如"Family类"的"address"：static String address = "幸福街1号"; 爸爸、妈妈、孩子（对象）访问的都是同一个地址，改address为"快乐街2号"，所有人的地址都变；
• 实例变量：不用static修饰，属于"对象"，每个对象有独立副本------就像每个人的身份证号（实例变量），爸爸的身份证号是"110101..."，妈妈的是"110102..."，改爸爸的身份证号，妈妈的不变；
比如"Person类"的"idCard"：爸爸的idCard是"110101..."，妈妈的是"110102..."，互不影响。
使用场景：
• 静态变量：存储"类级别的共享数据"，比如"计数器"（统计家里有多少人）、"常量"（比如Math类的PI=3.1415926）、"全局配置"（比如家里的Wi-Fi名称）；
• 实例变量：存储"对象级别的专属数据"，比如"Person类"的"名字""年龄""电话"，每个对象的这些数据都不同。
- 静态方法（类方法）与实例方法（对象方法）
• 静态方法：用static修饰，属于"类"，不用创建对象就能调用（类名.方法名），不能访问实例变量和实例方法------就像查家里的户口本地址（静态方法），不用找具体某个人，直接翻户口本（类名.方法名）就能看，不能查"爸爸的身份证号"（实例变量）；
比如"Family类"的"getAddress()"：static String getAddress() { return address; } 不用创建Family对象，直接Family.getAddress()就能查地址；
• 实例方法：不用static修饰，属于"对象"，必须创建对象才能调用（对象名.方法名），可以访问实例变量和静态变量------就像查爸爸的身份证号（实例方法），必须找到爸爸（对象），才能看他的身份证号（实例变量），也能看家里的户口本地址（静态变量）；
比如"Person类"的"getIdCard()"：String getIdCard() { return idCard; } 必须创建爸爸对象，爸爸.getIdCard()才能查。
使用场景：
• 静态方法：提供"类级别的工具功能"，比如"计算工具"的"求和"方法（Family.calculateSum(1,2,3)）、"打印工具"的"打印日志"方法（Log.print("信息")）；
• 实例方法：提供"对象级别的专属功能"，比如"Person类"的"吃饭""睡觉"、"Car类"的"启动""刹车"，每个对象执行这些方法时，操作的是自己的属性（比如Car对象启动时，用的是自己的油量）。
核心区别总结
• 静态的"属于类"，实例的"属于对象"；
• 静态的不用创建对象就能用，实例的必须创建对象；
• 静态的不能访问实例的东西，实例的能访问静态的东西。
九、final 关键字有什么作用？用生活例子说明每种作用的含义，以及"引用不可变"和"内容不可变"的区别
final 关键字的意思是"不可变"，可修饰"类、方法、变量"，核心是"一旦确定，就不能改"------就像"身份证号"（final变量），一旦生成就不能改；"太阳"（final类），不能有"小太阳"继承；"人用鼻子呼吸"（final方法），不能改成用皮肤呼吸。
- 修饰类："这个类不能有'孩子'"
• 作用：被final修饰的类不能被继承，没有子类；
• 生活例子："太阳"是final类，不能有子类"小太阳"------因为太阳只有一个，没有"后代"能继承它的"发光、发热"属性；
• 使用场景：修饰"功能完整、不需要扩展的类"，比如Java的String类（final类），它的功能已经很完善（拼接、截取字符串），不需要子类扩展，避免子类修改其核心逻辑导致混乱。
- 修饰方法："这个方法的步骤不能改"
• 作用：被final修饰的方法不能被子类重写，步骤定死了；
• 生活例子："人用鼻子呼吸"是final方法，子类"中国人""美国人"不能重写------不能改成"用皮肤呼吸"，必须用鼻子呼吸；
• 使用场景：修饰"核心方法，逻辑不能改"，比如"银行类"的"计算利息"方法（按"利息=本金×利率×时间"计算）、"加密类"的"MD5加密"方法（固定算法），子类不能改这些逻辑，保证业务安全。
- 修饰变量："这个变量的'引用'不能改，但'内容'可能能改"
• 作用：被final修饰的变量必须显式赋值（声明时或构造方法中），且"引用不能改"（不能指向新对象），但"引用指向的内容可能能改"；
• 生活例子：你的身份证号是final变量------身份证号（引用）不能改（不能换成别人的身份证号），但身份证上的地址（内容）能改（搬家后去派出所更新）；
• 使用场景：修饰"值不能变的变量"，比如"常量"（PI=3.1415926）、"对象的固定引用"（比如"用户的唯一ID"，不能改ID，但能改用户的姓名）。
关键区别："引用不可变" vs "内容不可变"
• 引用不可变：final变量不能指向新对象，就像你不能把"你的身份证"换成"别人的身份证"（引用变了）；
• 内容不可变：引用指向的对象内部属性可以改，就像你能改身份证上的地址（内容变了），但身份证号（引用）不变。
比如：
• 你有一个final修饰的"笔记本"（引用），不能换成"新笔记本"（引用不可变），但你可以在笔记本上写新内容（内容可变）；
• 你有一个final修饰的"水果篮"（引用），不能换成"新水果篮"（引用不可变），但你可以往篮子里加新水果（内容可变）。
如果想让"内容也不可变"，可以用不可变类，比如String------你有一个final String"hello"，既不能换成"world"（引用不可变），也不能在"hello"后面加"world"变成"hello world"（内容不可变）。
十、final、finally、finalize 的区别是什么？用生活例子说明各自的使用场景
这三个词长得像，但作用完全不同------final是"定死不变"，finally是"必须做"，finalize是"最后处理"，就像"身份证号（final）、吃完饭洗碗（finally）、扔旧衣服前掏口袋（finalize）"。
- final："定死了，不能改"
• 作用：修饰类、方法、变量，分别表示"类不能继承、方法不能重写、变量引用不能改"；
• 生活例子：你的身份证号（final变量），一旦生成就不能改；"地球"（final类），不能有子类；"人用嘴巴吃饭"（final方法），不能改成用鼻子吃饭；
• 使用场景：见第九点，核心是"固定不变的内容"，比如常量、核心类、核心方法。
- finally："不管怎样，都要做的事"
• 作用：属于异常处理的一部分，只能在try/catch语句中，finally块中的代码"无论try块是否报错、是否执行return"，都会执行（除非JVM退出）；
• 生活例子：你做饭（try块）------不管饭做成功了（try正常执行）、做糊了（报错）、中途接电话要出门（return），最后都要洗碗（finally块），不能把碗留着；
• 使用场景："释放资源"，比如关闭文件、关闭数据库连接、拔充电器------就算用电脑传文件时报错，也要拔掉U盘（释放资源），不然U盘会损坏。
- finalize："扔东西前，最后整理"
• 作用：是Object类的方法，当对象被垃圾回收器（GC）回收前，会调用该对象的finalize()方法，用于"释放特殊资源"（比如通过特殊方式申请的内存）；
• 生活例子：你扔旧书包（对象被回收）前，会最后掏一下书包口袋（finalize()）------把里面的纸巾、硬币拿出来（释放资源），再扔进垃圾桶；
• 使用场景：几乎不用！因为finalize()的执行时机不确定（不知道GC什么时候回收），且一个对象的finalize()只能被调用一次------比如你掏过一次书包，就算捡回来，也不会再掏第二次，可能漏东西。
核心区别总结
• final是"修饰符"，定死不变；
• finally是"异常处理关键字"，必须执行；
• finalize是"Object类的方法"，回收前处理，不推荐用。
十一、== 和 equals 的区别是什么？用生活例子说明"地址比较"和"内容比较"的差异，以及重写 equals 的注意事项
== 和 equals 都是"判断'相等'的工具"，但核心区别在"比较'地址'还是'内容'"------就像比较"两个苹果"，== 看是不是"同一个苹果"，equals 看是不是"一样大、一样红的苹果"。
- ==："看是不是同一个东西（地址比较）"
• 作用：
◦ 比较基本数据类型（int、double等）：比较"值"是否相等，因为基本数据类型没有"地址"，直接存值------就像比较"两个苹果的重量"，都是100g就相等；
◦ 比较引用数据类型（String、对象等）：比较"内存地址"是否相等，即"是不是同一个对象"------就像比较"两个苹果是不是从同一棵树上摘的"（地址相同），是就相等，不是就不相等；
• 生活例子：你有一个苹果A（长在1号树，地址0x123），朋友有一个苹果B：
◦ 若B是A的"分身"（和A长在同一棵树，地址0x123），则A==B为true；
◦ 若B是2号树的苹果（地址0x456），就算和A一样大、一样红，A==B也为false；
- equals："看内容是不是一样（内容比较）"
• 作用：
◦ 默认情况（未重写equals）：和==一样，比较引用数据类型的"地址"------就像你默认"只有同一棵树的苹果才一样"，不看大小；
◦ 重写后（自定义equals）：比较"对象的内容"是否相等------就像你自定义"苹果相等"的标准："只要大小和颜色相同，就算来自不同树，也相等"；
• 生活例子：你定义"苹果相等"的标准是"重量100g、红色"：
◦ 苹果A（100g、红色，地址0x123）；
◦ 苹果B（100g、红色，地址0x456）；
◦ 重写equals后，A.equals(B)为true（内容相等）；
- 重写 equals 的注意事项（必须遵守5个规范）
• 自反性：对象自己和自己比，equals返回true------就像苹果A和自己比，肯定相等；
• 对称性：若A.equals(B)为true，则B.equals(A)也为true------就像A和B相等，B和A也得相等；
• 传递性：若A.equals(B)为true，B.equals(C)为true，则A.equals(C)也为true------就像A和B相等，B和C相等，A和C也得相等；
• 一致性：若A和B的内容没改，多次比结果不变------就像A和B一直是100g、红色，不管比多少次，都相等；
• 非空性：A.equals(null)必须为false------就像苹果A和"没有苹果"（null）比，肯定不相等。
如果不遵守这些规范，会导致集合（比如HashSet）出错，比如把A和B都放进HashSet，HashSet会认为它们不相等，存两个相同的苹果。
十二、hashCode 与 equals 的关系是什么？为什么重写 equals 时必须重写 hashCode？用生活例子说明"哈希碰撞"的含义
hashCode 和 equals 是一对"搭档"，都用于"判断对象是否相等"，但分工不同：hashCode 是"快速找对象"，equals 是"精确判相等"------就像快递，hashCode 是"快递单号"，用于快速找货架；equals 是"收件人信息"，用于确认是不是你的快递。
- 什么是 hashCode？
hashCode 是 Object 类的方法，返回一个 int 整数（哈希码），作用是"给对象分配一个'编号'，用于哈希表（HashMap、HashSet）快速定位对象"------就像快递单号，每个快递（对象）有一个单号（hashCode），快递员根据单号快速找货架，不用一个个翻。
- hashCode 与 equals 的核心关系（Java 规范）
• 规范1：若两个对象的 equals 为 true（内容相等），则 hashCode 必须相等------就像两个快递的收件人相同（equals=true），单号（hashCode）必须相同，不然快递员会放错货架；
• 规范2：若两个对象的 hashCode 相等，equals 不一定为 true（哈希碰撞）------就像两个快递单号相同，但收件人不同；
• 规范3：若 equals 为 false，hashCode 可相等可不等------就像两个快递收件人不同，单号可相同可不同。
- 为什么重写 equals 必须重写 hashCode？
如果只重写 equals 不重写 hashCode，会违反规范1，导致哈希表出错------就像你给两个收件人相同的快递填不同单号，快递员会放不同货架，你以为没收到快递（实际在另一个货架）。
比如：
• 你有两个"红色、100g的苹果"（equals=true），但它们的 hashCode 不同（默认按地址算）；
• 把第一个苹果放进 HashSet，再放第二个：HashSet 认为它们 hashCode 不同，是两个对象，会存两个相同的苹果，违反"不存重复"规则；
• 重写 hashCode 后，两个苹果的 hashCode 相同，HashSet 会用 equals 判相等，认为是重复对象，不存储，符合规则。
- 什么是哈希碰撞？
哈希碰撞是"两个不同对象的 hashCode 相等"------就像两个不同的快递（收件人不同），单号却相同，是哈希算法的正常现象（因为 hashCode 是 int 类型，只有 2^32 个值，对象无限多，总会重复）。
生活例子：快递单号是"6位数字"，最多100万个单号，但有200万个快递，肯定有两个快递单号相同，这就是碰撞。
哈希表如何处理碰撞？比如 HashMap 会在"同一个货架"上挂"链表"，把 hashCode 相等的对象存链表；取对象时，先找货架，再遍历链表用 equals 找具体对象------就像快递员发现同一个单号有两个快递，会按收件人信息逐个确认。
- 总结
• equals 是"精确判相等"，hashCode 是"快速找对象"；
• 重写 equals 必须重写 hashCode，否则哈希表出错；
• 哈希碰撞不可避免，但算法会尽量减少（比如打乱 hashCode，让编号更分散）。
十三、Java 是值传递还是引用传递？用生活例子说明"值传递"的本质，以及引用类型的值传递为何"内容能改，引用不能改"
Java 只有值传递，没有引用传递------核心是"方法调用时，传递的是参数的'副本'（值），不是'参数本身'"，就算是引用类型，传递的也是"引用的副本"。
- 什么是值传递？
值传递是"方法调用时，传递的是参数的'副本'，方法内改副本，不影响原参数"------就像你把作业（原参数）复印一份（副本）给朋友，朋友在副本上改答案（方法内修改），你的原作业（原参数）不变。
- 基本类型的 值传递："副本是值的拷贝"
• 生活例子：你有5元钱（原参数a=5），把"5元"这个数字告诉朋友（传递副本"5"），朋友说"我把这个数字改成10"（改副本），但你的5元钱（原参数a）还是5元------朋友改的是"数字副本"，不是你的钱；
- 引用类型的 值传递："副本是引用的拷贝，指向同一个对象"
• 生活例子：你家的地址是"幸福街1号"（原引用person，指向堆中的对象），你把地址告诉朋友（传递引用副本"幸福街1号"）：
-
朋友去"幸福街1号"（副本指向的对象），把你家的灯换成新的（改对象内容）：你回家看到灯变了（原对象内容改了）------因为副本和原引用指向同一个家；
-
朋友说"我现在去'快乐街2号'"（改副本引用，指向新地址）：你家的地址（原引用）还是"幸福街1号"，朋友在新地址换灯（改新对象），和你家无关；
-
为什么说 Java 没有引用传递？
引用传递是"传递引用本身，方法内改引用会影响原引用"------就像你把家门钥匙（原引用）给朋友，朋友把钥匙改成"快乐街2号"的（改原引用），你回家打不开门。但 Java 传递的是"钥匙复印件"（副本），朋友改复印件地址，你的原钥匙不变，所以没有引用传递。
十四、深拷贝和浅拷贝的区别是什么？用生活例子说明两种拷贝的实现逻辑，以及各自的适用场景
深拷贝和浅拷贝都是"复制对象的方式"，核心区别在"是否'完全复制'引用类型的属性"------就像"复制一份家庭相册"，浅拷贝是"复印相册，照片是链接"，深拷贝是"重画相册，照片也重画"。
- 浅拷贝："只复制表面，引用类型还是同一个"
• 定义：仅复制对象的"基本类型属性"（值的拷贝）和"引用类型属性"（地址的拷贝），引用类型指向的对象不变------就像你复印家庭相册：
◦ 相册上的文字（基本类型，比如"2023年全家福"）是复印的（值拷贝），改复印的文字，原相册不变；
◦ 相册里的照片（引用类型）是"链接"，复印的相册还是指向原照片------改复印相册里的照片（比如涂鸦），原相册的照片也会变；
• 适用场景：引用类型属性"不需要修改"，或"所有拷贝对象共享引用属性"------比如"班级相册"，多个同学共享同一组照片（改一张照片，所有人的相册都同步），用浅拷贝节省内存；
- 深拷贝："完全复制，引用类型也换新的"
• 定义：不仅复制基本类型属性，还复制"引用类型属性指向的对象"，生成新的引用对象------就像你重画家庭相册：
◦ 相册上的文字（基本类型）重新写（值拷贝），改新文字，原相册不变；
◦ 相册里的照片（引用类型）也重新画（复制原照片，生成新照片），改新照片，原照片不变；
• 适用场景：引用类型属性"需要独立修改"，不影响原对象------比如"个人相册"，你加自己的照片，不想影响别人的相册，用深拷贝保证独立。
十五、Java 创建对象有哪几种方式？用生活例子说明每种方式的实现逻辑，以及各自的特点
Java 创建对象有四种核心方式，区别在"是'直接拿'还是'间接生成'"------就像"获取饮料"，有的直接买，有的自己做，有的分一半，有的解冻之前冻的。
- new 关键字："直接买现成的饮料"
• 方式：用"new 类名(参数)"创建对象，调用构造方法------就像你去超市买可乐，店员按你的要求拿现成的，直接就能喝；
• 特点：最常用、最简单，编译时就知道要创建哪个类的对象，必须调用构造方法；
• 适用场景：明确知道要创建的类，且需要传参数初始化------比如创建"学生对象"，传姓名"小美"、学号"2023002"；
- 反射机制："按配方自己做饮料"
• 方式：通过 Class 类获取类的信息（比如构造方法），调用 Constructor 的方法创建对象------就像你没有现成的可乐，按配方自己做，需要知道"可乐的成分"；
• 特点：运行时才知道要创建哪个类的对象，灵活但效率低，必须调用构造方法；
• 适用场景：动态创建对象，比如框架根据配置文件创建对象------不知道配置文件里写的是"可乐"还是"果汁"，运行时读配置再创建；
- clone 方法："把饮料分一半给朋友"
• 方式：让类实现 Cloneable 接口，重写 clone() 方法，调用对象的 clone() 生成拷贝对象------就像你有一瓶可乐，把它分一半给朋友，朋友的可乐和你的成分一样；
• 特点：创建的是"拷贝对象"，不用调用构造方法，默认是浅拷贝（需重写实现深拷贝）；
• 适用场景：需要"和原对象属性相同"的对象，且不想调用构造方法------比如原对象已经初始化好（比如可乐已经加了冰），直接拷贝更方便；
- 序列化："把冻在冰箱的饮料解冻"
• 方式：让类实现 Serializable 接口，将对象转成字节流（冻起来），再反序列化成新对象（解冻）------就像你把可乐冻在冰箱，想喝时解冻，得到和原可乐一样的新可乐；
• 特点：能实现深拷贝，常用于网络传输、持久化存储，不用调用构造方法；
• 适用场景：对象需要网络传输（比如给朋友发可乐的"电子版"）、持久化存储（比如把可乐的信息存到文件）。