基于Java的简易线上购物系统

1.系统首页Mypage：

该页面包含开发者，版本，商品名称，商品价格等信息，除此之外，还让用户进行了登陆，选商品等操作。

import java.util.Arrays;

import java.util.Scanner;

/*

商品构买逻辑模块的首页

开发者:XXXX

版本:v1.2

*/

public class MyPage {

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= {"40斤装狗粮",

"保暖卫衣",

"万代rg金色异端拼装模型",

"不锈钢密封饭盒 ",

"旺仔牛奶125ml*20盒"

};

//价格数组

Double[] prices= {185.0,39.9,179.0,31.5,80.2};

//配送数组

String[] peisongs= {"江苏南京 至 河北承德双桥区",

"河南郑州 至 河北承德双桥区",

"山东青岛 至 河北承德双桥区",

"广东潮州 至 河北承德双桥区",

"湖南长沙 至 河北承德双桥区"

};

//实例化购物车

MyCart mycart=new MyCart();

//显示商品列表的菜单

System.out.println("*********************");

System.out.println(" 简易线上购物系统");

System.out.println(" 开发者：Srymaker");

System.out.println(" 版本：v1.2");

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);

}

}

2.商品数量页MyGoods

该页面主要功能为：选择商品数量，选择直接购买还是加入购物车，购物车界面在下面会展示

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("请选择1或者2");

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 + '\'' +

'}';

}

}

3.购物车界面MyChat

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();

}

}

4.支付界面MyPay

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;

}

}

5.订单界面MyOrder

/*

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;

}

}