商品管理的后台系统

最新推荐文章于 2024-08-30 18:40:43 发布

2301_80416295

最新推荐文章于 2024-08-30 18:40:43 发布

阅读量53

点赞数

文章标签： java

本文链接：https://blog.csdn.net/2301_80416295/article/details/134555527

版权

面向接口

1、模块分离开发，相当于把商品和管理功能分开，商品作为java bean,这个类起到封装(构造函数，getter,setter，toString)

2、确定接口（方法）,一般在后台系统中增删改查.

3、确定abstract类-单个模块,抽象类中某些方法不能在当前功能模块中实现.(如果项目客户需求还没有具体,这个方法就是抽象)

4、确定类,实现接口,把方法的逻辑完成.一般查询的方法比较多的.

5、注意:(1)商品模块,ArrayList把商品放在ArrayList,商品模块是有商品编号的去重问题.采用HashMap(线性+链表+红黑树)(2)商品编号的制定规则,存储的是HashMap,返回数据是ArrayList,删除或者修改时, remove方法传参意义不一定,一个是key,一个是索引,把index加入到key中.(3) Size仿字符串源码,记录char[]数组长度的值,size-1就是一个元素,本身size就是元素的个数.(4)采用HashMap返回键对应的值的集合,也就是所有商品,返回类型是Collection.

思想:规避在程序中不断进行for循环.(数据量多用迭代器)

主类:整合系统,把功能用菜单的方式,由用户去选择条件语句,后台字节码

If -----gotoSwitch开始hashCode,后面equals用条件,

官方源码把条件转化成数组,数组执行函数功能,数组是存储数据的.

实例化的类不想总实例化,用静态,必须接口中的静态必须实现,再则静态方法中的全局变量是静态变量,静态类不需要面向接口.工具类需要在内存中,工具类是程序中用到算法.

While(true)中出现nextInt,这里进行try...catch并且跟上nextInt输入,执行速度无法控制.

While(true)中出现try----catch,很难控制菜单循环问题,try后面的内容就相当于函数一样,理解自己的保护.

Next()接收字符串很稳定,付出代码需要用数组来存储数据,进行转化,转化效率低,字符串底层就是字符数组.只接收字符数组第一位.char在内存中只用一个字节存储.

优化：1、避免循环(自己函数中用自己函数，递归)

2、变量应用存储字节最小。

3、条件用数组解决。

批量:来自于文件快捷方法:文件常用的文件就是没有格式的文件,这个文件只是文件图片文件(带格式先不讨论)Java提供了IO模块,这里实现很多类,类进行文件的操作读文件/写数据/重命名/删除

1、手动导入io模块

2、文件操作都有错误产生，有文件不存在情况。

IOExceptionFile类中File中不存在去操作文件内容，只操作文件New File没有异常报错，只是给File在传入文件名。对文件的操作可以从基本的增删改查去操作增：创建一个文件createNewFile创建新文件，这个文件是空文件如果a.txt文件没有就创建一个新的空文件，如果文件存在，并不覆盖，不处理。

删除：

delete方法删除文件文件夹的相关操作mkdir只能建立一层，

afmkdirs是建立多层文件夹的删除还是delete，但是删除一层

代码如下：

Mymain:

import java.util.Scanner;

public class MyMain {

public static void main(String[] args) {

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

System.out.println(" 商品的后台管理系统");

System.out.println(" (商家版)");

System.out.println(" 版本号:v1.0");

System.out.println(" 作者:CCCCC");

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

Scanner scanner = new Scanner(System.in);

char function_no='0';

//需要把非静态类的方法GoodManagerImpl进行实例化

GoodsManagerImpl manager = new GoodsManagerImpl();

//这个显示的菜单，执行一遍操作后，后面还可以选择，这个菜单反复出现，供用户选择

//显示商家进行商品增删改查的操作

while(true){

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

System.out.println("1-------添加商品");

System.out.println("2-------删除商品");

System.out.println("3-------修改商品");

System.out.println("4-------查询所有商品");

System.out.println("5-------按编号查询特定商品");

System.out.println("6-------按商品名称查询部分商品");

System.out.println("7-------按价格区间查询部分商品");

System.out.println("8-------退出");

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

System.out.println("请选择操作的功能编号:");

String myfunction_no=scanner.next();

System.out.println(myfunction_no);

//字符串本身就是一个char数组

function_no=myfunction_no.toCharArray()[0];

// try{

// function_no=(char)scanner.nextByte();

//

// }catch(Exception e){

// System.out.println("你选择的功能编号不正确，请重新选择");

// //使用 continue后面代码不执行，继续下次循环，执行速度太快，try...catch没有判断输入内容就开始执行

// }

//如果循环中有switch的优化，break只是退出switch的作用，并不退出循环，这里只能用if条件限定用户的退出

if(function_no=='8'){

break;

}

//采用switch,break退出的是switch

switch(function_no){

case '1': manager.add_goods();break;

case '2': manager.del_goods();break;

case '3': manager.update_goods();break;

case '4':

System.out.println(manager.findAll());break;

case '5':

System.out.println(manager.findByNo());break;

case '6':

System.out.println(manager.findByName());break;

case '7':

System.out.println(manager.findByPrice());break;

// default:continue;

}

Mymain1:

import java.util.Scanner;

public class MyMain1 {

public static void main(String[] args) {

GoodsManagerImpl goodsManager = new GoodsManagerImpl();

//一次添加

goodsManager.add_goods();

System.out.println(goodsManager.findAll());

//按名字查

Scanner scanner = new Scanner(System.in);

System.out.println("输入查询的商品名称");

String name=scanner.next();

System.out.println(goodsManager.findByName());

}

Mymain2:

import java.util.Scanner;

public class MyMain2 {

public static void main(String[] args) {

GoodsManagerImpl goodsManager = new GoodsManagerImpl();

//两次添加

goodsManager.add_goods();

System.out.println(goodsManager.findAll());

// goodsManager.add_goods();

// System.out.println(goodsManager.findAll());

//删除

// Scanner scanner=new Scanner(System.in);

// System.out.println("输入需要删除的商品编号");

// String no=scanner.next();

// goodsManager.del_goods();

// System.out.println(goodsManager.findAll());

// //一次更新

// goodsManager.update_goods();

// System.out.println(goodsManager.findAll());

}

Goods：

/*

java bean

这个类只是描述商品，哪些属性可以访问，哪些属性不开放访问。

描述商品的一个java bean

*/

public class Goods {

//封装，所有的属性私有化

//no商品编号

private String no;

//name商品名称

private String name;

//price商品价格

private double price;

//shop商家名称

private String shop;

//商品分类 type

private String type;

//封装构造函数，全参，无参

public Goods() {

}

public Goods(String no, String name, double price, String shop, String type) {

this.no = no;

this.name = name;

this.price = price;

this.shop = shop;

this.type = type;

}

//这些商品都需要getter,和setter方法

public String getNo() {

return no;

}

public void setNo(String no) {

this.no = no;

}

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;

}

public String getShop() {

return shop;

}

public void setShop(String shop) {

this.shop = shop;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

//打印对象显示的地址，显示的本类中所有的属性的值,重写toString

@Override

public String toString() {

return "Goods{" +

"no='" + no + '\'' +

", name='" + name + '\'' +

", price=" + price +

", shoGp='" + shop + '\'' +

", type='" + type + '\'' +

'}';

}

GoodsManager:

import java.util.Collection;

import java.util.List;

/*

这是一个接口，专门管理商品的java bean

*/

public interface GoodsManager {

//添加方法,一般初始化，返回值为空,这里参数在逻辑实现直接在方法中输入商品的相关参数

public void add_goods();

//删除方法，传入索引，这里传入编号，因为这里的删除有ArrayList还有HashMap，HashMap高效率地做了商品编号去重

public void del_goods();

//更新方法，需要更新商品的所有内容，按商品的编号来更新

public void update_goods();

//查询，必须返回用户结果，一定要有返回，返回内容多个

//按编号查,一个编号对应一个商品，返回值只有一个商品

public Goods findByNo();

//查询所有,出来是一个动态的集合，不能是数组，不需要去重,使用ArrayList，返回是一个ArrayList，里面是Goods

public Collection<Goods> findAll();

//按商品名称查,返回一堆商品

public List<Goods> findByName();

//按商品价格查，返回一堆商品

public List<Goods> findByPrice();

}

GoodsManagerImpI:

import java.util.*;

public class GoodsManagerImpl implements GoodsManager{

//设置一个总管家，HashMap，满足封装，需要私有,Map类型需要键(key）就是no，是String,value是对象，是Goods

private Map<String,Goods> goods_list=new HashMap<>();

//根据字符串源码中的处理方法，一个char[]定义一个size，到底有多个数。

private int size=0;

//最开始完成，添加一个商品,注意里面goods是执行过程中用户输入的,这里的goods就不需要传参

@Override

public void add_goods() {

//需要输入商品的名称，商品的价格，店铺的名称，商品的分类

Scanner scanner=new Scanner(System.in);

//接收商品名称

System.out.println("请输入添加商品的名称");

String name=scanner.next();

//接收商品的价格

System.out.println("请输入添加商品的价格");

//初始化没有定义的价格

double price=9999;

try {

price = scanner.nextDouble();

}catch(Exception e){

}

//接收商品的商家

System.out.println("商家名称");

String shop=scanner.next();

//接收商品的分类

System.out.println("商品的分类");

String type=scanner.next();

//产生一个no，no让系统随机产生，产生后加上一个索引size，理解当前商品的索引值

//UUID，一串随机,随机类型是UUID类型，如果用+号，在这里有一个StringBuilder对象，只有一个size,这里使用concat，

String no=UUID.randomUUID().toString().concat(size+"");

//初始化，商品参数结束，直接实例化

Goods goods=new Goods(no,name,price,shop,type);

//放在HashMap中就已经去重

goods_list.put(no,goods);

size++;

}

@Override

public void del_goods() {

Scanner scanner = new Scanner(System.in);

System.out.println("请输入删除的商品编号");

String no=scanner.next();

System.out.println("你确定要删除该商品吗?(y/n)");

String ans=scanner.next();

if(ans.toLowerCase().equals("y")){

goods_list.remove(no);

}else{

System.out.println("删除取消，你可以选择其它操作");

}

@Override

public void update_goods() {

Scanner scanner = new Scanner(System.in);

System.out.println("请输入修改商品的商品编号:");

//需要用户输入编号

String no=scanner.next();

//必须按商品的编号，告诉商品原来名称，需要改成,先把商品取出

Goods goods=goods_list.get(no);

//要求输入需要修改的商品名称内容

System.out.println("商品名称的原来内容:");

System.out.println(goods.getName());

//输出需要修改的商品名称内容

System.out.println("请输入修改后的名称");

String name=scanner.next();

// 要求输入需要修改的商品价格内容

System.out.println("商品名称的原来价格:");

System.out.println(goods.getPrice());

//输出需要修改的商品价格

System.out.println("请输入修改后的价格");

double price=goods.getPrice();

try{

price=scanner.nextDouble();

}catch(Exception e){

}

// 要求输入需要修改的商品店铺名称内容

System.out.println("商品名称的店铺名称:");

System.out.println(goods.getShop());

//输出需要修改的商品店铺名称

System.out.println("请输入修改后的店铺名称");

String shop=scanner.next();

// 要求输入需要修改的商品类别内容

System.out.println("商品名称的商品类别:");

System.out.println(goods.getType());

//输出需要修改的商品类别

System.out.println("请输入修改后的商品类别");

String type=scanner.next();

//修改商品的属性值，可以利用HashMap中key值覆盖的道理，产生一个新的商品

goods=new Goods(goods.getNo(),name,price,shop,type);

goods_list.put(goods.getNo(),goods);

}

@Override

public Goods findByNo() {

Scanner scanner = new Scanner(System.in);

System.out.println("请输入查询的商品编号:");

String no=scanner.next();

return goods_list.get(no);

}

@Override

public Collection<Goods> findAll() {

//显示所有，就是遍历HashMap,遍历HashMap中的值就可以,不需要遍历key,因为key的目的是去重

//直接使用values显示所有的值

return goods_list.values();

}

@Override

public List<Goods> findByName() {

Scanner scanner = new Scanner(System.in);

System.out.println("输入需要查询的商品名称：");

String name=scanner.next();

//构造结果

List<Goods> myresult=new ArrayList<>();

Collection<Goods> mygoods=goods_list.values();

//这里迭代器写

Iterator<Goods> myiter=mygoods.iterator();

while(myiter.hasNext()){

Goods goods=myiter.next();

if(goods.getName().indexOf(name)>-1){

myresult.add(goods);

}

return myresult;

}

@Override

public List<Goods> findByPrice() {

Scanner scanner=new Scanner(System.in);

System.out.println("请输入查询商品价格的开始区间：");

double start=0;

double end=0;

try {

start=scanner.nextDouble();

}catch(Exception e){

}

System.out.println("请输入查询商品价格的结束区间：");

try {

end=scanner.nextDouble();

}catch(Exception e){

}

//构造结果

List<Goods> myresult=new ArrayList<>();

Collection<Goods> mygoods=goods_list.values();

//这里迭代器写

Iterator<Goods> myiter=mygoods.iterator();

while(myiter.hasNext()){

Goods goods=myiter.next();

if(goods.getPrice()>=start && goods.getPrice()<=end){

myresult.add(goods);

}

return myresult;

}

2301_80416295

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
商品管理的后台系统

批量:来自于文件快捷方法:文件常用的文件就是没有格式的文件,这个文件只是文件图片文件(带格式先不讨论)Java提供了IO模块,这里实现很多类,类进行文件的操作读文件/写数据/重命名/删除。Next()接收字符串很稳定,付出代码需要用数组来存储数据,进行转化,转化效率低,字符串底层就是字符数组.只接收字符数组第一位.char在内存中只用一个字节存储.实例化的类不想总实例化,用静态,必须接口中的静态必须实现,再则静态方法中的全局变量是静态变量,静态类不需要面向接口.工具类需要在内存中,工具类是程序中用到算法.
复制链接

扫一扫