java宠物商店管理系统

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

宠物抽象类：

/**
 * 宠物类
 */
public class Pet {
    //属性
    private String name;//宠物名字
    private int age;//年龄
    private String sex;//性别
    private String strain;//品种
    private int inPrice;//购入价格
    private int outPrice;//出售价格

    //方法
    //getter/setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    public int getInPrice() {
        return inPrice;
    }

    public void setInPrice(int inPrice) {
        this.inPrice = inPrice;
    }

    public int getOutPrice() {
        return outPrice;
    }

    public void setOutPrice(int outPrice) {
        this.outPrice = outPrice;
    }

    //无参构造方法
    public Pet() {
    }

    //含所有参数的构造方法
    public Pet(String name, int age, String sex, String strain, int inPrice, int outPrice) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.strain = strain;
        this.inPrice = inPrice;
        this.outPrice = outPrice;
    }

    //显示方法 printf沿用了C的printf,用法也完全一致 第一组参数(占位符)代表要输出的类型,第二组参数代表待输出的数据对象
    public void play() {//输出错误信息  通过this关键字来调用属性
        System.out.printf("宠物:%s\t\t年龄:%d\t\t性别:%s\t\t品种:%s\t\t购入价格:%d\t\t售出价格:%d\t\t利润:%d\n",
                this.name, this.age, this.sex, this.strain, this.inPrice, this.outPrice, (this.outPrice - this.inPrice));
    }
}

宠物管理接口：

import java.util.ArrayList;
//宠物管理接口
public interface PetAdministration {
    /**
     * 显示所有宠物信息
     * @param pets
     */
    void showAllPets(ArrayList<Pet>pets);

    /**
     *根据名字查找宠物
     * @param name
     * @param pets
     */
    void findPetByName(String name,ArrayList<Pet>pets);

    /**
     * 根据名字删除宠物信息，先根据名字找到对应的宠物信息，将其加到另一个集合中后从原集合删除，
     * 从原集合被删除的被存入新集合，实现记录数据
     * @param name
     * @param pets
     * @param pets1
     */
    void deletePetByName(String name,ArrayList<Pet>pets,ArrayList<Pet> pets1);

    /**
     * 宠物信息
     * @return
     */
    Pet petInformation();

    /**
     * 添加宠物信息
     * @param pet
     * @param pets
     */
    void addPets(Pet pet,ArrayList<Pet>pets);

    /**
     * 按名字修改宠物信息
     * @param name
     * @param pets
     */
    void updatePets(String name,ArrayList<Pet>pets);

    /**
     * 根据购入价格排序
     * @param pets
     */
    void sortByInprice(ArrayList<Pet>pets);

    /**
     * 按售出价格排序
     * @param pets
     */
    void sortByOutPrice(ArrayList<Pet>pets);

    /**
     * 根据盈利排序
     * @param pets
     */
    void sortByProfit(ArrayList<Pet>pets);

    /**
     * 记录删除的数据
     * @param pets1
     */
    void findDeletePets(ArrayList<Pet>pets1);
}

接口实现类：

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;


/**
 * 业务类 实现接口
 */

public class PetBiz implements PetAdministration {
    Scanner input = new Scanner(System.in);
    Pet pet4 = new Pet();

    /**
     * 显示所有的宠物信息
     *
     * @param pets
     */
    @Override
    public void showAllPets(ArrayList<Pet> pets) {
        if (pets.size() == 0) {
            System.out.println("没有查询到宠物信息!!您的宠物商店还没有宠物!!");
        }
        for (Pet pet : pets) {//遍历集合 调用play方法输出
            if (pet.getName() != null) {
                pet.play();
            }
        }
    }

    /**
     * 根据名字查找宠物 传递参数为宠物姓名
     *
     * @param name
     * @param pets
     */
    @Override
    public void findPetByName(String name, ArrayList<Pet> pets) {
        boolean flag = false;//标志位 flag
        for (Pet pet1 : pets) {//遍历集合
            if (pet1.getName().equals(name)) {//如果传递的参数(name)和集合中的name相同
                pet1.play();//调用显示方法
                flag = true;//修改标志位
                break;//跳出循环
            }
        }
        if (!flag) {//如果遍历后标志位没有变，输出该宠物不存在
            System.out.println(name + "不存在!!");
        }
    }


    /**
     * 根据宠物名字删除宠物 传递参数为宠物名字 和查找类似，只是在找到后使用remove方法将其从集合中删除
     *
     * @param name
     * @param pets
     */
    @Override
    public void deletePetByName(String name, ArrayList<Pet> pets, ArrayList<Pet> pets1) {
        boolean flag = false;//标志位
        for (Pet pet2 : pets) {
            if (pet2.getName().equals(name)) {
                pet4 = pet2;
                pets1.add(pet4);
                pets.remove(pet2);
                flag = true;
                System.out.println("宠物删除成功!!");
                break;
            }
        }
        if (!flag) {
            System.out.println("删除失败!!!  宠物" + name + "不存在!!");
        }
    }


    /**
     * 宠物信息
     *
     * @return
     */
    @Override
    public Pet petInformation() {
        System.out.print("宠物名字:");
        String name = input.next();
        System.out.print("年龄:");
        int age = input.nextInt();
        System.out.print("性别:");
        String sex = input.next();
        System.out.print("品种:");
        String strain = input.next();
        System.out.print("购入价格:");
        int inPrice = input.nextInt();
        System.out.print("售出价格:");
        int outPrice = input.nextInt();
        return new Pet(name, age, sex, strain, inPrice, outPrice);
    }

    /**
     * 添加宠物信息
     *
     * @param pet
     * @param pets
     */
    @Override
    public void addPets(Pet pet, ArrayList<Pet> pets) {
        pets.add(pet);//对象.add(对象)
    }

    /**
     * 修改宠物信息 全部输一遍，把旧的宠物信息删除后再添加新的宠物信息 参数为宠物姓名
     *
     * @param name
     * @param pets
     */
    @Override
    public void updatePets(String name, ArrayList<Pet> pets) {
        boolean flag = false;//标志位
        for (Pet pet2 : pets) {
            if (pet2.getName().equals(name)) {//对比集合中的宠物姓名和输入的宠物姓名 如果相同删除该宠物信息
                pets.remove(pet2);
                System.out.println("请输入要修改的宠物信息:");
                Pet pet3 = petInformation();//调用输入宠物信息的方法
                pets.add(pet3);
                flag = true;//修改标志位
                System.out.println("修改成功!!");
                break;
            }
        }
        if (!flag) {
            System.out.println(name + "不存在!!");
        }
    }

    /**
     * 根据进价排序
     *
     * @param pets
     */
    @Override
    public void sortByInprice(ArrayList<Pet> pets) {
      /*  //Collections是一个工具类，sort是其中的静态方法，是用来对List集合进行排序的
        //当集合中的元素为某个类的实例时，则必须传入比较器，比较器无法省略
        //compare(类名 o1,类名 o2) 返回值为
        //当值>0时，相邻的两个元素o1和o2不交换位置;值<0时，相邻的两个元素o1和o2交换位置。
        // 需要注意的是，o1是List中下标较大的那个元素，o2是List中下标较小的那个元素
        Collections.sort(pets, (o1, o2) -> o1.getInPrice() - o2.getInPrice());*/
        /*双冒号（::）运算符在Java 8中被用作方法引用（method reference）*/
        Collections.sort(pets, Comparator.comparingInt(Pet::getInPrice).reversed());
    }

    /**
     * 按售价排序 排序方法一致
     *
     * @param pets
     */
    @Override
    public void sortByOutPrice(ArrayList<Pet> pets) {
        Collections.sort(pets, Comparator.comparingInt(Pet::getOutPrice));
    }

    /**
     * 按利润排序 还可以引申出按其他各种价格排序的方法
     *
     * @param pets
     */
    @Override
    public void sortByProfit(ArrayList<Pet> pets) {
        Collections.sort(pets, Comparator.comparingInt(o -> (o.getOutPrice() - o.getInPrice())));
    }

    /**
     * 查看被删除的数据
     *
     * @param pets1
     */
    @Override
    public void findDeletePets(ArrayList<Pet> pets1) {
        if (pets1.size() == 0) {
            System.out.println("还没有删除数据哦!!!");
        } else {
            for (Pet pet : pets1) {
                pet.play();
            }
        }
    }
}

工具类：

import org.junit.Test;

import java.text.SimpleDateFormat;
import java.util.*;

public class Tool1 {
    //属性
    String userName;//用户名
    String password;//密码
    Map<String, String> map = new HashMap<>();
    Scanner input = new Scanner(System.in);

    @Test
    public void register() {//注册
        map.put("zsss1", "111111");//初始化信息
        map.put("admin1", "123456");
        map.put("admin", "111111");
        System.out.println("*****欢迎使用宠物商店管理系统!!!*****");
        while (true) {
            System.out.println("请选择要进行的操作:1、注册 2、登录");//菜单
            int num3 = input.nextInt();
            if (num3 == 1) {//注册
                while (true) {
                    System.out.print("请输入用户名:");
                    userName = input.next();
                    System.out.print("请输入密码:");
                    password = input.next();
                    System.out.print("请再次输入密码:");
                    String password1 = input.next();
                    boolean flag = false;//标志位
                    //执行分支 判断用户名和密码长度是否满足
                    if (userName.length() > 3 && password1.length() >= 6) {//判断信息长度是否满足设置的要求
                        //判断用户名是否已存在 用map集合中的键和用户名对比，用户名不存在，将其加入到集合中，存在给出提示
                        // Set keySet = map.keySet();//key的set集合，即map集合中所有的userName
                        //只需要对比用户名即可，如果用户名存在，修改标志位，不存在继续执行下一步操作
                        String[] str = map.keySet().toArray(new String[map.keySet().size()]);
                        for (int i = 0; i < str.length; i++) {
                            if (str[i].equals(userName)) {//用户名与map集合中的键相同
                                flag = true;//修改标志位
                                break;
                            }
                        }
                        if (flag) {//flag==true  对比标志位，如果存在，即执行了上述循环中的if语句
                            System.out.println("用户已存在!!");//输出提示信息后继续执行循环
                        } else {//flag为false，即集合中不存在对应的用户名，可以注册
                            if (password.equals(password1)) {//对比两次输入的密码是否一致 如果一致，将其存入集合
                                map.put(userName, password);//键值对，键为用户名，值为密码
                                System.out.println("注册成功,请牢记用户名和密码!!");
                                break;
                            } else {//前后密码不一致，不用跳出循环
                                System.out.println("两次密码不相同!!");
                                //用户名与map集合中的元素不相同，判断密码是否相同
                            }
                        }
                    } else {//最开始执行的判断密码和用户名长度是否满足需求中的不满足需求，不满足跳出循环，执行外层循环，继续询问
                        System.out.println("用户名长度不能小于3,密码长度不能小于6!!");
                        break;
                    }
                }
            } else if (num3 == 2) {//登录
                Date date = new Date();//时间类
                System.out.println("请输入用户名和密码进行登录!!");
                System.out.print("请输入用户名:");//输入登录账户
                String userName2 = input.next();
                System.out.print("请输入密码:");
                String password2 = input.next();//输入密码
                SimpleDateFormat sd = new SimpleDateFormat("HH");//时间格式化后输出获取时间的小时，根据小时数来判断时间段
                String str = sd.format(date);//将格式化后的时间(小时)转为字符串
                int a = Integer.parseInt(str);//parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析,返回用十进制参数表示的整数值
                String time = "";
                if (a >= 0 && a <= 6) {
                    time = "凌晨";
                } else if (a >= 7 && a < 12) {
                    time = "上午";
                } else if (a >= 13 && a < 19) {
                    time = "下午";
                } else if (a >= 20) {
                    time = "晚上";
                }
                if (map.get(userName2) == null) {//map集合中获取输入的用户名返回值为null，用户不存在
                    System.out.println("用户不存在");
                } else if (map.get(userName2).equals(password2)) {//返回值非空，用户存在，对比输入的密码和集合中获取的密码
                    //System.out.println(map.get(userName2)+"***"+password2);
                    System.out.println("登录成功!!");
                    System.out.println(userName2 + time + "好 欢迎登录宠物商店管理系统!!!");
                    break;
                } else {//用户不存在 用户存在但是密码不匹配 用户存在且密码匹配
                    System.out.println("登录失败，密码错误!!!");
                }
            } else {
                System.out.println("您的输入有误!!!");
                continue;
            }
        }
    }

}

测试类：

import java.util.ArrayList;
import java.util.Scanner;

/**
 * 测试类
 */
public class TestPet {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //注册和登录
        Tool1 tool1 = new Tool1();//新建对象
        tool1.register();//调用方法
        PetBiz petBiz = new PetBiz();
        ArrayList<Pet> pets = new ArrayList<>();
        ArrayList<Pet> pets1 = new ArrayList<>();
        System.out.println("********宠物商店管理系统********");
        //初始化数据
        pets.add(new Pet("小白", 1, "F", "狗", 100, 200));
        pets.add(new Pet("张三", 2, "M", "猫", 200, 400));
        pets.add(new Pet("小小", 3, "F", "狗", 900, 876));
        while (true) {
            System.out.println("请选择要执行的操作:1.查看所有宠物 2.按名字查找宠物 3.删除宠物 4.添加宠物 " +
                    "5.修改宠物信息 6.按购入价格排序 7.按出售价格排序 8.按利润排序 9.查看删除记录 0.退出");
            try {
                int num = input.nextInt();
                switch (num) {//分支选择要进行的操作
                    case 1:
                        petBiz.showAllPets(pets);//查看所有宠物信息
                        break;
                    case 2:
                        System.out.print("请输入要查找的宠物名字:");
                        String name = input.next();
                        petBiz.findPetByName(name, pets);//按名字查找宠物
                        break;
                    case 3:
                        System.out.print("请输入要删除的宠物的名字:");
                        String name1 = input.next();
                        petBiz.deletePetByName(name1, pets, pets1);//按名字删除宠物
                        break;
                    case 4:
                        Pet pet = petBiz.petInformation();//添加宠物信息
                        pets.add(pet);//将传递的宠物信息添加到集合中
                        System.out.println("添加成功!!");//输出提示信息
                        break;
                    case 5:
                        System.out.print("请输入要修改的宠物名字:");
                        String name2 = input.next();//录入需要修改的宠物信息
                        petBiz.updatePets(name2, pets);//调用修改宠物信息的方法，传递参数为录入的宠物姓名
                        break;
                    case 6:
                        petBiz.sortByInprice(pets);//调用按进价排序的方法
                        petBiz.showAllPets(pets);//将排序后的集合输出
                        break;
                    case 7:
                        petBiz.sortByOutPrice(pets);
                        petBiz.showAllPets(pets);
                        break;
                    case 8:
                        petBiz.sortByProfit(pets);
                        petBiz.showAllPets(pets);
                        break;
                    case 9:
                        petBiz.findDeletePets(pets1);//查看已经删除的数据信息
                        break;
                    case 0:
                        System.out.println("再见,欢迎再次使用宠物管理系统!!!");
                        System.exit(1);
                    default:
                        System.out.println("您的选择有误!!!请重新选择!!!");
                }
            } catch (Exception e) {
                System.out.println("输入错误!!!");
                break;
            }
        }
    }
}

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