本次修改内容，分类后的优化代码。在加入购物车后回问是否生成订单，生成订单的话会直接购买，反之则会加入购物车内。
import java.util.Arrays;
import java.util.Scanner;
/*
商品构买逻辑模块的首页
*/
public class sx10 {
public static void main(String[] args) {
//整个程序中,mypay1实例化,mypay1,mypay2,mypay3,mypay4,mypay5都需要实例化，赋值，最后调用
//mypay1,mypay2,mypay3,mypay4,mypay5在整个main函数中全局有效
//在整个程序中，只要与数值有关系的，一、输入数值选择，二、变量名差不多，多一个数值
//数组初始化，只有5个元素，只有5个商品
MyPay[] mypays=new MyPay[5];
//由于MyPay初始化时输入不同的参数，把参数做成数组
String[] names= {"伤寒论张仲景正版原著中医书籍大全白话彩图典藏版",
"鬼谷子狼道墨菲定律断舍离说话技巧",
"红岩书正版",
"镜花缘 李汝珍著 ",
"读心术正版心理学书"
};
//价格数组
Double[] prices= {9.8,178.0,21.6,18.9,8.8};
//配送数组
String[] peisongs= {"江苏南京至北京市昌平区",
"河北廊坊至北京市昌平区",
"河北廊坊至北京市昌平区",
"天猫优仓天津1仓至北京市昌平区",
"北京至北京市昌平区"
};
//实例化购物车
MyCart mycart=new MyCart();
//显示商品列表的菜单
System.out.println("*********************");
System.out.println(" 欢迎光临幸运购买系统");
System.out.println(" 版本：v1.11");
System.out.println("--------------------");
//定义数组，把这些对象都放在数组中，数组中的每一个相当于一个商品对象，这里是MyPay的对象
//数量都是1,不做数组处理
//实例化所有的商品，对数组进行遍历
//第一层遍历五个MyPay对象，后遍历names,遍历prices，遍历peisons.但是names,prices,peisons都是一层的关系
//第一层循环是五个对象，每个对象赋值一次，把各个数组中的元素取出赋值即可
for(int i=0;i<5;i++){
mypays[i]=new MyPay();
mypays[i].setName(names[i]);
mypays[i].setPrice(prices[i]);
mypays[i].setPeison(peisongs[i]);
mypays[i].setNum(1);
print_goods(i+1,mypays[i].getName(),mypays[i].getPrice());
}
System.out.println("*********************");
//上面代码允许用户看首页,看完首页进入订单页，必有用户名
Scanner scanner = new Scanner(System.in);
//必须敲回车,或者用户敲任意字符不接收,这里不接收没有登录用户
scanner.nextLine();
//需要用户登录，才能选择商品，记住细节，之前执行过init，就执行过new Pay，之前的内容不允许输入用户名
System.out.println("请进行用户登录");
//执行mypays数组中的0元素进行用户登陆
mypays[0].myinput();
//mypays数组中第2到第5个元素所有username和money都等于第一个元素,从第二个元素开始赋值,这里j=1
for(int j=1;j<5;j++){
mypays[j].setUsername(mypays[0].getUsername());
mypays[j].setMoney(mypays[0].getMoney());
}
//这里循环状态就可以控制,通过订单的状态,如果订单关闭,就不用再进行while循环了
//因为每一个商品都实例化一次,都有一个订单状态,根据用户选择的商品来决定,加了while外面没有no
//或者只写一次,可以用do---while,do---while保证循环体出现一次
//如果加入购物车的话，不停加入购物车，while循环退出条件是最后一个商品的购买状态
int no=1;
do{
//这里只接收商品编号，使用nextInt会报错，直接用try -----catch
System.out.println("请输入购买商品的编号:");
try{
no=scanner.nextInt();
//当选择对应的商品后，进行商品模块，商品模块中显示商品详情，立即购买，加入购物车两个按钮
//调用商品模块中的显示。
//首页中调用商品1的显示方法,这里想引用数组脚标用i-1
mypays[no-1].show(mycart);
}catch(Exception e){
System.out.println("谢谢使用，你输入错误，请输入商品对应的编号");
}
} while(mypays[no-1].isStatus());
//最后交给主类打印购物车mycart中其它商品，用增强for
for(MyPay mygood:mycart.getCart()){
if(mygood!=null){
System.out.println(mygood.getName());
System.out.println(mygood.getPeison());
System.out.println(mygood.getPrice());
System.out.println(mygood.getNum());
}
}
//逻辑执行到这里，先把购物车输出
// System.out.println(Arrays.toString(mycart.getCart()));
}
//用函数解决代码中重复代码问题，参数不一致，在循环中用多个数组来解决，这里用函数传参的方式
//后期改变打印样式，只需要改变函数即可
public static void print_goods(int i,String name,double price){
System.out.println( i+"-"+name+"\t"+price);
}
}
import java.util.Scanner;
/*
以Java开发规范来修改的Pay类
*/
public class MyPay extends MyOrder{
//私有化所有的属性
private String username;
private double money;
//无参,自动可以产生一个无参
public MyPay() {
//在这里直接产生父类的构造函数会产生报错，希望父类的构造函数在子类有效,使用super
//直接super()，调用父类的构造器
super();
}
//有参,因为可以为 username和money赋值
public MyPay(String username, double money) {
this.username = username;
this.money = money;
}
//正常的逻辑代码区
//由用户输入用户名和密码，没有放在构造器原因，只需要用户输入一次即可
public void myinput(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入付款帐户名称");
this.username=scanner.next();
System.out.println("请输入付款帐户余额:");
try{
this.money=scanner.nextDouble();
}catch(Exception e){
this.money=100;
}
}
//实现重写Order中的pay_order方法
//pay_order中需要取购物车中的商品
@Override
public void pay_order(){
//实现支付的逻辑，判断当前的余额比订单大还是小
if(this.money>this.getTotal()){
this.money=this.money-this.getTotal();
System.out.println("恭喜你，成功买得商品");
System.out.println(this.getName());
System.out.println(this.getPeison());
System.out.println(this.getPrice());
System.out.println(this.getNum());
System.out.println(this.getTotal());
}else{
System.out.println("小可爱你的钱包太瘪啦");
}
}
//简化流程,帐户和余额是可以设置的,username和money都有getter和setter方法
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
/*
java规范修改的Order类
*/
public class MyOrder extends MyGoods{
//只有私有成员变量total
private double total=0;
//还需要订单关闭的状态,这里指的加入购物车,还是直接购买,这里状态只有关闭和不关闭,默认订单开启
private boolean status=true;
public MyOrder() {
super();
}
//产生无参构造,方便实例化,因为父类有无参,这里默认是有无参构造
//正常逻辑的方法
//重写需要在方法上面加上@Override表示这个方法,父类也有,子类重写
//重载make_order方法，这个make_order不需要算num()*price，直接把total取出即可
//是否可以不重载，把make_order写一起
//这里的total是购物车传过来的参数
@Override
protected final void make_order(double total){
//make_order方法就生成定单,当前定单关闭
this.status=false;
//产生定单号，定单号规定8位的整数
long order_id=(int)(Math.random()*10000000+10000000);
// double计算时，注意乘法是不准，改成私有化后，不能直接.num,.private,这里需要用get方法取值
//下面的this.num。调用this.getNum,this.price改成this.getPrice
//立即购买的total有初始值为0,不立即购买的初始值是和值,和值来自于购物车的结果，购物车结果要传回。
if(this.total==0.0){
this.total=this.getNum()*this.getPrice();
}else{
this.total=total;
}
//格式化，保留小数位数
this.total=Double.parseDouble(String.format("%.2f",this.total));
//离开了订单页面，到支付界面,调用支付,实例化,
//这里的pay_order()方法由Pay支付类进行重写。，这里传入购物车carts,这个参数是购物车过来的
this.pay_order();
}
//此方法需要Pay类重写，不需要访问，改成protected
protected void pay_order(){
//这个方法没有实现
}
//是否需要产生有参,有参只有一个total的构造函数,这里的total是计算出来的,不是用户赋值改变的,不需要做有参构造
//total一定是这个Order类自动计算,不需要外界用户参与,把这个值改变,这里的total只有getter方法
public double getTotal() {
return total;
}
//加入的订单状态需要getter和setter方法
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
}
import java.util.Scanner;
/*
修改Goods类，变成Java开发的规范
*/
public class MyGoods {
//第一，满足封装特性，所有变量全部私有private
private String name;
private String peison;
private int num;
private double price;
// private String big_pic;
private String small_pic;
//自动产生一个无参构造
public MyGoods() {
}
//自动产生全参构造函数，主类main函数调用这个类直接传入参数，不需要在主类main中产生init方法
public MyGoods(String name, double price,String peison, int num) {
this.name = name;
this.peison = peison;
this.num = num;
this.price = price;
}
//当前类显示的当前商品，没有办法显示全部商品
//正常逻辑中的方法
//显示所有的商品的方法show，有可能发生购物车的逻辑，主类把同一台的购物车取过来
public void show(MyCart mycart){
//首先显示商品
System.out.println(this.name);
System.out.println(this.num);
System.out.println(this.price);
System.out.println(this.peison);
//用户调整数量
System.out.println("请输入购买商品的数量");
Scanner scanner=new Scanner(System.in);
//这里的商品数量，如果出错，要继续输入
while(true){
try{
//输入的数量直接给this.num,this指示的当前对象
this.num=scanner.nextInt();
//成功后退出循环
break;
}catch(Exception e){
System.out.println("需要重新输入商品数量，你输入的有问题，请输入整数");
}
}
System.out.println("*********************");
System.out.println("1------立即购买");
System.out.println("2-------加入购物车");
System.out.println("*********************");
System.out.println("请选择你的购买意向，输入序号");
try{
//scanner是本类中本函数的全局变量，可以在这里使用
int no=scanner.nextInt();
switch(no){
case 1:
this.buy();
break;
case 2:
//调用时必须指明同一个购物车，这个购物车在主类中实例化，把购物车传入到这个类中
this.addcar(mycart);
break;
}
}catch(Exception e) {
//如果用户输入错误，默认选择立即购买的方法
this.buy();
}
}
//立即购买的方法
public void buy(){
System.out.println("你购买了这个商品");
//这里调用Order订单类的make_order()方法,在这里产生一个空方法,在Order类中重写
this.make_order(0.0);
}
//类只代表当前商品，addcar中只能把当前商品加入购物车,不进行购买，不做订单任务
//这里addcar作用就是把商品放在购物车中，但是只是当前商品的类，不能是不同的商品放在一个购物车里
//订单是进入购物车结算才开始的
//加入购物车的方法
public void addcar(MyCart mycart){
//把商品加入购物车类中,保证商品加到一个购物车中，购物车实例对象不能在这里实例化，在这里实例化不是一个购物车
//保证购物车是一个，实例在主类
//有购物车参数，直接执行加入购物车即可，this表示当前商品，直接把当前商品调用MyCart购物车类中的addCart购物车方法即可
mycart.addCart(this);
System.out.println("你已经把商品加入购物车");
}
//protected修饰,需要了类继承后进行重写
protected void make_order(double total){
//代码是由订单类做的,不是由Goods模块做的,它只能由Order的开发人员实现
}
//便于阅读，这些getter或者Setter方法放在代码的尾部
//第二，封装私有变量后，需要取值的变量用get方法，需要赋值的方法用set,即需要取值也需要赋值就是两个方法都有
//比如对name,get加上属性的首字母大写,get方法的目的是需要用户获取这个值，这里有返回值
public String getName(){
return this.name;
}
//set方法只起到一个赋值的作用，不需要返回值，因为需要赋值，必须有参数，参数name是局部变量
//一般set方法局部变量和类中属性名重名
public void setName(String name) {
this.name=name;
}
public String getPeison() {
return peison;
}
public void setPeison(String peison) {
this.peison = peison;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getSmall_pic() {
return small_pic;
}
public void setSmall_pic(String small_pic) {
this.small_pic = small_pic;
}
//toString放在代码最后
@Override
public String toString() {
return "MyGoods{" +
"name='" + name + '\'' +
", peison='" + peison + '\'' +
", num=" + num +
", price=" + price +
", small_pic='" + small_pic + '\'' +
'}';
}
}
import java.util.Scanner;
/*
把不同的商品的地址放在同一个地址的购物车中
购物车相当于new实例化一次
商品可以new实例化5个不同的商品
这样5个不同的地址放在一个地址的购物车中
产生购物车的类
属性
*/
public class MyCart {
//私有化属性,属性是数组，数组使用必须初始化，这里只有5个数值，当前没有数值是null
private MyPay[] carts=new MyPay[5];
//做getter和setter方法，根据逻辑可以加入购物车，向cart中加数值，这是setter方法，getter方法把购物车数据取出
public MyPay[] getCart() {
return carts;
}
//生成订单的功能
public void createOrder(){
System.out.println("现在是否生成订单?(y/n)");
Scanner scanner=new Scanner(System.in);
//用户输入y或n
String answer=scanner.next();
//用户输入的内容是y还是n,凡是字母考虑大小写
if(answer.toLowerCase().equals("y")){
//处理订单结算，把数据遍历，凡是不为空的，一定有价格，把价格总值给Order
//这个遍历不需要索引，可以用增强for
//求价格总和，求1-100的和 ,和值定义在循环外
double sum=0;
//记录商品的索引
int index=0;
for(MyPay mygood:carts){
if(mygood!=null){
sum+=mygood.getNum()*mygood.getPrice();
index++;
}
}
//调用订单类的make_order方法,
//加入购物车的商品每一个商品都可以购买，他的状态都是true,判断主类退出循环，用的哪一个商品订单的状态。
//根据逻辑，退出主循环的购买订单状态是最后一款商品，这里调用make_order方法使用最后一款商品即可
//虽然是数组的最后一个，但可能用户添加2个商品就结单了，直接判断4有问题，判断不空的商品的索引
//需要最后打印商品，需要carts的购物车
carts[index].make_order(sum);
}else{
}
}
//这个set方法特殊，希望加入购物车，不需要传入购物车所有内容，MyGoods[]变量意义是购物车所有内容，只要传入一个商品即可
//这里传入MyGoods是因为在MyGoods类中加入的this指示，this只能指代MyGoods类型。
public void addCart(MyGoods cart) {
//这里的逻辑把传入商品的加入购物车，因为数组只有5个元素，初始化后没有数值，是null
//对象类数组采用增加for遍历,for(数组中单个数据类型 变量名:数组名称）
for(int i=0;i<5;i++){
if (carts[i]==null){
//如果当前对象是空，证明购物车数组中第几位是没有商品,没有商品的就可以使用索引赋值
//这里需要把传入的MyGoods转成MyPay
carts[i]=(MyPay)cart;
//发现一个数据的商品为空,加入后直接退出循环,后面的商品不需要判空
break;
}
}
//当加入购物车结束后，需要判断是否进行订单关闭的结算
this.createOrder();
}
}
扫一扫
1448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
