Java 是纯面向对象编程语言，万物皆对象，除了八大基本数据类型，核心思想是 “用对象封装功能、靠关系复用代码”
一、理解类、对象、引用
面向对象的核心是 “类” 和 “对象”，就像 “图纸” 和 “实物” 的关系，而 “引用” 是连接两者的 “桥梁”。
1. 类 —— 事物的 “设计图纸”
- 通俗理解：定义某类事物的 “共同属性” 和 “能做的事”。比如 “手机类”，属性是品牌、价格、内存；能做的事是打电话、发微信。
- Java 语法：用 class 关键字定义，包含「成员变量（属性）」和「成员方法（功能）」。
2. 对象 —— 图纸造出来的 “实物”
- 通俗理解：类的具体实例。比如 “我的华为手机”“你的苹果手机”，都是 “手机类” 造出来的具体对象，有自己的属性值（华为、3999 元、128GB）。
- Java 语法：用 new 关键字创建对象（“造实物”），格式：类名 对象名 = new 类名();
3. 引用 —— 对象的 “遥控器”
- 通俗理解：Java 中不能直接操作对象，只能通过 “引用”（比如上面的 myPhone）来访问对象的属性和方法。就像你不用直接拆电视，用遥控器（引用）就能操作电视（对象）。
- 关键细节：
- 引用存的是对象在内存中的 “地址”，不是对象本身；
- 一个对象可以被多个引用指向（比如两个遥控器控制同一台电视）；
- 引用可以为 null（遥控器没对准任何电视），此时调用方法会报 NullPointerException（空指针异常）。
二、面向对象三大核心特征
这是 OOP 的灵魂，面试和开发都离不开，用 “手机生产”“动物喂养” 等例子讲透。
1. 封装 —— “黑盒子” 设计
核心思想：隐藏内部细节，只暴露安全的访问接口
- 生活例子：手机的内部电路板（细节）被外壳包住，你不用知道电路怎么接，只需要按屏幕、按键（接口）就能用，既安全又方便。
- Java 实现方式：
- 用 private 关键字修饰成员变量（隐藏属性，不让外部直接修改）；
- 提供 public 的 getter（获取属性值）和 setter（修改属性值）方法（暴露接口）；
- 可以在 setter 里加逻辑校验（比如价格不能为负数）。
代码示例（封装后的 Phone 类）：
封装的好处：
- 安全性：防止外部随意修改属性（比如价格不会是负数）；
- 易维护：修改内部逻辑（比如校验规则）时，不用改外部代码；
- 简洁性：外部不用关心内部实现，只需要用接口。
2. 继承 —— “子承父业 + 自主创新”
核心思想：子类继承父类的属性和方法，减少重复代码，同时可以添加自己的特性
- 生活例子：“智能手机” 是 “手机” 的子类，继承了手机 “打电话、发短信” 的功能，还新增了 “玩游戏、刷视频” 的功能；“老人机” 也是 “手机” 的子类，继承了基础功能，但没有游戏功能。
- Java 语法：
- 用 extends 关键字表示继承：子类名 extends 父类名；
- 父类（超类）：被继承的类（比如 Phone）；子类（派生类）：继承父类的类（比如 SmartPhone）；
- Java 只能 “单继承”（一个子类只能有一个直接父类），但可以通过 “接口” 实现多继承的效果。
代码示例（继承的实现）：
继承的关键细节：
- 访问父类的成员变量 / 方法：super.属性名、super.方法名()；
- 调用父类的构造方法：super(参数)，必须写在子类构造方法的第一行；
3. 多态 —— “一个接口，多种表现”
核心思想：同一操作作用于不同对象，产生不同的结果（比如 “吃饭”，猫吃鱼、狗吃粮、人吃米饭）
- 生活例子：“充电” 这个操作，给手机充电用手机充电器，给电脑充电用电脑充电器，给耳机充电用耳机充电器 —— 同一个 “充电” 行为，不同设备（对象）有不同的实现。
- Java 实现条件：
- 有继承关系（子类 extends 父类）；
- 子类重写父类的方法；
- 父类引用指向子类对象（向上转型）：父类名 引用名 = new 子类名();
代码示例（多态的实现）：
三、Java 中易混淆的核心概念（面试坑点）
1. 方法重写 VS 方法重载
这是最常考的区别，用 “点餐”“开车” 例子区分：
| 核心定义 | 子类覆盖父类的方法 | 同一个类中 同名不同参的方法 |
| 存在位置 | 父子类之间 | 同一个类中（或子类继承父类后新增重载） |
| 方法名 | 必须相同 | 必须相同 |
| 参数列表 |
必须完全相同（个数 类型 顺序） |
必须不同（个数、类型、顺序任一不同 |
| 返回值类型 | 子类返回值可以是父类返回值的子类（协变返回） | 可以不同（与返回值无关） |
| 访问权限 | 子类权限不能比父类更严谨（父类public 子类不能private） | 无限制 |
| 注释 | 可用@Overide校验 |
无专门注解 |
代码示例：
2. 抽象类 VS 接口
两者都是 “规范”，用于定义 “必须做什么”，但适用场景不同，用 “模板” 和 “标准” 区分：
| 定义关键字 | abstract class | interface |
| 核心作用 | 作为子类的 “模板”（有部分实现） | 作为 “标准 / 契约”（纯规范，无实现） |
| 成员方法 | 可以有普通方法、抽象方法（abstract 修饰，无方法体） | Java 8+ 可有默认方法（default）、静态方法（static），其余都是抽象方法（默认 public abstract） |
| 成员变量 | 可以是普通变量（public/private/protected） | 只能是常量（默认 public static final），必须初始化 |
| 继承 / 实现方式 | 子类用 extends 继承（单继承） | 类用 implements 实现（可多实现） |
| 实例化 | 不能直接实例化（不能 new） | 不能直接实例化 |
| 适用场景 | 子类有共同的属性和方法实现（比如 “图形” 类，有共同的 “计算面积” 抽象方法，也有 “显示颜色” 普通方法） | 不同类有相同的行为规范（比如 “可充电” 接口，手机、电脑、耳机都能实现） |
代码示例：
3. this 关键字 VS super 关键字
两者都是用于访问 “当前对象” 或 “父类对象” 的成员，区别如下
| this | 当前对象 |
1. 区分成员变量和局部变量（this.变量名） 2. 调用当前对象的其他方法（this.方法名()） 3. 调用当前类的其他构造方法（this(参数)，必须在第一行） |
| super | 父类对象 |
1. 访问父类的成员变量（super.变量名） 2. 调用父类的方法（super.方法名()） 3. 调用父类的构造方法（super(参数)，必须在子类构造方法第一行 |
代码示例：
四、Java 面向对象进阶知识点
1. 构造方法:对象的 “初始化工具”
- 作用：创建对象时初始化对象的属性（比如给成员变量赋默认值）；
- 语法规则：
- 方法名必须和类名完全相同；
- 没有返回值类型（连 void 都不能写）；
- 可以重载（多个构造方法，参数不同）；
- 如果类中没有显式定义构造方法，Java 会自动生成一个 “无参构造”；
- 如果类中定义了构造方法，Java 不会再自动生成无参构造（建议手动写一个，避免报错）。
代码示例：
2. 静态成员:类的 “共享资源”
- 通俗理解：属于 “类” 本身，不是某个对象的，所有对象共享。比如 “学生类” 的 “学校名称”，所有学生的学校都是同一个，就可以设为静态变量。
- 语法规则：
- 用 static 修饰成员变量（静态变量）或成员方法（静态方法）；
- 访问方式：类名.静态变量 或 类名.静态方法()（推荐），也可以用对象访问，但不规范；
- 静态方法中不能访问非静态成员（非静态成员属于对象，静态成员属于类，类加载时对象还没创建）；
- 静态方法中不能用 this 和 super 关键字。
代码示例：
3. 访问修饰符:代码的 “安全边界”
Java 有 4 种访问修饰符，用于控制类、成员变量、方法的访问范围，从宽到严：
| public | ✅ | ✅ | ✅ | ✅ |
| protected | ✅ | ✅ | ✅ | ❌ |
| 默认（无修饰） | ✅ | ✅ | ❌ | ❌ |
| private | ✅ | ❌ | ❌ | ❌ |
常用场景：
- 成员变量：用 private（封装）；
- 成员方法：用 public（对外提供接口）；
- 子类需要访问的父类成员：用 protected；
- 同包内共享的成员：用默认修饰符。
4. 包和 import:代码的 “文件夹”
- 包的作用：组织代码（避免类名冲突），比如 java.util.ArrayList 和 java.sql.ArrayList 是不同包的类，不会冲突；
- 定义包：用 package 关键字（必须写在 Java 文件第一行），格式：package 包名;（比如 package com.example;）；
- 导入类：用 import 关键字导入其他包的类，避免写全类名，格式：import 包名.类名;（比如 import java.util.ArrayList;）；
- 静态导入：导入类的静态成员，格式：import static 包名.类名.静态成员;（比如 import static java.lang.Math.PI;，之后可以直接用 PI 代替 Math.PI）。
五、常见题
1.Java 为什么是纯面向对象？
答：Java 中除了八大基本数据类型（byte、short、int、long、float、double、char、boolean），其余都是对象；所有类都默认继承 Object 类（根类）；核心特性（封装、继承、多态）贯穿始终。
2.Object 类有哪些常用方法？
答：equals()（比较对象是否相等）、hashCode()（返回对象哈希值）、toString()（返回对象字符串表示）、getClass()（获取对象的类）、notify()/wait()（线程通信）等。
3.== 和 equals() 的区别？
答：== 比较的是 “值”：基本类型比较数值，引用类型比较内存地址；equals() 是 Object 类的方法，默认和 == 一样（比较地址），但很多类（比如 String、Integer）重写了 equals()，改为比较内容（比如 String s1="a"; String s2="a"; s1.equals(s2) 返回 true）。
4.抽象类和接口的选择场景？
答：如果子类有共同的属性和方法实现，用抽象类；如果只是定义行为规范（不同类有不同实现），用接口；Java 8+ 接口有默认方法，可替代部分抽象类的场景，但接口不能有普通成员变量。
5.多态的好处是什么？
答：① 简化代码（比如一个方法接收父类类型，所有子类都能传入）；② 提高扩展性（新增子类不需要修改原有代码）；③ 降低耦合度（不依赖具体子类，只依赖父类规范）。
总结
Java 面向对象的核心是 “用类定义规范，用对象实现功能，用三大特征（封装、继承、多态）优化代码”：
- 封装：隐藏细节，安全易用；
- 继承：复用代码，减少冗余；
- 多态：灵活扩展，简化逻辑。
