基于控制台实现简单的银行转账与用户管理系统

bilibilidicks

已于 2022-07-05 12:53:44 修改

阅读量407

点赞数

文章标签： java

于 2022-07-05 12:53:28 首次发布

本文链接：https://blog.csdn.net/bilibilidicks/article/details/125617385

版权

包结构

User抽象类，抽象子类需要实现的方法

package org.example.bean;

/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:24
 */

public abstract class User {
    private Long cardId;
    private String cardPwd;
    private String userName;
    private String adminPwd;
    private String call;
    private Double account;

    public User() {
    }

    public User(Long cardId, String cardPwd, String userName, String call, Double account) {
        this.cardId = cardId;
        this.cardPwd = cardPwd;
        this.userName = userName;
        this.call = call;
        this.account = account;
    }

    public User(String userName, String adminPwd) {
        this.userName = userName;
        this.adminPwd = adminPwd;
    }

    // 抽象父类定义登录规则，由子类实现
    public abstract User login();

    // 抽象父类定义界面规则，由子类实现
    public abstract void userHandler();

    public Long getCardId() {
        return cardId;
    }

    public String getCardPwd() {
        return cardPwd;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Double getAccount() {
        return account;
    }

    public void setAccount(Double account) {
        this.account = account;
    }

    public String getAdminPwd() {
        return adminPwd;
    }

    public void setAdminPwd(String adminPwd) {
        this.adminPwd = adminPwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "cardId=" + cardId +
                ", cardPwd='" + cardPwd + '\'' +
                ", userName='" + userName + '\'' +
                ", call='" + call + '\'' +
                ", account=" + account +
                '}';
    }
}

子类AdminUser，封装管理员信息

package org.example.bean.concreteuser;

import org.example.bean.User;
import org.example.utils.DBUtil;

import java.util.Scanner;

import static org.example.utils.TypeConstants.ADMIN_TYPE;
import static org.example.utils.TypeConstants.BANK_USER_TYPE;

/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:32
 */

public class AdminUser extends User {

    private static final Scanner sc = new Scanner(System.in);

    public AdminUser() {
    }

    public AdminUser(String userName, String adminPwd) {
        super(userName, adminPwd);
    }

    @Override
    public User login() {
        String inputName;
        String inputPwd;
        while (true) {
            System.out.println("请输入管理员的用户名");
            inputName = sc.nextLine();
            if (DBUtil.containsKey(ADMIN_TYPE, inputName)) {
                System.out.println("用户名正确!");
                break;
            } else {
                System.out.println("用户名不存在，请重新输入!");
            }
        }
        while (true) {
            System.out.println("请输入管理员的密码");
            inputPwd = sc.nextLine();
            if (DBUtil.getUser(ADMIN_TYPE, inputName).getAdminPwd().equals(inputPwd)) {
                System.out.println("密码正确");
                break;
            } else {
                System.out.println("密码错误，请重新输入");
            }
        }
        return DBUtil.getUser(ADMIN_TYPE, inputName);
    }

    @Override
    public void userHandler() {
        boolean handle = true;
        while (handle) {
            System.out.println("(我自己加的功能)输入-1查询所有用户，输入1添加用户，输入2删除用户，输入3查询用户，输入0退出");
            String adminInputHandle = sc.nextLine();
            switch (adminInputHandle) {
                case "-1":
                    DBUtil.getAll();
                    break;
                case "1":
                    System.out.println("进入添加用户界面,请输入所需开户用户名");
                    String userName = sc.nextLine();
                    System.out.println("请输入所需开户用户密码");
                    String userPwd = sc.nextLine();
                    System.out.println("请输入所需开户用户电话");
                    String userCall = sc.nextLine();
                    boolean addUserResult = DBUtil.addUser(userName, userPwd, userCall);
                    if (addUserResult) System.out.println("开户成功");
                    else System.out.println("开户失败");
                    break;
                case "2":
                    System.out.println("进入删除用户界面，请输入所需删除用户银行卡号");
                    long userCardId = sc.nextLong();
                    sc.nextLine();
                    if (DBUtil.removeUser(userCardId)) {
                        System.out.println("删除成功");
                    } else {
                        System.out.println("删除失败");
                    }
                    break;
                case "3":
                    System.out.println("进入查询用户界面，请输入所需查询用户银行卡号");
                    userCardId = sc.nextLong();
                    sc.nextLine();
                    System.out.println(DBUtil.getUser(BANK_USER_TYPE, userCardId));
                    break;
                case "0":
                    System.out.println("bye~bye~");
                    handle = false;
                    break;
            }
        }
    }
}

子类BankUser类，封装普通用户信息

package org.example.bean.concreteuser;

import org.example.bean.User;
import org.example.utils.DBUtil;

import java.util.Scanner;

import static org.example.utils.TypeConstants.BANK_USER_TYPE;

/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:31
 */

public class BankUser extends User {

    private static final Scanner sc = new Scanner(System.in);

    public BankUser() {
    }

    public BankUser(Long cardId, String cardPwd, String userName, String call, Double account) {
        super(cardId, cardPwd, userName, call, account);
    }

    @Override
    public User login() {
        long userCardId;
        String cardPwd;
        User nowUser;
        while (true) {
            System.out.println("请输入用户银行卡号");
            userCardId = sc.nextLong();
            sc.nextLine();
            if (DBUtil.containsKey(BANK_USER_TYPE, userCardId)) {
                System.out.println("用户银行卡存在");
                break;
            } else {
                System.out.println("此银行卡不存在，请重新输入");
            }
        }
        while (true) {
            System.out.println("请输入用户银行卡密码");
            cardPwd = sc.nextLine();
            if (cardPwd.equals(DBUtil.getUser(BANK_USER_TYPE, userCardId).getCardPwd())) {
                System.out.println("银行卡密码正确");
                nowUser = DBUtil.getUser(BANK_USER_TYPE, userCardId);
                break;
            } else {
                System.out.println("银行卡密码错误，请重新输入");
            }
        }
        return nowUser;
    }

    @Override
    public void userHandler() {
        boolean handle = true;
        while (handle) {
            System.out.println("输入1存款，输入2取款，输入3查询余额，输入4转账，输入0退出");
            String userInputHandle = sc.nextLine();
            switch (userInputHandle) {
                case "1":
                    System.out.println("进入存款界面，请输入需要存款的金额");
                    double money = sc.nextDouble();
                    sc.nextLine();
                    DBUtil.deposit(getCardId(), money);
                    break;
                case "2":
                    System.out.println("进入取款界面，请输入要取出的金额");
                    money = sc.nextDouble();
                    sc.nextLine();
                    DBUtil.withdraw(getCardId(), money);
                    break;
                case "3":
                    System.out.println("进入查询余额页面，即将输出本账户余额");
                    System.out.println("账户余额为：" + getAccount());
                    break;
                case "4":
                    System.out.println("进入转账界面，请输入需要转账用户的银行卡号：");
                    long targetCardId = sc.nextLong();
                    sc.nextLine();
                    System.out.println("请输入需要转账的金额");
                    money = sc.nextDouble();
                    sc.nextLine();
                    DBUtil.transfer(getCardId(), targetCardId, money);
                    break;
                case "0":
                    System.out.println("bye~bye~");
                    handle = false;
                    break;
            }
        }
    }
}

对象工厂，传入具体类的对象生产具体的实例对象

package org.example.bean.context;



/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:32
 */

public class UserContext {

    public static <T> T createUser(Class<T> clazz) {
        T obj = null;
        try {
            // 反射生成具体实例
            obj = (T) Class.forName(clazz.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }

        return obj;
    }



}

Bank类，实现用户登录与界面交互功能

package org.example.utils;

import org.example.bean.User;


/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:52
 */

public class Bank {


    public static User login(User current) {
        // 利用type值判断传入的用户类型，利用类的多态性执行登录函数
        return current.login();
    }

    public static void userHandle(User obj) {
        // 利用type值判断传入的用户类型，利用类的多态性执行界面函数
        obj.userHandler();
    }

}

DBUtil类，模拟数据库封装所有数据操纵功能的一个工具类

package org.example.utils;

import org.example.bean.User;
import org.example.bean.concreteuser.AdminUser;
import org.example.bean.concreteuser.BankUser;
import org.example.bean.context.UserContext;


import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;

import static org.example.utils.TypeConstants.ADMIN_TYPE;
import static org.example.utils.TypeConstants.BANK_USER_TYPE;

/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:38
 */

public class DBUtil {

    private static final ConcurrentHashMap<Long, User> bankUserMap;
    private static final ConcurrentHashMap<String, User> adminUserMap;
    private static final Random random = new Random();


    static {
        bankUserMap = new ConcurrentHashMap<>();
        adminUserMap = new ConcurrentHashMap<>();
        bankUserMap.put(6217001930037940104L, new BankUser(6217001930037940104L, "123456", "wanglu", "18855544466", 5000.0));
        bankUserMap.put(6217001930037940105L, new BankUser(6217001930037940105L, "234567", "huangpeijun", "18855544477", 6000.0));
        bankUserMap.put(6217001930037940106L, new BankUser(6217001930037940106L, "345678", "chenlu", "18855544488", 7000.0));
        bankUserMap.put(6217001930037940107L, new BankUser(6217001930037940107L, "456789", "huangna", "18855544499", 8000.0));
        bankUserMap.put(6217001930037940108L, new BankUser(6217001930037940108L, "567890", "wangyuting", "18855544400", 9000.0));
        User adminUser = UserContext.createUser(AdminUser.class);
        adminUser.setUserName("admin");
        adminUser.setAdminPwd("123456");
        adminUserMap.put("admin", adminUser);
    }


    public static User getUser(String type, Object key) {
        if (ADMIN_TYPE.equals(type)) {
            return adminUserMap.get((String) key);
        } else if (BANK_USER_TYPE.equals(type)) {
            return bankUserMap.get((Long) key);
        }
        return null;
    }

    public static <T> boolean containsKey(String type, T key) {
        if (ADMIN_TYPE.equals(type)) {
            return adminUserMap.containsKey(key);
        } else if (BANK_USER_TYPE.equals(type)) {
            return bankUserMap.containsKey(key);
        }
        return false;
    }


    // TODO 管理员添加用户
    public static boolean addUser(String userName, String cardPwd, String call) {
        try {
            long nextLong = random.nextLong();
            Long carId = nextLong > 0 ? nextLong : -1 * nextLong;
            bankUserMap.put(carId, new BankUser(carId, cardPwd, userName, call, 0.0));
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    // TODO 管理员删除用户
    public static boolean removeUser(Long cardId) {
        if (bankUserMap.containsKey(cardId)) {
            bankUserMap.remove(cardId);
            return true;
        } else {
            System.out.println("不存在此用户!");
            return false;
        }
    }


    // TODO 查询所有用户
    public static void getAll() {
        bankUserMap.forEach((k, v) -> System.out.println("用户卡号:" + k + "\t" + "用户详情:" + v));
    }

    // TODO 用户存款
    public static void deposit(long cardId, double money) {
        if (money <= 0) {
            System.out.println("存储金额需大于零");
            return;
        }
        User newValue = bankUserMap.get(cardId);
        System.out.println("存储前卡内余额剩余" + newValue.getAccount());
        newValue.setAccount(newValue.getAccount() + money);
        bankUserMap.replace(cardId, newValue);
        System.out.println("存储后卡内余额剩余" + bankUserMap.get(cardId).getAccount());
    }


    // TODO 用户取款
    public static void withdraw(long cardId, double money) {
        if (money <= 0) {
            System.out.println("取出金额需大于零");
            return;
        }
        User newValue = bankUserMap.get(cardId);
        System.out.println("取出前卡内余额剩余" + newValue.getAccount());
        if (newValue.getAccount() < money) {
            System.out.println("卡内余额不足");
            return;
        }
        newValue.setAccount(newValue.getAccount() - money);
        bankUserMap.replace(cardId, newValue);
        System.out.println("取出后卡内余额剩余：" + bankUserMap.get(cardId).getAccount());
    }

    //TODO 用户转账
    public static void transfer(long cardId, long targetId, double money) {
        if (money <= 0) {
            System.out.println("转账金额需大于零");
            return;
        }
        if (bankUserMap.containsKey(targetId)) {
            //
            User nowUser = bankUserMap.get(cardId);
            User targetUser = bankUserMap.get(targetId);
            System.out.println("转账前本账户与目标账户的余额分别为" + nowUser.getAccount() + "\t" + targetUser.getAccount());
            if (nowUser.getAccount() - money < 0) {
                System.out.println("账户余额不足");
                return;
            }
            nowUser.setAccount(nowUser.getAccount() - money);
            targetUser.setAccount(targetUser.getAccount() + money);
            bankUserMap.replace(cardId, nowUser);
            bankUserMap.replace(targetId, targetUser);
            System.out.println("转账后本账户与目标账户的余额分别为" + bankUserMap.get(cardId).getAccount() + "\t" + bankUserMap.get(targetId).getAccount());
        } else {
            System.out.println("转账用户不存在");
        }
    }


}

TypeConstants常量池，封装经常使用的常量

package org.example.utils;

/**
 * @author bilibilidick
 * @version 2022 07
 * @date 2022/7/3 22:27
 */

public class TypeConstants {

    public static final String ADMIN_TYPE = "0";
    public static final String BANK_USER_TYPE = "1";

}

App为主函数，程序的入口

package org.example;

import org.example.bean.User;
import org.example.bean.concreteuser.AdminUser;
import org.example.bean.concreteuser.BankUser;
import org.example.bean.context.UserContext;
import org.example.utils.Bank;


import java.util.Scanner;

import static org.example.utils.TypeConstants.ADMIN_TYPE;
import static org.example.utils.TypeConstants.BANK_USER_TYPE;

/**
 * Hello world!
 */
public class App {

    private static final Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        boolean globalHandler = true;
        while (globalHandler) {
            // 用户类型标识符，存储在TypeConstants类中
            String inputType;
            // 当前用户，用来存放登录用户信息
            User currentUser;
            while (true) {
                System.out.println("请输入你的用户类型 0表示管理员 1表示普通用户");
                inputType = sc.nextLine();
                // 如果用户输入的字符是0或1则跳出循环，否则无限循环直到用户输入正确为止
                if (ADMIN_TYPE.equals(inputType) || BANK_USER_TYPE.equals(inputType)) {
                    break;
                } else {
                    System.out.println("类型选择错误，请重新输入！");
                }
            }

            System.out.println(ADMIN_TYPE.equals(inputType) ? "进入管理员用户身份验证界面" : "进入普通用户界面身份信息验证界面");
            // 利用工厂模式生产当前用户，类型为管理员或普通用户
            // currentUser = new UserContext(ADMIN_TYPE).getUser();
            currentUser = ADMIN_TYPE.equals(inputType) ? UserContext.createUser(AdminUser.class) : UserContext.createUser(BankUser.class);
            // 调用Bank类的登录接口
            currentUser = Bank.login(currentUser);
            System.out.println(ADMIN_TYPE.equals(inputType) ? "进入管理员界面" : "进入普通用户界面");
            // 调用Bank类的管理员或者普通用户界面接口
            Bank.userHandle(currentUser);

            System.out.println("是否退出系统，输入0退出，输入其他值继续");
            String gFlag = sc.nextLine();
            globalHandler = !"0".equals(gFlag);

        }

        System.out.println("see U~~");

    }
}

运行效果，首先是管理员类型

登录功能展示，用户或密码错误会无限循环直到输入正确，你也可以限制输入次数

增删改查功能展示

用户功能展示

完毕！

bilibilidicks

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
基于控制台实现简单的银行转账与用户管理系统

子类AdminUser，封装管理员信息子类BankUser类，封装普通用户信息对象工厂，传入具体类的对象生产具体的实例对象Bank类，实现用户登录与界面交互功能DBUtil类，模拟数据库封装所有数据操纵功能的一个工具类TypeConstants常量池，封装经常使用的常量App为主函数，程序的入口运行效果，首先是管理员类型登录功能展示，用户或密码错误会无限循环直到输入正确，你也可以限制输入次数增删改查功能展示用户功能展示
复制链接

扫一扫