soso移动营业厅

名称：soso移动营业厅

项目功能分析：

个人：注册，登录，查看个人信息，修改个人信息（修改密码），充值，查看我的业务，查看业务大厅（已发布），办理业务，终止业务

管理员：查看所有人信息，查看现有业务，查看可以办理的业务，未发布项目，添加业务（添加完成之后，在未发布中），发布新业务（未发布的业务发布出去），

删除业务（不做删除，业务的上架和下架，改为未发布），修改业务价格

原有用户有2个，管理员1个：

管理员：用户名：admin, 密码：admin , 这个用户名不允许用户注册

数据库：

使用集合模拟数据库的功能，用于数据的存储（个人，业务），个人密码进行加密操作（MD5）

用户对象分析：

用户编号，用户名，密码，姓名，手机号，身份证号码，arrayList<我的业务>，余额

业务类

业务编号，业务标题，业务描述（详情），业务价格，业务状态（1，正常办理，上架业务，0 业务下架 - 看不到的）

//用户类

public class User {
    private int userId;//用户编号
    private String username;//用户名
    private String password;//密码
    private String name;//姓名
    private int phone;//手机号
    private String codeId;//身份证号
    private ArrayList<Services>  myservice;//我的业务
    private double money;//余额
    public User(int userId, String username, String password, String name,
            int phone, String codeId, ArrayList<Services> myservice, double money) {
        super();
        this.userId = userId;
        this.username = username;
        this.password = password;
        this.name = name;
        this.phone = phone;
        this.codeId = codeId;
        this.myservice = myservice;
        this.money = money;
    }
    public User(int userId, String username, String password) {
        super();
        this.userId = userId;
        this.username = username;
        this.password = password;
    }
    public User() {
        super();
    }
    public String toString() {
        return "User [用户编号：" + userId + ", 用户名：" + username
                + ", 密码：" + password + ", 姓名：" + name + ", 手机号："
                + phone + ", 身份证号：" + codeId + ", 我的业务：" + myservice
                + ", 余额：" + money + "]";
    }
    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPhone() {
        return phone;
    }
    public void setPhone(int phone) {
        this.phone = phone;
    }
    public String getCodeId() {
        return codeId;
    }
    public void setCodeId(String codeId) {
        this.codeId = codeId;
    }
    public ArrayList<Services> getMyservice() {
        return myservice;
    }
    public void setMyservice(ArrayList<Services> myservice) {
        this.myservice = myservice;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }

}

//业务类

public class Services {

    private int sid;//业务编号
    private String title;//业务标题
    private String desc;//业务描述
    private double price;//业务价格
    private int state;//业务状态,1表示可以办理，0表示不可办理
    public Services() {
        super();
    }
    public Services(int sid, String title, String desc, double price, int state) {
        super();
        this.sid = sid;
        this.title = title;
        this.desc = desc;
        this.price = price;
        this.state = state;
    }
    public String toString() {
        return "Service [业务编号:" + sid + ",业务标题:" + title + ", 业务描述:" + desc
                + ", 业务价格:" + price + ", 业务状态:" + state + "]";
    }

    public int getSid() {
        return sid;
    }
    public void setSid(int sid) {
        this.sid = sid;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
    }
}

//首页

public class index 
{
    
    static Scanner sc=null;//定义一个控制台输入的静态成员变量，可被静态方法调用
    static List<User> users=null;//定义一个用户集合
    static List<Services> services=null;//定义一个业务集合
    static String loginUsername=null;//定义一个用户名字符串
    
    static
    {
        sc=new Scanner(System.in);
        users =new ArrayList<User>();
        services =new ArrayList<Services>();
        
        User admin=new User(0,"admin","21232f297a57a5a743894a0e4a801fb3");
        User u1=new User(1, "lili", "e10adb3949ba59abbe56e057f20f883e","李丽" ,1821131415,"31231241241222",null,10);//密码是由123456加密
        User u2=new User(2, "zhangsan", "96e79218965eb72b92a549dd5a330112");//密码是由111111加密的
        
        users.add(admin);//把用户对象admin添加进集合users
        users.add(u1);//把用户对象u1添加进集合users
        users.add(u2);//把用户对象u2添加进集合users
        
        Services s1=new Services(1001,"10元3本秘籍成为强者","降龙十八掌，易筋经，独孤九剑，一阳指",1.0,1);
        Services s2=new Services(1002,"英雄联盟皮肤等你来拿","凤凰盛典，等你抽取皮肤，100元抽十次",100,1);
        Services s3=new Services(1003,"100M宽带来免费抽取","soso十周年，有1元抽取100M宽带活动",1,0);
        services.add(s1);
        services.add(s2);
        services.add(s3);
    }
    
    
    
    public static void main(String[] args) 
    {
        index();//显示主页的方法
    }

    public static void index() 
    {
        System.out.println("-----欢迎进入soso移动营业厅-----");
        System.out.println("1、注册        2、登录        3、退出      ");
        System.out.print("请选择：");
        
        String num=sc.next();
        //判断输入的是1/2/3或者别的数，进入不同的分支
        switch (num) 
        {
            case "1":
                System.out.println("-----欢迎进入注册页面-----");
                register();//选择1，进入注册页面进行操作
                break;
            case "2":
                System.out.println("-----欢迎进入登录页面-----");
                login();//选择2，进入登录页面进行操作
                break;        
            case "3":选择3，程序退出
                System.out.println("营业厅退出，感谢进入");    
                System.exit(0);
                break;
            default://如果不是1/2/3中的数，则打印输入不正确
                System.out.println("你输入的数不符合要求，请重新来过");
                index();
        }

        
    }

    
    
    //登录操作
    public static void login() 
    {
        System.out.println("请输入用户名：");
        String username = sc.next();
        System.out.println("请输入密码：");
        String pwd = sc.next();
        if(voildLogin(username,pwd))//用户名和密码在集合中存在
        {
            //输入验证码进行校验
            String code = getCode();
            System.out.println("验证码是："+code);
            System.out.print("请输入验证码：");
            String mycode = sc.next();
            if(mycode.equals(code))//验证码输入正确
            {
                loginUsername=username;
                System.out.println("登录成功，");
                //登录成功后要判断是普通用户还是管理员
                if(username.equals("admin"))//如果是管理员的话
                {
                    adminView();//进入管理员页面
                }
                else //如果是普通用户的话
                {
                    userView();//进入普通用户页面
                }
            }
            else //验证码输入错误
            {
                System.out.println("验证码输入错误，请重新登录");
                login();
            }
            
        }
        else
        {
            System.out.println("用户名或密码输入错误，请重新登录");
            login();
        }
    }

    //管理员页面
    public static void adminView() 
    {
        System.out.println("-----欢迎您，尊敬的管理员-----");
        System.out.println("1、查看所有用户信息    2、查看上架业务   3、添加业务   4、下架业务   5、修改业务价格   6、上架业务   7、退出 ");
        System.out.println("请选择：");
        String num = sc.next();
        
        switch (num) {
        case "1":
            //查看用户信息，不过其中密码是加密的
            showInformation();
            break;
        case "2":
            showServices();//查看业务大厅，只能看到状态为1 的业务
            break;
        case "3":
            addServices();//添加业务，添加后的业务状态为0
            break;
        case "4":
            delService();//下架业务，也就是把业务状态置为0
            break;
        case "5":
            alterPrice();//修改上架业务价格
            break;
        case "6":
            groundService();//上架业务，也就是把业务状态置为1
            break;
        case "7":
            index();
            break;
        default:
            System.out.println("输入有误，请重新选择");
            adminView();
        }    
    }
    
    //修改上架业务价格
    public static void alterPrice() {
        showOnlineService();//显示所有上架的业务
        System.out.println("请输入你所要修改的业务编号：");
        int sid=sc.nextInt();
        for (Services s : services) {//遍历业务集合
            if(sid==s.getSid()){//输入的编号与集合业务编号相同
                System.out.println("输入你想要修改的价格：");
                double price = sc.nextDouble();
                if(price>=1&&price<=100)
                {
                    s.setPrice(price);//把修改后的价格存进集合中
                    break;
                }
                else {
                    System.out.println("输入的价格不合理，请重新来过");
                    adminView();
                }
            }
        }
        goBack();
    }

    //把未上架的业务上架
    public static void groundService() {
        for (Services s : services)
        {
            if(s.getState()==0)
            {
                System.out.println(s);//打印出未上架的业务
            }
        }
        int flag=0;//设置标志符
        System.out.println("请输入你想上架的业务编号：");
        int sid = sc.nextInt();
        for (Services s1 : services) {
            if(sid==s1.getSid())
            {
                s1.setState(1);//把输入的业务状态置为1，让它上架
                flag=1;
            }
        }
        if(flag==0)
        {
            System.out.println("业务上架失败，编号输入不合理");
            adminView();
        }
        else {
            System.out.println("业务上架成功");
            goBack();
        }
    }

    //下架业务
    public static void delService() {
        showOnlineService();//显示所有上架的业务
        System.out.println("请输入你想下架的业务编号：");
        int sid = sc.nextInt();
        int flag=0;//设置标志符
        for (Services s : services) {
            if(sid==s.getSid())
            {
                s.setState(0);//把输入的业务状态置为1，让它上架
                flag=1;
            }
        }
        if(flag==0)
        {
            System.out.println("业务下架失败，编号输入不合理");
            adminView();
        }
        else {
            System.out.println("业务下架成功");
            goBack();
        }
        
    }

    //显示所有用户信息
    public static void showInformation() {
        for (User u : users) {
            System.out.println(u);
        }
        goBack();
    }

    //添加业务
    //新添加的业务状态默认为0，也就是未上架
    //编号是自动顺延的
    public static void addServices(){
                System.out.println("业务标题：");
                String title = sc.next();
                System.out.println("业务描述：");
                String desc  = sc.next();
                System.out.println("业务价格：");
                double price = sc.nextDouble();
                int sid = getServiceId();
                Services s=new Services(sid,title,desc,price,0);//创建对象，对象中的值为当前输入的业务内容
                services.add(s);//把业务对象添加到集合中
                System.out.println("业务添加成功");
                System.out.println(services);
                goBack();
    }
    
    
    //返回管理员页面
    public static void goBack(){
        System.out.println("1、返回   2、退出程序");
        String num = sc.next();
        if(num.equals("1")){
            if(loginUsername.equals("admin")){
                adminView();
            }else{
                userView();
            }
        }else{
            System.out.println("程序退出");
            System.exit(0);
        }
    }

    
    //获取业务编号
    public static int getServiceId() {
        Services service = services.get(services.size()-1);//拿到集合中最后一个业务对象
        int sid = service.getSid();
        sid++;
        return sid;
    }
    
    //展示我的业务
    public static void showOnlineService(){
        System.out.println("业务编号\t业务标题\t\t\t业务描述\t\t\t业务价格");
        for (Services s : services) {
            if(s.getState()==1){
                System.out.println(s.getSid()+"\t"+s.getTitle()+"\t"+ s.getDesc()+"\t"+s.getPrice());
            }
        }
    }
    
    
    //查看业务大厅，里面有所有上架的业务，也就是状态为1的业务
    public static void showServices() {
        showOnlineService();
        goBack();
    }

    //普通用户页面
    public static void userView() {
        System.out.println("欢迎你："+loginUsername);
        System.out.println("1、个人信息   2、修改密码   3、充值   4、我的业务   5、业务大厅   6、业务办理   7、业务终止   8、退出");
        System.out.println("请选择：");
        int num = sc.nextInt();
        switch (num) {
            case 1:
                showMyInformation();//个人信息
                break;
            case 2:
                alterPwd();//修改密码
                break;        
            case 3:
                addMoney();//充值
                break;        
            case 4:
                MyService();//我的业务    
                break;        
            case 5:
                showServices();//业务大厅        
                break;
            case 6:
                addMyService();//业务办理
                break;        
            case 7:
                endService();//业务终止        
                break;
            case 8://退出
                index();        
                break;
            default:
                System.out.println("输入错误，请重新来过");
                userView();
        }
    }
    
    
    //业务终止
    public static void endService() {
        User user=getLoginUser();//获取当前用户对象
        int flag1=0;
        for (Services s : user.getMyservice()) {
            if(s.getState()==1)
            {
                flag1=1;
            }
            if(user.getMyservice()==null)
            {
                flag1=-1;
            }
        }
        if(flag1==1)
        {
            System.out.println("你办理过的业务有：");
            System.out.println("业务编号\t业务标题\t\t\t业务描述\t\t\t业务价格");
            for (Services s : user.getMyservice()) {
                if(s.getState()==1)
                {
                    System.out.println(s.getSid()+"\t"+s.getTitle()+"\t"+ s.getDesc()+"\t"+s.getPrice());
                }
            }
        }
        else{
            System.out.println("还没有办理过业务，请先办理业务");
            userView();
        }

        System.out.println("输入你想删除的业务编号：");
        int sid = sc.nextInt();
        int flag2=0;
        //遍历当前用户的业务
        for (Services s : user.getMyservice())
        {
            if(s.getSid()==sid)
            {
                s.setState(0);//把要删除的业务下架
                flag2++;
            }
        }
        if(flag2==0)
        {
            System.out.println("输入的编号不合理，返回用户页面");
            userView();
        }
        else {
            System.out.println("删除了"+flag2+"个，编号为"+sid+"的业务");
        }
        goBack();
    }

    //用户充值
    public static void addMoney() {
        User user=getLoginUser();//获取当前用户对象
        System.out.println("请输入你要充值的金额：");
        double money=sc.nextDouble();
        user.setMoney(user.getMoney()+money);
        System.out.println("充值成功");
        goBack();
    }

    //修改密码
    public static void alterPwd() {
        User user=getLoginUser();//获取当前用户对象
        System.out.println("输入原密码：");
        String pwd = sc.next();
        if(MD5Util.getMD5(pwd).equals(user.getPassword()))//原密码输入正确
        {
            System.out.println("请输入修改的密码：");
            String pwd1=sc.next();
            System.out.println("请再次输入修改的密码：");
            String pwd2=sc.next();
            if(voildPwd(pwd1, pwd2))
            {
                System.out.println("密码修改成功");
                user.setPassword(pwd1);//把修改后的密码赋值到用户对象中
                goBack();
            }
            else {
                System.out.println("修改后的密码不符合条件，返回个人页面");
                userView();
            }
        }
    }

    //业务办理
    public static void addMyService() {
        User user =getLoginUser();
        showOnlineService();
        System.out.println("请选择需要办理的业务编号：");
        int sid = sc.nextInt();
        //遍历业务集合，与输入的编号进行比较，如果一样就添加进业务
        int flag=0;//设置标志符，0表示不存在输入的编号，1表示存在
        Services ser=null;//设置一个空的业务对象
        for (Services b : services) {
            if(b.getSid()==sid && b.getState()==1)
            {
                flag=1;
                ser=b;
                break;
            }
        }
        if(flag==0)//输入的业务编号错误
        {
            System.out.println("业务编号输入错误，返回个人页面");
            userView();
        }
        else //输入的业务编号是正确的
        {
            if(ser.getPrice()>user.getMoney())//余额不够办理业务
            {
                System.out.println("余额不足，请充值");
                userView();
            }
            else //编号正确，钱足够
            {
                ArrayList<Services> service=user.getMyservice();
                //如果自己的业务中是空的话，则需要先实例化，然后再添加；不然就会有空指针异常
                if(service==null)
                {
                    service=new ArrayList<Services>();
                }
                service.add(ser);//把业务添加进自己的业务中
                user.setMoney(user.getMoney()-ser.getPrice());//更新自己的余额
                user.setMyservice(service);
                System.out.println("业务办理成功");
                goBack();
            }
        }
    }

    //用户的业务展示
    public static void MyService() {
        User user = getLoginUser();
        if(user.getMyservice()==null)
        {
            System.out.println("还没有办理过业务");
        }else{
            System.out.println("业务编号\t业务标题\t\t\t业务描述\t\t\t业务价格");
            for (Services s : user.getMyservice()) {
                if(s.getState()==1)
                {
                    System.out.println(s.getSid()+"\t"+s.getTitle()+"\t"+ s.getDesc()+"\t"+s.getPrice());
                }
            }
        }
        goBack();
    }
    
    //获取当前的登录对象
    public static User getLoginUser(){
        User user=null;//当前用户对象
        for (User u : users) {
            if(u.getUsername().equals(loginUsername)){
                user=u;
                break;
            }
        }
        return user;
    }

    //显示个人信息
    public static void showMyInformation() {
        User user =getLoginUser();
        System.out.println(user);
        goBack();
    }

    //检验用户名与密码是否对应
    public static boolean voildLogin(String username, String pwd) {
        boolean result = true;//设置标志符
        for (User user : users) {
            if(user.getUsername().equals(username) && user.getPassword().equals(MD5Util.getMD5(pwd)))//当前的用户名和加密的密码在集合的一个元素内都相同
            {
                result = true;
                break;
            }else{
                result = false;
            }
        }
        return result;
    }

    //注册操作
    public static void register() {
        System.out.println("请输入用户名：");
        String username = sc.next();
        if(voildUsername(username))//如果输入的用户名符合条件，则进行密码输入
        {
            System.out.println("请输入密码：");
            String pwd1 = sc.next();
            System.out.println("请再次输入密码：");
            String pwd2 = sc.next();
            if(voildPwd(pwd1,pwd2))//如果输入的密码符合条件，则进行验证码校验
            {
                String code = getCode();
                System.out.println("验证码是："+code);
                System.out.print("请输入验证码：");
                String mycode = sc.next();
                if(code.equals(mycode))//如果验证码输入正确
                {
                    //生成用户编号
                    int id = getId();
                    pwd1=MD5Util.getMD5(pwd1);
                    //创建对象，其中值就是新增的用户信息
                    User user=new User(id, username, pwd1);
                    users.add(user);//把新增的用户信息添加到集合中
                    System.out.println("注册成功了！！！");
                    System.out.println(users);
                    index();
                }else {
                    System.out.println("验证码输入错误，注册失败，请重新注册");
                    register();
                }
            }
            else//如果输入的密码不符合条件，则重新开始
            {
                register();
            }
        }else //如果输入的用户名不符合条件，则重新开始
        {
            register();
        }
    }
    
    
    //获取用户编号
    public static int getId() {
        //获取集合长度，并将下一个注册成功的用户放入集合最后，编号加1
        //获得集合中最后一个元素
        User user = users.get(users.size()-1);
        int userId = user.getUserId();//获取元素的UserId，也就是它的用户编号
        userId++;//把用户编号自增一，置为新加入的用户编号
        return userId;
    }

    //获得四位数验证码
    public static String getCode(){
        String  random = Math.random()+"";
        String s=random.substring(random.length()-4);
        return s;
    }
    
    //检验用户名是否满足条件，是的话返回true ，不是的话返回false
    public static boolean voildUsername(String username)
    {
        boolean result = true;//设置标志符
        //判断传入的数长度是否在4~10之间
        if(username.length() >= 4 && username.length() <= 10)
        {
            //进行重复性校验，判断集合中是否存在同样的用户名
            for (User user : users) //用for-each遍历集合
            {
                //user.getUsername()获取的是集合每一个元素中的用户名
                if(username.equals(user.getUsername()))//表示在集合中查到了同样的用户名
                {
                    result = false;
                    System.out.println("已存在用户名，注册失败，请重新注册");
                    break;
                }
            }
        }
        //如果长度不在4~10之间
        else 
        {
            result = false;
            System.out.println("长度不符合，注册失败，请重新注册");
        }
        return result;//返回标志符
    }

    
    //检验两次输入的密码是否相等，以及是否符合条件-长度4~16
    public static boolean voildPwd(String pwd1, String pwd2) 
    {
         boolean result = true;//设置标志符
        if(pwd1.equals(pwd2))//如果两次输入的密码相等
        {
            if(pwd1.length()<4 || pwd1.length()>16)//密码长度不在4~16之间
            {                
                System.out.println("密码长度不符合，注册失败，请重新注册");
                result=false;
            }
        }
        else//两次输入的密码不相等
        {
            System.out.println("两次输入密码不一致，注册失败，请重新注册");
            result=false;
        }
        return result;//返回标志符
    }
}
 

//MD5加密工具类

public class MD5Util {
     public static final String CHARSET = "UTF-8";
     

     public final static String getMD5(String s) {
            char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','a','b','b','d','e','f'};//把传入的s换成小写a-f和0-9
            try {
                byte[] btInput = s.getBytes();
                // 获得MD5摘要算法的 MessageDigest 对象
                MessageDigest mdInst = MessageDigest.getInstance("MD5");
                // 使用指定的字节更新摘要
                mdInst.update(btInput);
                // 获得密文
                byte[] md = mdInst.digest();
                // 把密文转换成十六进制的字符串形式
                int j = md.length;
                char str[] = new char[j * 2];
                int k = 0;
                for (int i = 0; i < j; i++) {
                    byte byte0 = md[i];
                    str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                    str[k++] = hexDigits[byte0 & 0xf];
                }
                return new String(str);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
}