devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java宠物商店管理系统_宠物管理系统java

作者：羊村懒王 | 2024-04-06 23:16:53

赞

踩

宠物管理系统java

java面向对象编写宠物商店管理系统，控制台输出和输入，使用map集合和list集合存储输入的数据信息。

宠物抽象类：

  1. /**
  2.  * 宠物类
  3.  */
  4. public class Pet {
  5.     //属性
  6.     private String name;//宠物名字
  7.     private int age;//年龄
  8.     private String sex;//性别
  9.     private String strain;//品种
  10.     private int inPrice;//购入价格
  11.     private int outPrice;//出售价格
  12.  
  13.     //方法
  14.     //getter/setter方法
  15.     public String getName() {
  16.         return name;
  17.     }
  18.  
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  22.  
  23.     public int getAge() {
  24.         return age;
  25.     }
  26.  
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  30.  
  31.     public String getSex() {
  32.         return sex;
  33.     }
  34.  
  35.     public void setSex(String sex) {
  36.         this.sex = sex;
  37.     }
  38.  
  39.     public String getStrain() {
  40.         return strain;
  41.     }
  42.  
  43.     public void setStrain(String strain) {
  44.         this.strain = strain;
  45.     }
  46.  
  47.     public int getInPrice() {
  48.         return inPrice;
  49.     }
  50.  
  51.     public void setInPrice(int inPrice) {
  52.         this.inPrice = inPrice;
  53.     }
  54.  
  55.     public int getOutPrice() {
  56.         return outPrice;
  57.     }
  58.  
  59.     public void setOutPrice(int outPrice) {
  60.         this.outPrice = outPrice;
  61.     }
  62.  
  63.     //无参构造方法
  64.     public Pet() {
  65.     }
  66.  
  67.     //含所有参数的构造方法
  68.     public Pet(String name, int age, String sex, String strain, int inPrice, int outPrice) {
  69.         this.name = name;
  70.         this.age = age;
  71.         this.sex = sex;
  72.         this.strain = strain;
  73.         this.inPrice = inPrice;
  74.         this.outPrice = outPrice;
  75.     }
  76.  
  77.     //显示方法 printf沿用了C的printf,用法也完全一致 第一组参数(占位符)代表要输出的类型,第二组参数代表待输出的数据对象
  78.     public void play() {//输出错误信息  通过this关键字来调用属性
  79.         System.out.printf("宠物:%s\t\t年龄:%d\t\t性别:%s\t\t品种:%s\t\t购入价格:%d\t\t售出价格:%d\t\t利润:%d\n",
  80.                 this.name, this.age, this.sex, this.strain, this.inPrice, this.outPrice, (this.outPrice - this.inPrice));
  81.     }
  82. }
宠物管理接口：
  1.  
  2. import java.util.ArrayList;
  3. //宠物管理接口
  4. public interface PetAdministration {
  5.     /**
  6.      * 显示所有宠物信息
  7.      * @param pets
  8.      */
  9.     void showAllPets(ArrayList<Pet>pets);
  10.  
  11.     /**
  12.      *根据名字查找宠物
  13.      * @param name
  14.      * @param pets
  15.      */
  16.     void findPetByName(String name,ArrayList<Pet>pets);
  17.  
  18.     /**
  19.      * 根据名字删除宠物信息，先根据名字找到对应的宠物信息，将其加到另一个集合中后从原集合删除，
  20.      * 从原集合被删除的被存入新集合，实现记录数据
  21.      * @param name
  22.      * @param pets
  23.      * @param pets1
  24.      */
  25.     void deletePetByName(String name,ArrayList<Pet>pets,ArrayList<Pet> pets1);
  26.  
  27.     /**
  28.      * 宠物信息
  29.      * @return
  30.      */
  31.     Pet petInformation();
  32.  
  33.     /**
  34.      * 添加宠物信息
  35.      * @param pet
  36.      * @param pets
  37.      */
  38.     void addPets(Pet pet,ArrayList<Pet>pets);
  39.  
  40.     /**
  41.      * 按名字修改宠物信息
  42.      * @param name
  43.      * @param pets
  44.      */
  45.     void updatePets(String name,ArrayList<Pet>pets);
  46.  
  47.     /**
  48.      * 根据购入价格排序
  49.      * @param pets
  50.      */
  51.     void sortByInprice(ArrayList<Pet>pets);
  52.  
  53.     /**
  54.      * 按售出价格排序
  55.      * @param pets
  56.      */
  57.     void sortByOutPrice(ArrayList<Pet>pets);
  58.  
  59.     /**
  60.      * 根据盈利排序
  61.      * @param pets
  62.      */
  63.     void sortByProfit(ArrayList<Pet>pets);
  64.  
  65.     /**
  66.      * 记录删除的数据
  67.      * @param pets1
  68.      */
  69.     void findDeletePets(ArrayList<Pet>pets1);
  70. }

接口实现类：

  1.  
  2. import org.junit.Test;
  3.  
  4. import java.util.*;
  5. import java.util.stream.Collectors;
  6.  
  7.  
  8. /**
  9.  * 业务类 实现接口
  10.  */
  12. public class PetBiz implements PetAdministration {
  13.     Scanner input = new Scanner(System.in);
  14.     Pet pet4 = new Pet();
  15.  
  16.     /**
  17.      * 显示所有的宠物信息
  18.      *
  19.      * @param pets
  20.      */
  21.     @Override
  22.     public void showAllPets(ArrayList<Pet> pets) {
  23.         if (pets.size() == 0) {
  24.             System.out.println("没有查询到宠物信息!!您的宠物商店还没有宠物!!");
  25.         }
  26.         for (Pet pet : pets) {//遍历集合 调用play方法输出
  27.             if (pet.getName() != null) {
  28.                 pet.play();
  29.             }
  30.         }
  31.     }
  32.  
  33.     /**
  34.      * 根据名字查找宠物 传递参数为宠物姓名
  35.      *
  36.      * @param name
  37.      * @param pets
  38.      */
  39.     @Override
  40.     public void findPetByName(String name, ArrayList<Pet> pets) {
  41.         boolean flag = false;//标志位 flag
  42.         for (Pet pet1 : pets) {//遍历集合
  43.             if (pet1.getName().equals(name)) {//如果传递的参数(name)和集合中的name相同
  44.                 pet1.play();//调用显示方法
  45.                 flag = true;//修改标志位
  46.                 break;//跳出循环
  47.             }
  48.         }
  49.         if (!flag) {//如果遍历后标志位没有变，输出该宠物不存在
  50.             System.out.println(name + "不存在!!");
  51.         }
  52.     }
  53.  
  54.  
  55.     /**
  56.      * 根据宠物名字删除宠物 传递参数为宠物名字 和查找类似，只是在找到后使用remove方法将其从集合中删除
  57.      *
  58.      * @param name
  59.      * @param pets
  60.      */
  61.     @Override
  62.     public void deletePetByName(String name, ArrayList<Pet> pets, ArrayList<Pet> pets1) {
  63.         boolean flag = false;//标志位
  64.         for (Pet pet2 : pets) {
  65.             if (pet2.getName().equals(name)) {
  66.                 pet4 = pet2;
  67.                 pets1.add(pet4);
  68.                 pets.remove(pet2);
  69.                 flag = true;
  70.                 System.out.println("宠物删除成功!!");
  71.                 break;
  72.             }
  73.         }
  74.         if (!flag) {
  75.             System.out.println("删除失败!!!  宠物" + name + "不存在!!");
  76.         }
  77.     }
  78.  
  79.  
  80.     /**
  81.      * 宠物信息
  82.      *
  83.      * @return
  84.      */
  85.     @Override
  86.     public Pet petInformation() {
  87.         System.out.print("宠物名字:");
  88.         String name = input.next();
  89.         System.out.print("年龄:");
  90.         int age = input.nextInt();
  91.         System.out.print("性别:");
  92.         String sex = input.next();
  93.         System.out.print("品种:");
  94.         String strain = input.next();
  95.         System.out.print("购入价格:");
  96.         int inPrice = input.nextInt();
  97.         System.out.print("售出价格:");
  98.         int outPrice = input.nextInt();
  99.         return new Pet(name, age, sex, strain, inPrice, outPrice);
  100.     }
  101.  
  102.     /**
  103.      * 添加宠物信息
  104.      *
  105.      * @param pet
  106.      * @param pets
  107.      */
  108.     @Override
  109.     public void addPets(Pet pet, ArrayList<Pet> pets) {
  110.         pets.add(pet);//对象.add(对象)
  111.     }
  112.  
  113.     /**
  114.      * 修改宠物信息 全部输一遍，把旧的宠物信息删除后再添加新的宠物信息 参数为宠物姓名
  115.      *
  116.      * @param name
  117.      * @param pets
  118.      */
  119.     @Override
  120.     public void updatePets(String name, ArrayList<Pet> pets) {
  121.         boolean flag = false;//标志位
  122.         for (Pet pet2 : pets) {
  123.             if (pet2.getName().equals(name)) {//对比集合中的宠物姓名和输入的宠物姓名 如果相同删除该宠物信息
  124.                 pets.remove(pet2);
  125.                 System.out.println("请输入要修改的宠物信息:");
  126.                 Pet pet3 = petInformation();//调用输入宠物信息的方法
  127.                 pets.add(pet3);
  128.                 flag = true;//修改标志位
  129.                 System.out.println("修改成功!!");
  130.                 break;
  131.             }
  132.         }
  133.         if (!flag) {
  134.             System.out.println(name + "不存在!!");
  135.         }
  136.     }
  137.  
  138.     /**
  139.      * 根据进价排序
  140.      *
  141.      * @param pets
  142.      */
  143.     @Override
  144.     public void sortByInprice(ArrayList<Pet> pets) {
  145.       /*  //Collections是一个工具类，sort是其中的静态方法，是用来对List集合进行排序的
  146.         //当集合中的元素为某个类的实例时，则必须传入比较器，比较器无法省略
  147.         //compare(类名 o1,类名 o2) 返回值为
  148.         //当值>0时，相邻的两个元素o1和o2不交换位置;值<0时，相邻的两个元素o1和o2交换位置。
  149.         // 需要注意的是，o1是List中下标较大的那个元素，o2是List中下标较小的那个元素
  150.         Collections.sort(pets, (o1, o2) -> o1.getInPrice() - o2.getInPrice());*/
  151.         /*双冒号（::）运算符在Java 8中被用作方法引用（method reference）*/
  152.         Collections.sort(pets, Comparator.comparingInt(Pet::getInPrice).reversed());
  153.     }
  154.  
  155.     /**
  156.      * 按售价排序 排序方法一致
  157.      *
  158.      * @param pets
  159.      */
  160.     @Override
  161.     public void sortByOutPrice(ArrayList<Pet> pets) {
  162.         Collections.sort(pets, Comparator.comparingInt(Pet::getOutPrice));
  163.     }
  164.  
  165.     /**
  166.      * 按利润排序 还可以引申出按其他各种价格排序的方法
  167.      *
  168.      * @param pets
  169.      */
  170.     @Override
  171.     public void sortByProfit(ArrayList<Pet> pets) {
  172.         Collections.sort(pets, Comparator.comparingInt(o -> (o.getOutPrice() - o.getInPrice())));
  173.     }
  174.  
  175.     /**
  176.      * 查看被删除的数据
  177.      *
  178.      * @param pets1
  179.      */
  180.     @Override
  181.     public void findDeletePets(ArrayList<Pet> pets1) {
  182.         if (pets1.size() == 0) {
  183.             System.out.println("还没有删除数据哦!!!");
  184.         } else {
  185.             for (Pet pet : pets1) {
  186.                 pet.play();
  187.             }
  188.         }
  189.     }
  190. }

工具类：

  1.  
  2. import org.junit.Test;
  3.  
  4. import java.text.SimpleDateFormat;
  5. import java.util.*;
  6.  
  7. public class Tool1 {
  8.     //属性
  9.     String userName;//用户名
  10.     String password;//密码
  11.     Map<String, String> map = new HashMap<>();
  12.     Scanner input = new Scanner(System.in);
  13.  
  14.     @Test
  15.     public void register() {//注册
  16.         map.put("zsss1", "111111");//初始化信息
  17.         map.put("admin1", "123456");
  18.         map.put("admin", "111111");
  19.         System.out.println("*****欢迎使用宠物商店管理系统!!!*****");
  20.         while (true) {
  21.             System.out.println("请选择要进行的操作:1、注册 2、登录");//菜单
  22.             int num3 = input.nextInt();
  23.             if (num3 == 1) {//注册
  24.                 while (true) {
  25.                     System.out.print("请输入用户名:");
  26.                     userName = input.next();
  27.                     System.out.print("请输入密码:");
  28.                     password = input.next();
  29.                     System.out.print("请再次输入密码:");
  30.                     String password1 = input.next();
  31.                     boolean flag = false;//标志位
  32.                     //执行分支 判断用户名和密码长度是否满足
  33.                     if (userName.length() > 3 && password1.length() >= 6) {//判断信息长度是否满足设置的要求
  34.                         //判断用户名是否已存在 用map集合中的键和用户名对比，用户名不存在，将其加入到集合中，存在给出提示
  35.                         // Set keySet = map.keySet();//key的set集合，即map集合中所有的userName
  36.                         //只需要对比用户名即可，如果用户名存在，修改标志位，不存在继续执行下一步操作
  37.                         String[] str = map.keySet().toArray(new String[map.keySet().size()]);
  38.                         for (int i = 0; i < str.length; i++) {
  39.                             if (str[i].equals(userName)) {//用户名与map集合中的键相同
  40.                                 flag = true;//修改标志位
  41.                                 break;
  42.                             }
  43.                         }
  44.                         if (flag) {//flag==true  对比标志位，如果存在，即执行了上述循环中的if语句
  45.                             System.out.println("用户已存在!!");//输出提示信息后继续执行循环
  46.                         } else {//flag为false，即集合中不存在对应的用户名，可以注册
  47.                             if (password.equals(password1)) {//对比两次输入的密码是否一致 如果一致，将其存入集合
  48.                                 map.put(userName, password);//键值对，键为用户名，值为密码
  49.                                 System.out.println("注册成功,请牢记用户名和密码!!");
  50.                                 break;
  51.                             } else {//前后密码不一致，不用跳出循环
  52.                                 System.out.println("两次密码不相同!!");
  53.                                 //用户名与map集合中的元素不相同，判断密码是否相同
  54.                             }
  55.                         }
  56.                     } else {//最开始执行的判断密码和用户名长度是否满足需求中的不满足需求，不满足跳出循环，执行外层循环，继续询问
  57.                         System.out.println("用户名长度不能小于3,密码长度不能小于6!!");
  58.                         break;
  59.                     }
  60.                 }
  61.             } else if (num3 == 2) {//登录
  62.                 Date date = new Date();//时间类
  63.                 System.out.println("请输入用户名和密码进行登录!!");
  64.                 System.out.print("请输入用户名:");//输入登录账户
  65.                 String userName2 = input.next();
  66.                 System.out.print("请输入密码:");
  67.                 String password2 = input.next();//输入密码
  68.                 SimpleDateFormat sd = new SimpleDateFormat("HH");//时间格式化后输出获取时间的小时，根据小时数来判断时间段
  69.                 String str = sd.format(date);//将格式化后的时间(小时)转为字符串
  70.                 int a = Integer.parseInt(str);//parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析,返回用十进制参数表示的整数值
  71.                 String time = "";
  72.                 if (a >= 0 && a <= 6) {
  73.                     time = "凌晨";
  74.                 } else if (a >= 7 && a < 12) {
  75.                     time = "上午";
  76.                 } else if (a >= 13 && a < 19) {
  77.                     time = "下午";
  78.                 } else if (a >= 20) {
  79.                     time = "晚上";
  80.                 }
  81.                 if (map.get(userName2) == null) {//map集合中获取输入的用户名返回值为null，用户不存在
  82.                     System.out.println("用户不存在");
  83.                 } else if (map.get(userName2).equals(password2)) {//返回值非空，用户存在，对比输入的密码和集合中获取的密码
  84.                     //System.out.println(map.get(userName2)+"***"+password2);
  85.                     System.out.println("登录成功!!");
  86.                     System.out.println(userName2 + time + "好 欢迎登录宠物商店管理系统!!!");
  87.                     break;
  88.                 } else {//用户不存在 用户存在但是密码不匹配 用户存在且密码匹配
  89.                     System.out.println("登录失败，密码错误!!!");
  90.                 }
  91.             } else {
  92.                 System.out.println("您的输入有误!!!");
  93.                 continue;
  94.             }
  95.         }
  96.     }
  97.  
  98. }

测试类：

  1.  
  2. import java.util.ArrayList;
  3. import java.util.Scanner;
  4.  
  5. /**
  6.  * 测试类
  7.  */
  8. public class TestPet {
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         //注册和登录
  12.         Tool1 tool1 = new Tool1();//新建对象
  13.         tool1.register();//调用方法
  14.         PetBiz petBiz = new PetBiz();
  15.         ArrayList<Pet> pets = new ArrayList<>();
  16.         ArrayList<Pet> pets1 = new ArrayList<>();
  17.         System.out.println("********宠物商店管理系统********");
  18.         //初始化数据
  19.         pets.add(new Pet("小白", 1, "F", "狗", 100, 200));
  20.         pets.add(new Pet("张三", 2, "M", "猫", 200, 400));
  21.         pets.add(new Pet("小小", 3, "F", "狗", 900, 876));
  22.         while (true) {
  23.             System.out.println("请选择要执行的操作:1.查看所有宠物 2.按名字查找宠物 3.删除宠物 4.添加宠物 " +
  24.                     "5.修改宠物信息 6.按购入价格排序 7.按出售价格排序 8.按利润排序 9.查看删除记录 0.退出");
  25.             try {
  26.                 int num = input.nextInt();
  27.                 switch (num) {//分支选择要进行的操作
  28.                     case 1:
  29.                         petBiz.showAllPets(pets);//查看所有宠物信息
  30.                         break;
  31.                     case 2:
  32.                         System.out.print("请输入要查找的宠物名字:");
  33.                         String name = input.next();
  34.                         petBiz.findPetByName(name, pets);//按名字查找宠物
  35.                         break;
  36.                     case 3:
  37.                         System.out.print("请输入要删除的宠物的名字:");
  38.                         String name1 = input.next();
  39.                         petBiz.deletePetByName(name1, pets, pets1);//按名字删除宠物
  40.                         break;
  41.                     case 4:
  42.                         Pet pet = petBiz.petInformation();//添加宠物信息
  43.                         pets.add(pet);//将传递的宠物信息添加到集合中
  44.                         System.out.println("添加成功!!");//输出提示信息
  45.                         break;
  46.                     case 5:
  47.                         System.out.print("请输入要修改的宠物名字:");
  48.                         String name2 = input.next();//录入需要修改的宠物信息
  49.                         petBiz.updatePets(name2, pets);//调用修改宠物信息的方法，传递参数为录入的宠物姓名
  50.                         break;
  51.                     case 6:
  52.                         petBiz.sortByInprice(pets);//调用按进价排序的方法
  53.                         petBiz.showAllPets(pets);//将排序后的集合输出
  54.                         break;
  55.                     case 7:
  56.                         petBiz.sortByOutPrice(pets);
  57.                         petBiz.showAllPets(pets);
  58.                         break;
  59.                     case 8:
  60.                         petBiz.sortByProfit(pets);
  61.                         petBiz.showAllPets(pets);
  62.                         break;
  63.                     case 9:
  64.                         petBiz.findDeletePets(pets1);//查看已经删除的数据信息
  65.                         break;
  66.                     case 0:
  67.                         System.out.println("再见,欢迎再次使用宠物管理系统!!!");
  68.                         System.exit(1);
  69.                     default:
  70.                         System.out.println("您的选择有误!!!请重新选择!!!");
  71.                 }
  72.             } catch (Exception e) {
  73.                 System.out.println("输入错误!!!");
  74.                 break;
  75.             }
  76.         }
  77.     }
  78. }

实现注册登录功能后进行宠物管理，有一些异常因为没有重写异常类，只能抛出异常，没有进行处理

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/374934
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号