SCAU 简易产品管理程序

随堂实验7 简易产品管理程序

题目类别: C实验

关键字: 接口

内容要求:

步骤1：定义一个产品类Product

(1) 位于data包

(2) 数据域有：编号（String）、名称(String)、价格（double）、库存数量（int）、上架日期（java.util.Date）

(3) 对数据域进行封装

(4) 定义1个无参构造方法和1个有参构造方法

(5) 实现 Comparable 接口，以编号作为比较依据

(6) 实现 Cloneable 接口，要求实现深克隆

(7) 重写equals和hashCode方法

步骤2：为Product定义3个比较器, 实现Comparator接口

(1) 以 价格 为依据

(2) 以 库存数量 为依据

(3) 以 上架日期 为依据

步骤3：定义ProductManager类

(1) 定义存放多个产品对象的Product数组

(2) 增加产品功能，

输入产品编号，

如果产品已经在数组中，则要求输入增加的数量，在数组中找到该产品并增加该产品数量；

如果产品不存在，则要求输入：名称、价格、数量，创建对象后增加到数组中，上架日期是创建对象时的时间。

(3) 产品销售功能，

输入产品编号，

如果产品不在数组内，则提示产品编号输入错误

如果产品在数组内，则显示产品信息，并要求输入销售数量，如果销售数量>库存数量，则提示库存数量不足；否则减少库存数量。

(4)产品查询功能

可以根据选择分别按照：编号、名称、价格、库存数量、上架日期 排序后显示所有产品，格式如下：

编号 名称 价格 库存数量 库存金额 上架日期

---

1 A 200.00 100 20000.00 2019.01.01

(5)产品统计功能

统计并输出总库存数量和总库存金额

总结：
1.compareTo
它是先比较对应字符的大小(ASCII码顺序)，返回值类型分别有三种，小于0，等于0，大于0
如果字符串相等返回值0；
如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值（ascii码值）（负值前字符串的值小于后字符串，正值前字符串大于后字符串）；
如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推，直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度。
2.深度克隆和浅度克隆的主要区别就是他们在克隆引用类型的数据变量（Date）的时候，一个是共用空间，一个是新开一个空间。
多个p.date = (Date) this.date.clone();
ps：作业题目比较短，但要求是真的多啊🤧 累了 晚安宝

@Override
   public Object clone(){
       try {
           Product p = (Product) super.clone();
           p.date = (Date) this.date.clone();
           return p;
       }
       catch (CloneNotSupportedException e) {
           return null;
       }
   }

Main

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        ProductManager products =  new ProductManager();
        Product[] product = products.creatProductManager();
        System.out.println("请输入需要增加产品的编号（1，2，3，4，5）：");
        String num;
        Scanner cin = new Scanner(System.in);
        num = cin.next();
        products.increaseProducts(num,product);

        System.out.println("产品销售，先输入产品编号：");
        String id;
        id = cin.next();
        products.saleProducts(id,product);

        System.out.println("产品查询功能");
        products.sortProducts(product);

        System.out.println();
        System.out.println("产品统计功能");
        products.staticsProducts(product);


    }
}

Product

import java.util.Comparator;
import java.util.Date;
import java.lang.Cloneable;
import java.util.Objects;

public class Product implements Comparator<Product>,Cloneable {
    private String number;
    private String name;
    private double price;
    private int count;
    private java.util.Date date;

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    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 int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public Product(String number, String name, double price, int count, Date date) {
        this.number = number;
        this.name = name;
        this.price = price;
        this.count = count;
        this.date = date;
    }

    public Product() {
    }

    @Override
    public int compare(Product p1, Product p2){
        return p1.number.compareTo(p2.number);
    }

    @Override
    public Object clone(){
        try {
            Product p = (Product) super.clone();
            p.date = (Date) this.date.clone();
            return p;
        }
        catch (CloneNotSupportedException e) {
            return null;
        }
    }

    @Override
    public boolean equals(Object O){
        if(O == null)return false;
        if(O.getClass()!=this.getClass())return false;
        Product p = (Product) O;
        return this.number.equals(p.number);
    }

    @Override
    public int hashCode(){
        return Objects.hashCode(number);
    }

}

ProductManager

import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;

public class ProductManager extends Product {
    public int num=4;

    public Product[] creatProductManager(){
        Product[] products = new Product[100];
        products[0] = new Product("1","B",200,100, new Date());
        products[1] = new Product("2","A",300,200, new Date());
        products[2] = new Product("3","D",400,300, new Date());
        products[3] = new Product("4","C",500,400, new Date());
        return products;
    }

    public boolean increaseProducts(String number,Product[] p2){
        for (int i=0;i<num;i++) {
            if (number.equals(p2[i].getNumber())) {
                int currentCount = p2[i].getCount() + 1;
                p2[i].setCount(currentCount);
                System.out.println("已查询到该产品，并在该产品的库存数量加1");
                printProducts(p2);
                return true;
            }
        }
            String name;
            double price;
            int count;
            System.out.println("未查询到产品，新建产品");
            System.out.println("请分别输入新建产品的名称、价格、数量");
            Scanner cin = new Scanner(System.in);
            name = cin.next();
            price = cin.nextDouble();
            count = cin.nextInt();
            num+=1;
            p2[num] = new Product(number,name,price,count,new Date());
            printProducts(p2);
            return true;

    }

    public boolean saleProducts(String number, Product[] products){
        for (Product product : products) {
            if (number.equals(product.getNumber())) {
                int saleCount;
                System.out.println("请输入该产品的销售数量：");
                Scanner cin = new Scanner(System.in);
                saleCount = cin.nextInt();
                if (saleCount > product.getCount()) {
                    System.out.println("库存数量不足!");
                    return true;
                } else {
                    product.setCount(product.getCount() - saleCount);
                    System.out.println("已减少库存数量!");
                    printProducts(products);
                    return true;
                }
            }
        }
        System.out.println("产品编号输入错误!");
        return false;
    }

    public void printProducts(Product[] products){
        System.out.println("编号  名称     价格     库存数量    库存金额    上架日期\n" +
                "-------------------------------------------------------------------------");
        for (int i=0;i<num;i++){
            System.out.println(products[i].getNumber()+"     "+products[i].getName()+"     "+products[i].getPrice()+"     "+products[i].getCount()+"     "+products[i].getCount()*products[i].getPrice()+"     "+products[i].getDate());
        }
}

    public void sortProducts(Product[] products){
        System.out.println("可以根据选择分别按照：1.编号、2.名称、3.价格、4.库存数量、5.上架日期 排序后显示所有产品");
        System.out.println("请输入编号：");
        int nums;
        Scanner cin = new Scanner(System.in);
        nums = cin.nextInt();
        if(nums == 1) {
            Arrays.sort(products);
            printProducts(products);
        }
        else if(nums == 2){
            Arrays.sort(products,0,num,new CompareName());
            printProducts(products);
        }
        else if(nums == 3){
            Arrays.sort(products,0,num,new ComparePrice());
            printProducts(products);
        }
        else if(nums == 4){
            Arrays.sort(products,0,num,new CompareCount());
        }
        else if(nums == 5){
            Arrays.sort(products,0,num, new CompareDate());
        }
        else {
            System.out.println("输入有误！");
        }

    }

    public void staticsProducts (Product[] products){
        int totalCount = 0;
        int totalPrice = 0;
        for(int i=0;i<num;i++){
            totalCount += products[i].getCount();
            totalPrice += products[i].getPrice()*products[i].getCount();
        }
        System.out.println("总库存数量和总库存金额分别是"+totalCount+"和"+totalPrice);
    }


}

CompareCount

import java.util.Comparator;

public class CompareCount implements Comparator<Product> {
    @Override
    public int compare(Product p1, Product p2){
        return p1.getCount()-p2.getCount();
    }
}

CompareDate

import java.util.Comparator;

public class CompareDate implements Comparator<Product> {
    @Override
    public int compare(Product p1, Product p2){
        return p1.getDate().compareTo(p2.getDate());
    }
}

CompareName

import java.util.Comparator;

public class CompareName implements Comparator<Product> {
    @Override
    public int compare(Product p1,Product p2){
        return p1.getName().compareTo(p2.getName());
    }
}

ComparePrice

import java.util.Comparator;

public class ComparePrice implements Comparator<Product> {
    @Override
    public int compare(Product p1,Product p2){
        return Double.compare(p1.getPrice(),p2.getPrice());
    }
}