案例：购物车模块模拟-架构搭建
一、需求
模拟购物车模块的功能，需要实现添加商品到购物车中去，同时需要提供修改商品的购买数量，结算商品价格功能（请使用面向对象编程来解决）。
二、分析
-
购物车中的每个商品都是一个对象，需要定义一个商品类。
-
成员变量：商品编号、名称、价格、购买数量；
-
-
购物车本身也是一个对象，可以使用数组对象代表它——>容器。
-
完成界面架构，让用户选择操作的功能。
三、实现
1、定义商品类，用于后期创建商品对象
(1.1) 定义成员变量: 商品编号、名称、价格、购买数量
2、定义购物车对象: 使用一个数组对象表示购物车，数组类型用的就是商品类
3、搭建购物操作界面:
a: 定义while循环，作用: 当各个指令的操作完成后，不会中断程序，可以继续操作指令
(1) 用户输入指令: add、query、update、pay
(2) 使用switch分支，判断用户输入的指令，进行对应的操作
a: 输入add: 添加商品到购物车中;
b: 输入query: 查看购物车中的商品;
c: 输入update: 修改商品的购买数量;
d: 输入pay: 结算购物车中所有商品的价格;
e: 输入exit: 退出操作;
f: 默认: "抱歉~您输入的指令有误!!!"。
4、定义操作方法:
(4.1) 添加商品的方法: addGoods，无返回值，设置两个形参: 分别用于接收传入的购物车、键盘录入对象
a: 录入商品信息: 编号，名称，价格，购买数量;
b: 将购买商品的信息封装成一个商品对象——>打包;
c: 将商品对象添加到购物车中(数组):
(1) 判断当前位置是否为空，
(1.1) 为空则添加新商品到购物车,
(1.2) 结束循环，因为商品成功存入了，不需要继续找空位置了。
d: 成功加入购物车提示一下。
(4.2) 查看商品的方法: queryGoods，无返回值，设置一个形参用于接收传入的购物车
a: 定义for循环遍历购物车中的所有商品对象:
(1) 定义个变量接收每次遍历到的商品对象
(2) 判断购物车中的商品对象是否为null，
(2.1) 不为空，展示所有商品对象信息
(2.2) 为空，结束展示
(4.3) 根据商品id查询的方法：getGoodsById，返回值类型是Goods，形参: 购物车数组, 要找的商品id
a: 定义for循环遍历购物车的所有商品对象:
(1) 定义变量接收每次遍历出来的商品对象
(2) 当遍历到的商品对象不为空时，说明有商品对象
(2.1) 判断这个商品的id 是不是我们要找的商品
是我们要找的，将商品对象返回
(3)否则为空，说明都没有商品对象
b: 代表找完了购物车中所有的商品都没有找到id一样的商品
(4.4) 修改商品的方法: updateGoods，无返回值，设置两个形参: 分别用于接收传入的购物车、键盘录入对象
a: 定义while循环，作用：当我们找不到要找的商品时，不会中断程序，可以继续找
(1) 调用getGoodsById方法，查询该商品id 是不是 我们要找的商品
(2) 判断该商品是否已加入购物车
(2.1) 该商品未加入购物车
(2.2) 该商品已加入购物车
(2.3) 修改该商品的购买数量
(2.4) 修改成功后，调用queryGoods，展示最新商品信息
(2.5) 结束循环: 因为已经找到我们要找的商品并且购买数量已修改成功！
(4.5) 结算价格的方法: payGoods，无返回值，设置一个形参用于接收传入的购物车
a: 定义一个求和变量，用于将购物车中所有商品的价格累加求和
b: 定义for循环，遍历购物车所有的商品对象
(1) 定义变量接收每次遍历到的商品对象
(2) 判断当前商品是否为空
(2.1) 不为空，结算价格: 总价 = 购买数量 * 价格
(2.2) 为空，说明后面没有商品了，结束循环
c: 展示购物车里的所有商品，并展示总金额
- 定义商品类
package com.app.demo;
// 1、定义商品类，用于后期创建商品对象
public class Goods {
// (1.1) 定义成员变量: 商品编号、名称、价格、购买数量
int id;
String name;
double price;
int buyNumbers;
}
- 定义实现类
package com.app.demo;
import java.util.Scanner;
/**
目标——>面向对象编程训练: 购物车模块模拟
*/
public class ShopCarTest {
public static void main(String[] args) {
// 2、定义购物车对象: 使用一个数组对象表示购物车，数组类型用的就是商品类
Goods[] shopCar = new Goods[1000];
// 3、搭建购物操作界面:
// a: 定义while循环，作用: 当各个指令的操作完成后，不会中断程序，可以继续操作指令
while (true) {
System.out.println("\n购物操作指令如下: ");
System.out.println("添加商品: add");
System.out.println("查看商品: query");
System.out.println("修改数量: update");
System.out.println("结算价格: pay");
System.out.println("退出操作: exit");
// (1) 用户输入指令: add、query、update、pay
Scanner sc = new Scanner(System.in);
System.out.println("请您输入操作指令: ");
String command = sc.next();
// (2) 使用switch分支，判断用户输入的指令，进行对应的操作
switch (command) {
// a: 输入add:
case "add":
// 添加商品到购物车中;
addGoods(shopCar, sc);
break;
// b: 输入query:
case "query":
// 查看购物车中的商品;
queryGoods(shopCar);
break;
// c: 输入update:
case "update":
// 修改商品的购买数量;
updateGoods(shopCar, sc);
break;
// d: 输入pay:
case "pay":
// 结算购物车中所有商品的价格;
payGoods(shopCar);
break;
// e: 输入exit:
case "exit":
// 退出操作
System.exit(0);
break;
// f: 默认:
default:
// "抱歉~您输入的指令有误!!!"
System.out.println("抱歉~您输入的指令有误!!!");
break;
}
}
}
// 4、定义操作方法:
/**
(4.1) 添加商品的方法: addGoods，无返回值，设置两个形参: 分别用于接收传入的购物车、键盘录入对象
*/
public static void addGoods(Goods[] shopCar, Scanner sc) {
// a: 录入商品信息: 编号，名称，价格，购买数量
System.out.println("\n-----------------------");
System.out.println("开始购物");
System.out.println("请您输入商品编号(不重复): ");
int id = sc.nextInt();
System.out.println("请您输入商品名称: ");
String name = sc.next();
System.out.println("请您输入商品价格: ");
double price = sc.nextDouble();
System.out.println("请您输入购买数量: ");
int buyNumbers = sc.nextInt();
// b: 将购买商品的信息封装成一个商品对象——>打包
Goods commodity = new Goods();
commodity.id = id;
commodity.name = name;
commodity.price = price;
commodity.buyNumbers = buyNumbers;
// c: 将商品对象添加到购物车中(数组)
for (int i = 0; i < shopCar.length; i++) {
// (1) 判断当前位置是否为空，
if (shopCar[i] == null) {
// (1.1) 为空则添加新商品到购物车
shopCar[i] = commodity;
// (1.2) 结束循环，因为商品成功存入了，不需要继续找空位置了
break;
}
}
// d: 成功加入购物车提示一下
System.out.println("您的商品" + commodity.name + "已加入购物车中~~\n");
}
/**
(4.2) 查看商品的方法: queryGoods，无返回值，设置一个形参用于接收传入的购物车
*/
public static void queryGoods(Goods[] shopCar) {
System.out.println("==================查询购物车信息如下==================");
System.out.println("编号\t\t名称\t\t\t\t价格\t\t\t购买数量");
// a: 定义for循环遍历购物车中的所有商品对象
for (int i = 0; i < shopCar.length; i++) {
// (1) 定义个变量接收每次遍历到的商品对象
Goods commodity = shopCar[i];
// (2) 判断购物车中的商品对象是否为null，
if (commodity != null) {
// (2.1) 不为空，展示所有商品对象信息
System.out.println(commodity.id + "\t\t"
+ commodity.name + "\t\t"
+ commodity.price + "元\t\t\t"
+ commodity.buyNumbers + "\t\t\t");
}else {
// (2.2) 为空，结束展示
break;
}
}
}
/**
(4.3) 定义一个根据商品id查询的方法：getGoodsById，返回值类型是Goods，形参: 购物车数组, 要找的商品id
*/
public static Goods getGoodsById(Goods[] shopCar, int id) {
// a: 定义for循环遍历购物车的所有商品对象
for (int i = 0; i < shopCar.length; i++) {
// (1) 定义变量接收每次遍历出来的商品对象
Goods commodity = shopCar[i];
// (2) 当遍历到的商品对象不为空时，说明有商品对象
if (commodity != null) {
// (2.1) 判断这个商品的id 是不是我们要找的商品
if (commodity.id == id) {
// 是我们要找的，将商品对象返回
return commodity;
}
}else {
// (3)否则为空，说明都没有商品对象
return null;
}
}
// b: 代表找完了购物车中所有的商品都没有找到id一样的商品
return null;
}
/**
(4.4) 修改商品的方法: updateGoods，无返回值，设置两个形参: 分别用于接收传入的购物车、键盘录入对象
*/
public static void updateGoods(Goods[] shopCar, Scanner sc) {
System.out.println("\n==================修改商品购买数量==================");
// a: 定义while循环，作用：当我们找不到要找的商品时，不会中断程序，可以继续找
while (true) {
System.out.println("请您输入商品编号: ");
int id = sc.nextInt();
// (1) 调用getGoodsById方法，查询该商品id 是不是 我们要找的商品
Goods commodity = getGoodsById(shopCar, id);
// (2) 判断该商品是否已加入购物车
if (commodity == null) {
// (2.1) 该商品未加入购物车
System.out.println("抱歉~ 该商品未加入购物车！");
}else {
// (2.2) 该商品已加入购物车
System.out.println("请您输入商品 " + commodity.name + " 的最新购买数量: ");
int newBuyNumbers = sc.nextInt();
// (2.3) 修改该商品的购买数量
commodity.buyNumbers = newBuyNumbers;
System.out.println("商品 " + commodity.name + " 的购买数量已修改~");
// (2.4) 修改成功后，调用queryGoods，展示最新商品信息
queryGoods(shopCar);
// (2.5) 结束循环: 因为已经找到我们要找的商品并且购买数量已修改成功！
break;
}
}
}
// (4.5) 结算价格的方法: payGoods，无返回值，设置一个形参用于接收传入的购物车
public static void payGoods(Goods[] shopCar) {
// a: 定义一个求和变量，用于将购物车中所有商品的价格累加求和
double money = 0;
// b: 定义for循环，遍历购物车所有的商品对象
for (int i = 0; i < shopCar.length; i++) {
// (1) 定义变量接收每次遍历到的商品对象
Goods g = shopCar[i];
// (2) 判断每次遍历到的商品是否为空
if (g != null) {
// (2.1) 不为空，结算价格: 总价 = 购买数量 * 价格
money += (g.buyNumbers * g.price);
}else {
// (2.2) 为空，说明后面没有商品了，结束循环
break;
}
}
// c: 展示购物车里的所有商品，并展示总金额
queryGoods(shopCar);
System.out.println("\n结算成功~ 您已支付" + (money*1.0) + "元！");
}
}
输出结果：
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
add
-----------------------
开始购物
请您输入商品编号(不重复):
1
请您输入商品名称:
国服鼠标
请您输入商品价格:
299.9
请您输入购买数量:
1
您的商品国服鼠标已加入购物车中~~
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
add
-----------------------
开始购物
请您输入商品编号(不重复):
2
请您输入商品名称:
奥巴马键盘
请您输入商品价格:
455.9
请您输入购买数量:
2
您的商品奥巴马键盘已加入购物车中~~
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
add
-----------------------
开始购物
请您输入商品编号(不重复):
3
请您输入商品名称:
青龙偃月刀
请您输入商品价格:
788.9
请您输入购买数量:
4
您的商品青龙偃月刀已加入购物车中~~
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
query
==================查询购物车信息如下==================
编号 名称 价格 购买数量
1 国服鼠标 299.9元 1
2 奥巴马键盘 455.9元 2
3 青龙偃月刀 788.9元 4
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
update
==================修改商品购买数量==================
请您输入商品编号:
3
请您输入商品 青龙偃月刀 的最新购买数量:
2
商品 青龙偃月刀 的购买数量已修改~
==================查询购物车信息如下==================
编号 名称 价格 购买数量
1 国服鼠标 299.9元 1
2 奥巴马键盘 455.9元 2
3 青龙偃月刀 788.9元 2
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
pay
==================查询购物车信息如下==================
编号 名称 价格 购买数量
1 国服鼠标 299.9元 1
2 奥巴马键盘 455.9元 2
3 青龙偃月刀 788.9元 2
结算成功~ 您已支付2789.5元！
购物操作指令如下:
添加商品: add
查看商品: query
修改数量: update
结算价格: pay
退出操作: exit
请您输入操作指令:
exit
Process finished with exit code 0
总结
1、购物车中的每个商品可以看成什么？需要先做什么准备？
- 一个个对象
- 定义商品类：Goods，后期创建对象代表一个商品信息
2、购物车对象用什么表示的？可以用于做什么？
-
使用商品类型的数组对象表示，可以用于存放商品对象
Goods[] shopCar = new Goods[1000];
3、如何完成添加商品功能？
- 创建Goods类的对象代表商品对象
- 封装用户输入的商品信息——>打包
- 把商品对象存入到购物车数组中
4、如何查看购物车信息？
- 遍历购物车数组，每遍历到一个商品对象，展示其信息
5、如何修改商品购买的数量？
- 根据用户输入的商品id查询出要修改的商品对象
6、如何进行商品的订单总额计算？
- 定义求和变量，用于累加: 购买数量 * 价格
- 遍历购物车中所有的商品，累加其 单价*购买数量