Java面向对象：购物车系统完整版+全系列考点复盘

🏠个人主页：黎雁

🎬作者简介：C/C++/JAVA后端开发学习者

❄️个人专栏：C语言、数据结构（C语言）、EasyX、JAVA、游戏、规划、程序人生

✨ 从来绝巘须孤往，万里同尘即玉京

文章目录

[✨Java面向对象精讲（六）：综合实战收官｜购物车系统完整版+全系列考点复盘夯实基础闭环 ✅](#✨Java面向对象精讲（六）：综合实战收官｜购物车系统完整版+全系列考点复盘夯实基础闭环 ✅)
- [📌 文章摘要（245字）](#📌 文章摘要（245字）)
- - [🕒 阅读时长：约25分钟](#🕒 阅读时长：约25分钟)
  - [✅ 适用人群 & 阅读重点](#✅ 适用人群 & 阅读重点)
- [📖 知识回顾](#📖 知识回顾)
- [一、实战前置：购物车系统业务分析 🛒 从场景到代码](#一、实战前置：购物车系统业务分析 🛒 从场景到代码)
- - [1.1 核心业务场景（贴合电商实际）](#1.1 核心业务场景（贴合电商实际）)
  - [1.2 类的设计思路（面向对象核心：职责划分）](#1.2 类的设计思路（面向对象核心：职责划分）)
  - - [✔ 类1：Goods（商品类）- 纯实体类](#✔ 类1：Goods（商品类）- 纯实体类)
    - [✔ 类2：CartItem（购物车项类）- 关联实体类](#✔ 类2：CartItem（购物车项类）- 关联实体类)
    - [✔ 类3：ShoppingCart（购物车主类）- 业务逻辑类](#✔ 类3：ShoppingCart（购物车主类）- 业务逻辑类)
    - [✔ 类4：CartTest（测试类）- 控制台交互类](#✔ 类4：CartTest（测试类）- 控制台交互类)
  - [1.3 核心技术点（全系列知识点融合）](#1.3 核心技术点（全系列知识点融合）)
- [二、终极综合实战 🛒 购物车系统完整实现](#二、终极综合实战 🛒 购物车系统完整实现)
- - [2.1 类1：Goods.java（商品类，标准JavaBean）](#2.1 类1：Goods.java（商品类，标准JavaBean）)
  - [2.2 类2：CartItem.java（购物车项类，关联实体）](#2.2 类2：CartItem.java（购物车项类，关联实体）)
  - [2.3 类3：ShoppingCart.java（购物车主类，业务逻辑封装）](#2.3 类3：ShoppingCart.java（购物车主类，业务逻辑封装）)
  - [2.4 类4：CartTest.java（测试类，控制台交互）](#2.4 类4：CartTest.java（测试类，控制台交互）)
  - [2.5 运行结果（验证业务有效性）](#2.5 运行结果（验证业务有效性）)
  - [2.6 案例核心考点提炼（必记）](#2.6 案例核心考点提炼（必记）)
  - - [✅ 考点1：对象作为成员变量](#✅ 考点1：对象作为成员变量)
    - [✅ 考点2：自定义变量管理有效数据](#✅ 考点2：自定义变量管理有效数据)
    - [✅ 考点3：私有方法封装](#✅ 考点3：私有方法封装)
    - [✅ 考点4：业务健壮性设计](#✅ 考点4：业务健壮性设计)
    - [✅ 考点5：数组扩容优化](#✅ 考点5：数组扩容优化)
    - [✅ 考点6：单一职责原则](#✅ 考点6：单一职责原则)
- [三、全系列核心知识点复盘 📚 构建知识框架](#三、全系列核心知识点复盘 📚 构建知识框架)
- - [3.1 核心知识体系（必背）](#3.1 核心知识体系（必背）)
- [四、笔试高频易错点避坑指南 ❌ 零失分必备](#四、笔试高频易错点避坑指南 ❌ 零失分必备)
- - [4.1 语法类易错点](#4.1 语法类易错点)
  - [4.2 思想类易错点](#4.2 思想类易错点)
  - [4.3 实战类易错点](#4.3 实战类易错点)
- [✍️ 写在最后（系列收官，展望进阶）](#✍️ 写在最后（系列收官，展望进阶）)
- - [🌟 后续学习展望](#🌟 后续学习展望)
- [📌 系列回顾](#📌 系列回顾)

✨Java面向对象精讲（六）：综合实战收官｜购物车系统完整版+全系列考点复盘夯实基础闭环 ✅

📌 文章摘要（245字）

本文是Java面向对象系列第六篇·综合实战收官篇 ，融合前五篇类与对象、封装、构造方法、对象数组基础/进阶、增删改查等核心知识点，以电商购物车系统（控制台版） 为终极实战案例，实现商品定义、购物车增删改查、结算总价的完整业务逻辑。全文拆解需求分析、类设计、逻辑封装与代码实现，同步复盘全系列核心考点、笔试高频易错点，帮你构建完整知识框架。内容贴合实际业务、代码规范可复用、注释详尽，零基础能完成项目开发，在校生可夯实笔试基础，入门者能形成面向对象编程思维，助力吃透面向对象基础阶段所有内容，实现知识闭环。

🕒 阅读时长：约25分钟

✅ 适用人群 & 阅读重点

▫️ Java零基础入门者 ：重点看购物车系统需求分析、代码分步实现与注释，跟着敲写完整项目，建立综合编程思维。

▫️ 在校学生/备考者 ：聚焦全系列考点复盘、易错点总结 ，牢记核心定义与避坑技巧，应对单元测/期末考。

▫️ 开发入门者 ：关注类的职责划分、业务逻辑封装，学会将真实业务转化为代码，提升项目实战能力。

▫️ 系列知识点薄弱者 ：重点看核心知识点速记，快速查漏补缺，打通面向对象思维闭环。

▫️ 复习巩固者：直接看实战考点提炼+全系列复盘，复刻核心内容，夯实基础。

📖 知识回顾

历经Java面向对象系列前五篇学习，我们从零基础入门到综合实战，完成面向对象基础阶段完整进阶，吃透核心技能：

✔ 基础层：理解"找对象做事情"核心思想，掌握类与对象的设计、创建与调用，区分成员变量与局部变量；
✔ 进阶层：吃透封装思想、this关键字、构造方法，能编写符合规范的标准JavaBean类；
✔ 实战层：掌握对象数组基础（初始化、存储、遍历）与进阶（增删改查、扩容、唯一性校验），理解方法封装复用思想；
✔ 能力层：独立完成格斗游戏、汽车录入、学生管理等案例，实现单知识点到多知识点综合应用的跨越。

本篇作为收官之作，将通过购物车系统落地全知识点，同时全面复盘、梳理考点，帮你形成完整知识框架。

一、实战前置：购物车系统业务分析 🛒 从场景到代码

1.1 核心业务场景（贴合电商实际）

控制台版购物车系统，模拟用户购物核心流程，覆盖商品管理、购物车操作、结算三大环节，需求如下：

定义商品类：含商品编号（id，唯一标识）、名称、单价，遵循标准JavaBean规范；
定义购物车项类：关联商品与购买数量，体现对象关联关系；
购物车核心操作：添加商品（已存在则累加数量）、修改数量（为0则删除）、删除商品、查看购物车、结算总价；
控制台交互：通过指令模拟用户操作，直观展示每步结果。

1.2 类的设计思路（面向对象核心：职责划分）

打破单一类编写思维，通过三个类分工关联，贴合企业开发思想，每个类仅负责对应职责：

✔ 类1：Goods（商品类）- 纯实体类

职责：封装商品属性，作为购物车基础数据，遵循标准JavaBean规范；
核心：商品id为唯一标识，用于精准匹配操作。

✔ 类2：CartItem（购物车项类）- 关联实体类

职责：封装单个商品购买信息，关联商品对象与购买数量；
核心：包含Goods类型成员变量，体现对象关联关系，提供小计金额计算方法（单价×数量）。

✔ 类3：ShoppingCart（购物车主类）- 业务逻辑类

职责：封装购物车所有核心操作（增删改查、结算），含购物车项数组成员变量；
核心：整合业务逻辑，对外提供统一操作方法，实现逻辑与交互分离。

✔ 类4：CartTest（测试类）- 控制台交互类

职责：程序入口，模拟用户操作，调用ShoppingCart方法，实现业务逻辑与用户交互解耦。

1.3 核心技术点（全系列知识点融合）

本案例覆盖前五篇所有高频考点，一次吃透：

标准JavaBean类编写（Goods、CartItem）；
对象作为成员变量的应用（CartItem关联Goods）；
对象数组进阶应用（购物车项数组增删改查、扩容）；
方法封装与复用（私有工具方法+公有业务方法）；
业务逻辑闭环（添加→修改→删除→查看→结算）；
空指针、边界值规避（数量校验、非空判断）。

二、终极综合实战 🛒 购物车系统完整实现

2.1 类1：Goods.java（商品类，标准JavaBean）

java 复制代码

/**
 * 商品类 - 严格遵循标准JavaBean规范
 * 属性：商品编号（id，唯一标识）、名称、单价（私有封装）
 * 提供：空参/带参构造、全套get/set方法
 */
public class Goods {
    private String id;   // 商品编号（唯一标识）
    private String name; // 商品名称
    private double price;// 商品单价

    // 空参构造
    public Goods() {
    }

    // 带参构造，快速初始化商品属性
    public Goods(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    // 全套get/set方法
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

2.2 类2：CartItem.java（购物车项类，关联实体）

java 复制代码

/**
 * 购物车项类 - 关联商品与购买数量
 * 核心：包含Goods对象作为成员变量，体现对象关联关系
 * 提供：小计金额计算方法、get/set方法
 */
public class CartItem {
    private Goods goods; // 关联商品对象
    private int num;     // 购买数量

    // 空参构造
    public CartItem() {
    }

    // 带参构造
    public CartItem(Goods goods, int num) {
        this.goods = goods;
        this.num = num;
    }

    // 核心方法：计算当前购物车项小计（单价×数量）
    public double getSubTotal() {
        return goods.getPrice() * num;
    }

    // 全套get/set方法
    public Goods getGoods() {
        return goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

2.3 类3：ShoppingCart.java（购物车主类，业务逻辑封装）

java 复制代码

/**
 * 购物车主类 - 封装所有核心业务操作
 * 包含：购物车项数组、索引查找、添加、修改、删除、查看、结算方法
 * 核心：方法封装复用，对外提供统一操作入口
 */
public class ShoppingCart {
    // 购物车项数组，存储所有商品项
    private CartItem[] cartItems;
    // 有效商品项数量，简化遍历与扩容
    private int size;

    // 构造方法：初始化购物车项数组，默认长度5
    public ShoppingCart() {
        cartItems = new CartItem[5];
        size = 0;
    }

    // 私有方法1：根据商品编号找购物车项索引，存在返回索引，否则返回-1
    private int getIndex(String goodsId) {
        for (int i = 0; i < size; i++) {
            CartItem item = cartItems[i];
            if (item.getGoods().getId().equals(goodsId)) {
                return i;
            }
        }
        return -1;
    }

    // 私有方法2：数组扩容，长度+3（避免频繁扩容）
    private void expand() {
        CartItem[] newCartItems = new CartItem[cartItems.length + 3];
        // 复制原数组有效元素到新数组
        for (int i = 0; i < size; i++) {
            newCartItems[i] = cartItems[i];
        }
        cartItems = newCartItems;
    }

    // 核心方法1：添加商品到购物车，已存在则累加数量
    public void addGoods(Goods goods, int num) {
        // 校验数量合法性
        if (num <= 0) {
            System.out.println("购买数量必须大于0，添加失败！");
            return;
        }
        // 查找商品是否已在购物车
        int index = getIndex(goods.getId());
        if (index != -1) {
            // 已存在，累加数量
            CartItem item = cartItems[index];
            item.setNum(item.getNum() + num);
            System.out.println("商品【" + goods.getName() + "】已在购物车，数量累加为" + item.getNum() + "！");
        } else {
            // 不存在，新增商品项，判断是否需要扩容
            if (size >= cartItems.length) {
                expand();
            }
            cartItems[size] = new CartItem(goods, num);
            size++;
            System.out.println("商品【" + goods.getName() + "】添加购物车成功，数量：" + num + "！");
        }
    }

    // 核心方法2：修改商品数量，数量为0则删除
    public void updateNum(String goodsId, int newNum) {
        // 查找商品是否存在
        int index = getIndex(goodsId);
        if (index == -1) {
            System.out.println("商品编号【" + goodsId + "】未在购物车，修改失败！");
            return;
        }
        // 校验数量
        if (newNum < 0) {
            System.out.println("修改数量不能为负数，操作失败！");
            return;
        }
        if (newNum == 0) {
            // 数量为0，执行删除
            deleteGoods(goodsId);
            return;
        }
        // 修改数量
        CartItem item = cartItems[index];
        item.setNum(newNum);
        System.out.println("商品【" + item.getGoods().getName() + "】数量修改为" + newNum + "！");
    }

    // 核心方法3：根据商品编号删除商品
    public void deleteGoods(String goodsId) {
        // 查找商品是否存在
        int index = getIndex(goodsId);
        if (index == -1) {
            System.out.println("商品编号【" + goodsId + "】未在购物车，删除失败！");
            return;
        }
        // 元素向前移位，覆盖待删项
        for (int i = index; i < size - 1; i++) {
            cartItems[i] = cartItems[i + 1];
        }
        // 最后一个有效项置空，有效数量-1
        cartItems[size - 1] = null;
        size--;
        System.out.println("商品编号【" + goodsId + "】从购物车删除成功！");
    }

    // 核心方法4：查看购物车所有商品
    public void showCart() {
        if (size == 0) {
            System.out.println("您的购物车为空，快去添加商品吧！");
            return;
        }
        // 打印表头
        System.out.println("=====【我的购物车】=====");
        System.out.println("商品编号\t商品名称\t商品单价\t购买数量\t小计金额");
        // 遍历有效商品项
        for (int i = 0; i < size; i++) {
            CartItem item = cartItems[i];
            Goods goods = item.getGoods();
            System.out.printf("%s\t\t%s\t\t%.2f\t\t%d\t\t%.2f\n",
                    goods.getId(),
                    goods.getName(),
                    goods.getPrice(),
                    item.getNum(),
                    item.getSubTotal());
        }
    }

    // 核心方法5：结算购物车，返回总价
    public double settleAccount() {
        if (size == 0) {
            System.out.println("购物车为空，无法结算！");
            return 0.0;
        }
        double total = 0.0;
        // 累加所有商品项小计
        for (int i = 0; i < size; i++) {
            total += cartItems[i].getSubTotal();
        }
        System.out.println("=====【结算结果】=====");
        System.out.printf("您的购物车共%d件商品，应付总价：%.2f元\n", size, total);
        return total;
    }
}

2.4 类4：CartTest.java（测试类，控制台交互）

java 复制代码

/**
 * 购物车测试类 - 程序入口，模拟用户控制台操作
 * 核心：调用ShoppingCart方法，展示完整购物流程
 */
public class CartTest {
    public static void main(String[] args) {
        // 1. 创建购物车对象
        ShoppingCart cart = new ShoppingCart();

        // 2. 创建商品对象（模拟商品库）
        Goods g1 = new Goods("001", "Java编程思想", 108.0);
        Goods g2 = new Goods("002", "Spring实战", 89.0);
        Goods g3 = new Goods("003", "MySQL从入门到精通", 59.9);

        // 3. 模拟操作：添加商品
        System.out.println("=====【第一步：添加商品】====");
        cart.addGoods(g1, 1);
        cart.addGoods(g2, 2);
        cart.addGoods(g1, 1); // 重复添加，累加数量
        cart.addGoods(g3, 0); // 非法数量，添加失败
        cart.showCart();

        // 4. 模拟操作：修改数量
        System.out.println("\n=====【第二步：修改数量】====");
        cart.updateNum("002", 1); // 修改002数量为1
        cart.updateNum("004", 5); // 不存在的商品
        cart.updateNum("003", 0); // 数量为0，删除
        cart.showCart();

        // 5. 模拟操作：删除商品
        System.out.println("\n=====【第三步：删除商品】====");
        cart.deleteGoods("001");
        cart.deleteGoods("005");
        cart.showCart();

        // 6. 模拟操作：重新添加并结算
        System.out.println("\n=====【第四步：重新添加并结算】====");
        cart.addGoods(g1, 2);
        cart.addGoods(g2, 1);
        cart.showCart();
        cart.settleAccount();
    }
}

2.5 运行结果（验证业务有效性）

复制代码

=====【第一步：添加商品】====
商品【Java编程思想】添加购物车成功，数量：1！
商品【Spring实战】添加购物车成功，数量：2！
商品【Java编程思想】已在购物车，数量累加为2！
购买数量必须大于0，添加失败！
=====【我的购物车】=====
商品编号	商品名称	商品单价	购买数量	小计金额
001		Java编程思想		108.00		2		216.00
002		Spring实战		89.00		2		178.00

=====【第二步：修改数量】====
商品【Spring实战】数量修改为1！
商品编号【004】未在购物车，修改失败！
商品编号【003】未在购物车，删除失败！
=====【我的购物车】=====
商品编号	商品名称	商品单价	购买数量	小计金额
001		Java编程思想		108.00		2		216.00
002		Spring实战		89.00		1		89.00

=====【第三步：删除商品】====
商品编号【001】从购物车删除成功！
商品编号【005】未在购物车，删除失败！
=====【我的购物车】=====
商品编号	商品名称	商品单价	购买数量	小计金额
002		Spring实战		89.00		1		89.00

=====【第四步：重新添加并结算】====
商品【Java编程思想】添加购物车成功，数量：2！
商品【Spring实战】已在购物车，数量累加为2！
=====【我的购物车】=====
商品编号	商品名称	商品单价	购买数量	小计金额
002		Spring实战		89.00		2		178.00
001		Java编程思想		108.00		2		216.00
=====【结算结果】=====
您的购物车共2件商品，应付总价：394.00元

2.6 案例核心考点提炼（必记）

✅ 考点1：对象作为成员变量

CartItem关联Goods对象，体现对象间关联关系，是复合类设计基础，为后续继承、多态学习铺垫。

✅ 考点2：自定义变量管理有效数据

size变量记录有效商品项数量，避免遍历空对象，是数组操作优化的常用技巧。

✅ 考点3：私有方法封装

getIndex()、expand()设为私有，隐藏实现细节，仅暴露核心业务方法，符合封装思想。

✅ 考点4：业务健壮性设计

添加/修改时校验数量合法性，查找时判断对象存在性，规避非法操作导致程序异常。

✅ 考点5：数组扩容优化

扩容长度+3而非+1，减少频繁扩容的性能损耗，贴合实际开发优化思路。

✅ 考点6：单一职责原则

每个方法仅负责一项功能（add负责添加、update负责修改），逻辑清晰、易维护。

三、全系列核心知识点复盘 📚 构建知识框架

3.1 核心知识体系（必背）

一、面向对象核心思想

核心：找对象做事情，将真实事物抽象为类与对象；
关键：职责划分，对象各司其职，通过交互实现业务；
优势：解耦、易维护、可复用，适配大型项目开发。

二、类与对象基础

类：事物抽象模板，包含属性（成员变量） 和行为（成员方法）；
对象：类的实例，通过new关键字创建；
关系：一个类可创建多个对象，对象属性独立、方法共享。

三、封装（核心特性）

实现：private私有化属性 + public的get/set方法；
好处：数据安全、隐藏细节、提升复用性；
标准JavaBean：私有化属性+空参构造+带参构造+全套get/set。

四、核心关键字与方法

this关键字：当前对象引用，区分同名成员变量与局部变量；
构造方法：与类名一致、无返回值，用于对象初始化；空参（默认/手动）、带参（快速赋值）；
构造与set区别：构造创建时赋值（仅1次），set创建后赋值（可多次）。

五、变量分类与区别

维度	成员变量（类中方法外）	局部变量（方法内/形参）
内存位置	堆内存（随对象）	栈内存（随方法栈帧）
初始化值	有默认值（int=0等）	无默认值，需手动赋值
生命周期	随对象创建/销毁	随方法调用/结束
作用域	整个类有效	仅当前方法/代码块有效

六、对象数组

定义：数组元素为类的对象，用于批量管理多对象；
初始化：动态初始化（推荐，类名[] 数组名 = new 类名[长度]）、静态初始化；
底层：栈存数组引用，堆存对象，数组存储对象地址；
进阶操作：先找索引再操作，含唯一性校验、扩容、增删改查；
扩容：数组长度不可变，需创建新数组+复制原元素。

七、开发核心思想

方法封装复用：重复逻辑封装为独立方法，单一职责；
空指针规避：操作对象前先判对象 != null；
唯一标识：为对象定义id，作为增删改查依据。

四、笔试高频易错点避坑指南 ❌ 零失分必备

4.1 语法类易错点

❌ 手动定义构造后忘记写空参构造，导致new 类名()报错；
❌ 字符串对比用==（对比地址）而非equals()（对比内容）；
❌ 操作对象数组未判空，引发空指针异常；
❌ 局部变量未赋值直接使用，编译报错；
❌ 试图直接修改数组长度（数组长度不可变）。

4.2 思想类易错点

❌ 一个类包揽所有逻辑（实体、业务、测试），违反单一职责；
❌ 重复编写遍历/查找逻辑，未封装方法，代码冗余；
❌ 未定义对象唯一标识，导致增删改查精准度低；
❌ set方法未做数据校验，允许非法值赋值（如负数数量）。

4.3 实战类易错点

❌ 删除数组元素仅置空，未做元素移位，导致遍历混乱；
❌ 新增对象未做唯一性校验，导致数据重复；
❌ 金额计算未控制精度，展示不友好（需用printf("%.2f", 数值)）；
❌ 方法参数未校验合法性，引发非法操作。

✍️ 写在最后（系列收官，展望进阶）

至此，Java面向对象系列六篇内容全部完结！从类与对象入门，到封装、对象数组应用，再到购物车系统综合实战，我们完成了从语法认知到思维建立、项目落地的完整跨越。购物车系统虽为控制台简易版，但覆盖了基础阶段所有高频考点，吃透它就能具备多知识点融合应用的能力。

面向对象是Java的灵魂，也是后续学习JavaSE进阶、框架（Spring、MyBatis）的核心根基。学习编程的关键不是死记语法，而是建立编程思维------从面向过程的"分步做事"，到面向对象的"找对象做事"，这一转变将让你在后续学习中事半功倍。

🌟 后续学习展望

基础阶段结束后，将进入JavaSE进阶学习，重点攻克：

面向对象进阶：继承、多态、抽象类、接口；
常用API：String、包装类、集合框架（ArrayList、HashMap）；
IO流、多线程、网络编程；
复杂项目实战：融合全知识点实现企业级简易应用。

Java学习之路，道阻且长，行则将至。愿你保持热爱，持续精进，以基础为帆，驶向更广阔的编程海洋！✨

📌 系列回顾

Java面向对象精讲（一）：类与对象入门｜从概念到实战，吃透核心思想
Java面向对象精讲（二）：封装+this+构造方法｜标准JavaBean规范与编码
Java面向对象精讲（三）：内存图+变量区别｜打通底层原理，从会写到懂原理
Java面向对象精讲（四）：对象数组核心+实战｜格斗游戏+汽车管理，吃透多对象应用
Java面向对象精讲（五）：对象数组进阶实战｜学生信息管理+增删改查，吃透核心考点
Java面向对象精讲（六）：综合实战收官｜购物车系统+全系列复盘，夯实基础闭环

本文为Java面向对象系列收官篇，案例实测可运行，代码贴合企业规范。对你有帮助的话，欢迎点赞+收藏+关注，后续持续更新Java核心知识点与实战案例！评论区留言可解答疑问~

Java面向对象：购物车系统完整版+全系列考点复盘

文章目录

✨Java面向对象精讲（六）：综合实战收官｜购物车系统完整版+全系列考点复盘 夯实基础闭环 ✅

📌 文章摘要（245字）

🕒 阅读时长：约25分钟

✅ 适用人群 & 阅读重点

📖 知识回顾

一、实战前置：购物车系统业务分析 🛒 从场景到代码

1.1 核心业务场景（贴合电商实际）

1.2 类的设计思路（面向对象核心：职责划分）

✔ 类1：Goods（商品类）- 纯实体类

✔ 类2：CartItem（购物车项类）- 关联实体类

✔ 类3：ShoppingCart（购物车主类）- 业务逻辑类

✔ 类4：CartTest（测试类）- 控制台交互类

1.3 核心技术点（全系列知识点融合）

二、终极综合实战 🛒 购物车系统完整实现

2.1 类1：Goods.java（商品类，标准JavaBean）

2.2 类2：CartItem.java（购物车项类，关联实体）

2.3 类3：ShoppingCart.java（购物车主类，业务逻辑封装）

2.4 类4：CartTest.java（测试类，控制台交互）

2.5 运行结果（验证业务有效性）

2.6 案例核心考点提炼（必记）

✅ 考点1：对象作为成员变量

✅ 考点2：自定义变量管理有效数据

✅ 考点3：私有方法封装

✅ 考点4：业务健壮性设计

✅ 考点5：数组扩容优化

✅ 考点6：单一职责原则

三、全系列核心知识点复盘 📚 构建知识框架

3.1 核心知识体系（必背）

一、面向对象核心思想

二、类与对象基础

三、封装（核心特性）

四、核心关键字与方法

五、变量分类与区别

六、对象数组

七、开发核心思想

四、笔试高频易错点避坑指南 ❌ 零失分必备

4.1 语法类易错点

4.2 思想类易错点

4.3 实战类易错点

✍️ 写在最后（系列收官，展望进阶）

🌟 后续学习展望

📌 系列回顾

✨Java面向对象精讲（六）：综合实战收官｜购物车系统完整版+全系列考点复盘夯实基础闭环 ✅