一、项目简介

  • 项目名：嗖嗖移动业务大厅

  • 技能点：

　　

二、技能点　

　　

三、系统概述

　　

四、整体开发思路

　　

五、实体类和接口开发

　　　

　　

六、 创建工具类

　　

七、使用集合存储数据

　　

八、开发计划

　　

九、代码实现　　

　　1.项目目录

　　

　　2.具体代码

  • 测试类
  1. package cn.soso.biz;
  2.  
  3. import java.util.Scanner;
  4.  
  5. import cn.soso.entity.MobileCard;
  6. import cn.soso.entity.ServicePackage;
  7. import cn.soso.utils.CardUtil;
  8.  
  9. /**
  10.  * 业务类
  11.  *
  12.  * @author yu
  13.  *
  14.  */
  15. public class SosoMgr {
  16.     Scanner input = new Scanner(System.in);
  17.     CardUtil utils = new CardUtil();
  18.  
  19.     public static void main(String[] args) {
  20.         SosoMgr soso = new SosoMgr();
  21.         soso.mainMenu();
  22.         System.out.println("谢谢使用！");
  23.     }
  24.  
  25.     /**
  26.      * 主流程
  27.      */
  28.     public void mainMenu() {
  29.         int menuChoose = 0;
  30.         String mobileNumber= "";
  31.         String password = "";
  32.         utils.init();
  33.         utils.initScenes();
  34.         //Common.typesInit();
  35.         do {
  36.             System.out.println("\n*************欢迎使用嗖嗖移动业务大厅***************");
  37.             System.out.println("1.用户登录   2.用户注册   3.使用嗖嗖   4.话费充值  5.资费说明  6.退出系统");
  38.             System.out.print("请选择：");
  39.             menuChoose = input.nextInt();
  40.             // 分支语句：根据功能编号执行相应功能
  41.             switch (menuChoose) {
  42.                 case 1:
  43.                     //用户登录
  44.                     System.out.print("请输入手机卡号：");
  45.                     mobileNumber = input.next();
  46.                     System.out.print("请输入密码：");
  47.                     password = input.next();
  48.                     if (utils.isExistCard(mobileNumber, password)) {
  49.                         cardMenu(mobileNumber);
  50.                     }else{
  51.                         System.out.println("对不起，您输入的信息有误，无法登录！");
  52.                     }
  53.                     continue;
  54.                 case 2:
  55.                     //用户注册
  56.                     registCard();
  57.                     continue;
  58.                 case 3:
  59.  
  60.                     //使用嗖嗖
  61.                     System.out.print("请输入手机卡号：");
  62.                     mobileNumber = input.next();
  63.  
  64.                     if (utils.isExistCard(mobileNumber)) {
  65.                         try {
  66.                         /*System.out.println("****使用之前****");
  67.                         cn.soso.utils.showRemainDetail(mobileNumber);
  68.                         cn.soso.utils.showAmountDetail(mobileNumber);*/
  69.                             utils.userSoso(mobileNumber);
  70.                         } catch (Exception e) {
  71.                             System.err.println(e.getMessage());
  72.                         }
  73.                     }else{
  74.                         System.out.println("对不起，该卡号未注册，不能使用！");
  75.                     }
  76.  
  77.                 /*System.out.println("****使用之后****");
  78.                 cn.soso.utils.showRemainDetail(mobileNumber);
  79.                 cn.soso.utils.showAmountDetail(mobileNumber);*/
  80.                     continue;
  81.                 case 4:
  82.                     //话费充值
  83.                     System.out.print("请输入充值卡号：");
  84.                     mobileNumber = input.next();
  85.                     if (utils.isExistCard(mobileNumber)) {
  86.                         System.out.print("请输入充值金额：");
  87.                         double money = input.nextDouble();
  88.                         utils.chargeMoney(mobileNumber, money);
  89.                     }else{
  90.                         System.out.println("对不起，要充值的卡号未注册，无法充值！");
  91.                     }
  92.                     continue;
  93.                 case 5:
  94.                     System.out.println("\n*****资费说明******");
  95.                     utils.showDescription();
  96.                     continue;
  97.                 case 6:
  98.                     //退出系统
  99.                     break;
  100.                 default:
  101.                     //选择其他数字退出系统
  102.                     break;
  103.             }
  104.             break;
  105.         } while (true);
  106.     }
  107.  
  108.     /**
  109.      * 手机卡功能菜单
  110.      *
  111.      * @param number
  112.      * @return
  113.      */
  114.     public int cardMenu(String mobileNumber) {
  115.         int menuChoose = 0;
  116.         do {
  117.             System.out.println("\n*****嗖嗖移动用户菜单*****");
  118.             System.out.println("1.本月账单查询");
  119.             System.out.println("2.套餐余量查询");
  120.             System.out.println("3.打印消费详单");
  121.             System.out.println("4.套餐变更");
  122.             System.out.println("5.办理退网");
  123.             System.out.print("请选择(输入1~5选择功能，其他键返回上一级)：");
  124.             menuChoose = input.nextInt();
  125.             switch (menuChoose) {
  126.                 case 1:
  127.                     System.out.println("\n*****本月账单查询******");
  128.                     utils.showAmountDetail(mobileNumber);
  129.                     continue;
  130.                 case 2:
  131.                     System.out.println("\n*****套餐余量查询******");
  132.                     utils.showRemainDetail(mobileNumber);
  133.                     continue;
  134.                 case 3:
  135.                     System.out.println("\n*****消费详单查询******");
  136.                     utils.printConsumInfo(mobileNumber);
  137.                     continue;
  138.                 case 4:
  139.                     System.out.println("\n*****套餐变更******");
  140.                     System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐  请选择（序号）：");
  141.                     utils.changingPack(mobileNumber, input.next());
  142.                     continue;
  143.                 case 5:
  144.                     System.out.println("\n*****办理退网******");
  145.                     utils.delCard(mobileNumber);
  146.                     System.out.println("谢谢使用！");
  147.                     System.exit(1);     //办理退网后退出系统
  148.  
  149.             }
  150.  
  151.             break;
  152.         } while (true);
  153.         return menuChoose;
  154.     }
  155.  
  156.     /**
  157.      * 注册新卡流程
  158.      */
  159.     public void registCard(){
  160.         String[] newNumbers = utils.getNewNumbers(9);
  161.         //显示可供选择的手机号列表
  162.         System.out.println("*****可选择的卡号*****");
  163.  
  164.         for(int i=0;i<9;i++){
  165.             System.out.print((i+1)+"."+newNumbers[i]+"\t\t");
  166.             if((i+1)%3==0){
  167.                 System.out.println();
  168.             }
  169.         }
  170.         //选择手机号
  171.         System.out.print("请选择卡号（输入1~9的序号）：");
  172.         String number = newNumbers[input.nextInt()-1];
  173.  
  174.         //选择套餐类型
  175.         System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐，  ");
  176.         System.out.print("请选择套餐(输入序号)：");
  177.         //cn.soso.utils.getPackList();
  178.         //获取套餐对象
  179.         ServicePackage pack = utils.createPack(input.nextInt());
  180.  
  181.         //输入用户名
  182.         System.out.print("请输入姓名：");
  183.         String name = input.next();
  184.  
  185.         //输入密码
  186.         System.out.print("请输入密码：");
  187.         String password = input.next();
  188.  
  189.         //输入预存话费金额
  190.         double money = 0;
  191.         System.out.print("请输入预存话费金额：");
  192.         money = input.nextDouble();
  193.         while(money<pack.getPrice()){
  194.             System.out.print("您预存的话费金额不足以支付本月固定套餐资费，请重新充值：");
  195.             money = input.nextDouble();
  196.         }
  197.  
  198.         //创建新卡对象并添加
  199.         MobileCard newCard = new MobileCard(name,password,number,pack,pack.getPrice(),money-pack.getPrice());
  200.         utils.addCard(newCard);
  201.     }
  202. }
  • 公共类
  1. package cn.soso.common;
  2.  
  3. import java.text.DecimalFormat;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6.  
  7. /**
  8.  * 公共类
  9.  * @author yu
  10.  *
  11.  */
  12. public class Common {
  13.     /**
  14.      * double类型格式化
  15.      * @param data
  16.      * @return
  17.      */
  18.     public static String dataFormat(double data) {
  19.         DecimalFormat formatData = new DecimalFormat("#.0");
  20.         return formatData.format(data);
  21.     }
  22.  
  23.     /**
  24.      * double类型两数相减
  25.      * @param num1
  26.      * @param num2
  27.      * @return
  28.      */
  29.     public static double sub(double num1,double num2){
  30.         return (num1*10-num2*10)/10;
  31.     }
  32. }
  1. package cn.soso.common;
  2. /**
  3.  * 消费类型
  4.  * @author rong.zhou
  5.  *
  6.  */
  7. public enum ConsumType {
  8.    TALK,SMS,NETWORK
  9. }
  • 实体类
  1. package cn.soso.entity;
  2. import cn.soso.common.ConsumType;
  3. /**
  4.  * 消费信息
  5.  * @author yu
  6.  *
  7.  */
  8. public class ConsumInfo {
  9.     private String cardNumber;  //卡号
  10.     private String type;  //消费类型：通话、发短信、上网
  11.     private int consumData;   //消费数据   通话：分钟   发短信：条   上网：MB
  12.  
  13.     public ConsumInfo(){}
  14.     public ConsumInfo(String cardNumber, String type, int consumData) {
  15.         super();
  16.         this.cardNumber = cardNumber;
  17.         this.type = type;
  18.         this.consumData = consumData;
  19.     }
  20.     public String getCardNumber() {
  21.         return cardNumber;
  22.     }
  23.     public void setCardNumber(String cardNumber) {
  24.         this.cardNumber = cardNumber;
  25.     }
  26.     public String getType() {
  27.         return type;
  28.     }
  29.     public void setType(String type) {
  30.         this.type = type;
  31.     }
  32.     public int getConsumData() {
  33.         return consumData;
  34.     }
  35.     public void setConsumData(int consumData) {
  36.         this.consumData = consumData;
  37.     }
  38. }
  1. package cn.soso.entity;
  2. /**
  3.  * 手机卡
  4.  * @author yu
  5.  *
  6.  */
  7. public class MobileCard {
  8.     private String cardNumber;  //卡号
  9.     private String userName;  //用户名
  10.     private String passWord;  //密码
  11.     private ServicePackage serPackage;  //所属套餐
  12.     private double consumAmount;  //当月消费金额
  13.     private double money;  //账户余额
  14.     private int realTalkTime;  //实际通话时长（分钟）
  15.     private int realSMSCount;  //实际发送短信条数（条）
  16.     private int realFlow;  //实际上网流量
  17.  
  18.     public MobileCard(){}
  19.  
  20.     public MobileCard(String userName, String passWord, String cardNumber,
  21.                       ServicePackage serPackage, double consumAmount, double money) {
  22.         super();
  23.         this.userName = userName;
  24.         this.passWord = passWord;
  25.         this.cardNumber = cardNumber;
  26.         this.serPackage = serPackage;
  27.         this.consumAmount = consumAmount;
  28.         this.money = money;
  29.     }
  30.  
  31.     public String getUserName() {
  32.         return userName;
  33.     }
  34.  
  35.     public void setUserName(String userName) {
  36.         this.userName = userName;
  37.     }
  38.  
  39.     public String getPassWord() {
  40.         return passWord;
  41.     }
  42.  
  43.     public void setPassWord(String passWord) {
  44.         this.passWord = passWord;
  45.     }
  46.  
  47.     public String getCardNumber() {
  48.         return cardNumber;
  49.     }
  50.  
  51.     public void setCardNumber(String cardNumber) {
  52.         this.cardNumber = cardNumber;
  53.     }
  54.  
  55.     public ServicePackage getSerPackage() {
  56.         return serPackage;
  57.     }
  58.  
  59.     public void setSerPackage(ServicePackage serPackage) {
  60.         this.serPackage = serPackage;
  61.     }
  62.  
  63.     public double getConsumAmount() {
  64.         return consumAmount;
  65.     }
  66.  
  67.     public void setConsumAmount(double consumAmount) {
  68.         this.consumAmount = consumAmount;
  69.     }
  70.  
  71.     public double getMoney() {
  72.         return money;
  73.     }
  74.  
  75.     public void setMoney(double money) {
  76.         this.money = money;
  77.     }
  78.  
  79.     public int getRealTalkTime() {
  80.         return realTalkTime;
  81.     }
  82.  
  83.     public void setRealTalkTime(int realTalkTime) {
  84.         this.realTalkTime = realTalkTime;
  85.     }
  86.  
  87.     public int getRealSMSCount() {
  88.         return realSMSCount;
  89.     }
  90.  
  91.     public void setRealSMSCount(int realSMSCount) {
  92.         this.realSMSCount = realSMSCount;
  93.     }
  94.  
  95.     public int getRealFlow() {
  96.         return realFlow;
  97.     }
  98.  
  99.     public void setRealFlow(int realFlow) {
  100.         this.realFlow = realFlow;
  101.     }
  102.  
  103.     /**
  104.      * 显示卡信息
  105.      */
  106.     public void showMeg(){
  107.         System.out.println("卡号："+this.cardNumber+" 用户名："+this.userName+" 当前余额："+this.money+"元。");
  108.         this.serPackage.showInfo();
  109.     }
  110. }
  1. package cn.soso.entity;
  2.  
  3. import cn.soso.common.Common;
  4. import cn.soso.service.NetService;
  5.  
  6. /**
  7.  * 网虫套餐
  8.  *
  9.  * @author yu
  10.  *
  11.  */
  12. public class NetPackage extends ServicePackage implements NetService {
  13.     private int flow; // 上网流量（MB）
  14.  
  15.     public NetPackage() {
  16.         //套餐数据初始化
  17.         this.flow = 1024 * 3;
  18.         this.price = 68.0;
  19.     }
  20.  
  21.     public NetPackage(int flow) {
  22.         super();
  23.         this.flow = flow;
  24.     }
  25.  
  26.     public int getFlow() {
  27.         return flow;
  28.     }
  29.  
  30.     public void setFlow(int flow) {
  31.         this.flow = flow;
  32.     }
  33.  
  34.     @Override
  35.     public void showInfo() {
  36.         System.out.println("网虫套餐：上网流量是" + flow / 1024 + "GB/月,月资费是"
  37.                 + this.price + "元/月。");
  38.     }
  39.  
  40.     /**
  41.      * 提供上网服务
  42.      */
  43.     public void netPlay2(int flow, MobileCard card) throws Exception {
  44.         int reminFlow = this.flow - card.getRealFlow();  //卡中可支付的免费流量
  45.         // 判断套餐中的上网流量是否足够支付本次上网服务
  46.         if (this.flow <= reminFlow) {
  47.             // 套餐中上网流量足够：修改该卡实际上网流量数据
  48.             card.setRealFlow(card.getRealFlow() + flow);
  49.         } else {
  50.             // 套餐中上网流量不够：额外消费需按0.1元/条付费，额外消费金额=0.1*（该卡实际消费上网流量+本次消费上网流量-套餐包含的上网流量）
  51.             double consumeMoney = 0.1 * (flow-reminFlow);
  52.             // 该卡账户余额足够支付：修改该卡实际使用的上网流量、账户余额、当月消费金额
  53.             if (card.getMoney() >= consumeMoney) {
  54.                 //消耗的流量增加
  55.                 card.setRealFlow(card.getRealFlow() + flow);
  56.                 // 当前账户余额＝当前账户余额－额外消费金额
  57.                 card.setMoney(card.getMoney() - consumeMoney);
  58.                 // 当月消费金额＝当月消费金额＋额外消费金额
  59.                 card.setConsumAmount(card.getConsumAmount() + consumeMoney);
  60.             } else {
  61.  
  62.                 int temp = (int)(card.getMoney()/0.1); //当前余额够大
  63.                 throw new Exception("您的余额不足，请充值后再使用！");
  64.             }
  65.         }
  66.     }
  67.  
  68.     /**
  69.      * 提供上网服务
  70.      */
  71.     public int netPlay(int flow, MobileCard card) throws Exception {
  72.         int temp = flow;
  73.         for(int i=0;i<flow;i++){
  74.             if(this.flow-card.getRealFlow()>=1){
  75.                 //第一种情况：套餐剩余流量可以支持使用1M流量
  76.                 card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB
  77.             }else if(card.getMoney()>=0.1){
  78.                 //第二种情况:套餐流量已用完，账户余额可以支付1M流量，使用账户余额支付
  79.                 card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB
  80.                 card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1M流量费用）
  81.                 card.setConsumAmount(card.getConsumAmount() + 0.1);
  82.             }else{
  83.                 temp = i;
  84.                 throw new Exception("本次已使用流量"+i+"MB,您的余额不足，请充值后再使用！");
  85.             }
  86.         }
  87.         return temp;
  88.     }
  89. }
  1. package cn.soso.entity;
  2. /**
  3.  * 使用场景
  4.  * @author yu
  5.  *
  6.  */
  7. public class Scene {
  8.     private String type;  //场景消费类型
  9.     private int data;  //消费数据
  10.     private String description;//场景描述
  11.  
  12.     public Scene(){}
  13.     public Scene(String type,int data,String description){
  14.         this.type = type;
  15.         this.data = data;
  16.         this.description = description;
  17.     }
  18.  
  19.     public String getType() {
  20.         return type;
  21.     }
  22.     public void setType(String type) {
  23.         this.type = type;
  24.     }
  25.     public int getData() {
  26.         return data;
  27.     }
  28.     public void setData(int data) {
  29.         this.data = data;
  30.     }
  31.     public String getDescription() {
  32.         return description;
  33.     }
  34.     public void setDescription(String description) {
  35.         this.description = description;
  36.     }
  37.  
  38. }
  1. package cn.soso.entity;
  2. /**
  3.  * 嗖嗖移动卡套餐
  4.  * @author yu
  5.  *
  6.  */
  7. public abstract class ServicePackage {
  8.     protected double price;  //套餐月资费(元)
  9.  
  10.     public double getPrice() {
  11.         return price;
  12.     }
  13.  
  14.     public void setPrice(double price) {
  15.         this.price = price;
  16.     }
  17.  
  18.     //显示套餐数据
  19.     public abstract void showInfo();
  20. }
  1. package cn.soso.entity;
  2.  
  3. import cn.soso.common.Common;
  4. import cn.soso.service.CallService;
  5. import cn.soso.service.NetService;
  6. import cn.soso.service.SendService;
  7.  
  8. /**
  9.  * 超人套餐
  10.  * @author yu
  11.  *
  12.  */
  13. public class SuperPackage extends ServicePackage implements CallService,
  14.         SendService,NetService {
  15.     private int talkTime;   //通话时长(分钟)
  16.     private int smsCount;   //短信条数（条）
  17.     private int flow;  //上网流量（MB）
  18.  
  19.     public int getTalkTime() {
  20.         return talkTime;
  21.     }
  22.  
  23.     public void setTalkTime(int talkTime) {
  24.         this.talkTime = talkTime;
  25.     }
  26.  
  27.     public int getSmsCount() {
  28.         return smsCount;
  29.     }
  30.  
  31.     public void setSmsCount(int smsCount) {
  32.         this.smsCount = smsCount;
  33.     }
  34.  
  35.     public int getFlow() {
  36.         return flow;
  37.     }
  38.  
  39.     public void setFlow(int flow) {
  40.         this.flow = flow;
  41.     }
  42.  
  43.     public SuperPackage(){
  44.         //套餐数据初始化
  45.         this.talkTime = 200;
  46.         this.smsCount = 50;
  47.         this.flow = 1*1024;
  48.         this.price = 78.0;
  49.     }
  50.     @Override
  51.     public void showInfo() {
  52.         System.out.println("超人套餐：通话时长为"+this.talkTime+"分钟/月，短信条数为"+this.smsCount+"条/月，上网流量为"+this.flow/1024+"GB/月。");
  53.     }
  54.  
  55.     /**
  56.      * 提供上网服务
  57.      */
  58.     public int netPlay(int flow, MobileCard card) throws Exception {
  59.         int temp = flow;
  60.         for(int i=0;i<flow;i++){
  61.             if(this.flow-card.getRealFlow()>=1){
  62.                 //第一种情况：套餐剩余流量可以支持使用1M流量
  63.                 card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB
  64.             }else if(card.getMoney()>=0.1){
  65.                 //第二种情况:套餐流量已用完，账户余额可以支付1M流量，使用账户余额支付
  66.                 card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB
  67.                 card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1M流量费用）
  68.                 card.setConsumAmount(card.getConsumAmount() + 0.1);
  69.             }else{
  70.                 temp = i;
  71.                 throw new Exception("本次已使用流量"+i+"MB,您的余额不足，请充值后再使用！");
  72.             }
  73.         }
  74.         return temp;
  75.     }
  76.  
  77.     /**
  78.      * 提供通话服务
  79.      */
  80.     public int call(int minCount, MobileCard card) throws Exception{
  81.         int temp = minCount;
  82.         for(int i=0;i<minCount;i++){
  83.             if(this.talkTime-card.getRealTalkTime()>=1){
  84.                 //第一种情况：套餐剩余通话时长可以付1分钟通话
  85.                 card.setRealTalkTime(card.getRealTalkTime()+1); //实际通话数据加1
  86.             }else if(card.getMoney()>=0.2){
  87.                 //第二种情况:套餐通话时长已用完，账户余额可以支付1分钟通话，使用账户余额支付
  88.                 card.setRealTalkTime(card.getRealTalkTime()+1); //实际使用通话时长1分钟
  89.                 card.setMoney(Common.sub(card.getMoney(),0.2)); //账户余额消费0.2元（1分钟额外通话）
  90.                 card.setConsumAmount(card.getConsumAmount() + 0.2);
  91.             }else{
  92.                 temp = i; //记录实现通话分钟数
  93.                 throw new Exception("本次已通话"+i+"分钟,您的余额不足，请充值后再使用！");
  94.             }
  95.         }
  96.         return temp;
  97.     }
  98.  
  99.     /**
  100.      * 提供短信服务
  101.      */
  102.     public int sendMessage(int smsCount, MobileCard card) throws Exception {
  103.         int temp = smsCount;
  104.         for(int i=0;i<smsCount;i++){
  105.             if(this.smsCount-card.getRealSMSCount()>=1){
  106.                 //第一种情况：套餐剩余短信条数可以付1条短信
  107.                 card.setRealSMSCount(card.getRealSMSCount()+1); //实际使用短信条数加1
  108.             }else if(card.getMoney()>=0.1){
  109.                 //第二种情况:套餐短信条数已用完，账户余额可以支付1条短信，使用账户余额支付
  110.                 card.setRealSMSCount(card.getRealSMSCount()+1);
  111.                 card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1条短信费用）
  112.                 card.setConsumAmount(card.getConsumAmount() + 0.1);
  113.             }else{
  114.                 temp = i;
  115.                 throw new Exception("本次已发送短信"+i+"条,您的余额不足，请充值后再使用！");
  116.             }
  117.         }
  118.         return temp;
  119.     }
  120.  
  121. }
  1. package cn.soso.entity;
  2. import cn.soso.common.Common;
  3. import cn.soso.service.CallService;
  4. import cn.soso.service.SendService;
  5.  
  6. /**
  7.  * 话唠套餐
  8.  *
  9.  * @author yu
  10.  *
  11.  */
  12. public class TalkPackage extends ServicePackage implements CallService,
  13.         SendService {
  14.     private int talkTime; // 通话时长(分钟)
  15.     private int smsCount; // 短信条数（条）
  16.  
  17.     public int getTalkTime() {
  18.         return talkTime;
  19.     }
  20.  
  21.     public void setTalkTime(int talkTime) {
  22.         this.talkTime = talkTime;
  23.     }
  24.  
  25.     public int getSmsCount() {
  26.         return smsCount;
  27.     }
  28.  
  29.     public void setSmsCount(int smsCount) {
  30.         this.smsCount = smsCount;
  31.     }
  32.  
  33.     public TalkPackage() {
  34.         //套餐数据初始化
  35.         this.talkTime = 500;
  36.         this.smsCount = 30;
  37.         this.price = 58.0;
  38.     }
  39.  
  40.     public TalkPackage(int talkTime, int smsCount) {
  41.         super();
  42.         this.talkTime = talkTime;
  43.         this.smsCount = smsCount;
  44.     }
  45.  
  46.     /**
  47.      * 显示套餐详情
  48.      */
  49.     public void showInfo() {
  50.         System.out.println("话唠套餐：通话时长为" + this.talkTime + "分钟/月，短信条数为"
  51.                 + this.smsCount + "条/月，资费为" + this.price + "元/月。");
  52.     }
  53.  
  54.     public int call(int minCount, MobileCard card) throws Exception{
  55.         int temp = minCount;
  56.         for(int i=0;i<minCount;i++){
  57.             if(this.talkTime-card.getRealTalkTime()>=1){
  58.                 //第一种情况：套餐剩余通话时长可以付1分钟通话
  59.                 card.setRealTalkTime(card.getRealTalkTime()+1); //实际使用流量加1MB
  60.             }else if(card.getMoney()>=0.2){
  61.                 //第二种情况:套餐通话时长已用完，账户余额可以支付1分钟通话，使用账户余额支付
  62.                 card.setRealTalkTime(card.getRealTalkTime()+1); //实际使用通话时长1分钟
  63.                 card.setMoney(Common.sub(card.getMoney(),0.2)); //账户余额消费0.2元（1M流量费用）
  64.                 card.setConsumAmount(card.getConsumAmount() + 0.2);
  65.             }else{
  66.                 temp = i; //记录实现通话分钟数
  67.                 throw new Exception("本次已通话"+i+"分钟,您的余额不足，请充值后再使用！");
  68.             }
  69.         }
  70.         return temp;
  71.     }
  72.  
  73.     public int sendMessage(int smsCount, MobileCard card) throws Exception {
  74.         int temp = smsCount;
  75.         for(int i=0;i<smsCount;i++){
  76.             if(this.smsCount-card.getRealSMSCount()>=1){
  77.                 //第一种情况：套餐剩余短信条数可以付1条短信
  78.                 card.setRealSMSCount(card.getRealSMSCount()+1); //实际使用短信条数加1
  79.             }else if(card.getMoney()>=0.1){
  80.                 //第二种情况:套餐短信条数已用完，账户余额可以支付1条短信，使用账户余额支付
  81.                 card.setRealSMSCount(card.getRealSMSCount()+1);
  82.                 card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1条短信费用）
  83.                 card.setConsumAmount(card.getConsumAmount() + 0.1);
  84.             }else{
  85.                 temp = i;
  86.                 throw new Exception("本次已发送短信"+i+"条,您的余额不足，请充值后再使用！");
  87.             }
  88.         }
  89.         return temp;
  90.     }
  91.  
  92. }
  • 接口：　
  1. package cn.soso.service;
  2.  
  3. import cn.soso.entity.MobileCard;
  4.  
  5. /**
  6.  * 通话服务接口
  7.  * @author yu
  8.  *
  9.  */
  10. public interface CallService {
  11.     //打电话
  12.     public int call(int minCount,MobileCard card) throws Exception;
  13. }
  1. package cn.soso.service;
  2.  
  3. import cn.soso.entity.MobileCard;
  4.  
  5. /**
  6.  * 上网服务
  7.  * @author yu
  8.  *
  9.  */
  10. public interface NetService {
  11.     //上网
  12.     public int netPlay(int flow,MobileCard card) throws Exception;
  13. }
  1. package cn.soso.service;
  2.  
  3. import cn.soso.entity.MobileCard;
  4.  
  5. /**
  6.  * 短信服务
  7.  * @author yu
  8.  *
  9.  */
  10. public interface SendService {
  11.     //发短信
  12.     public int sendMessage(int count,MobileCard card) throws Exception;
  13. }
  • 工具类
  1. package cn.soso.utils;
  2.  
  3. import java.io.FileReader;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.io.Reader;
  7. import java.io.Writer;
  8. import java.text.DecimalFormat;
  9. import java.util.ArrayList;
  10. import java.util.HashMap;
  11. import java.util.Iterator;
  12. import java.util.List;
  13. import java.util.Map;
  14. import java.util.Random;
  15. import java.util.Set;
  16.  
  17. import cn.soso.common.Common;
  18. import cn.soso.entity.ConsumInfo;
  19. import cn.soso.entity.MobileCard;
  20. import cn.soso.entity.NetPackage;
  21. import cn.soso.entity.Scene;
  22. import cn.soso.entity.ServicePackage;
  23. import cn.soso.entity.SuperPackage;
  24. import cn.soso.entity.TalkPackage;
  25. import cn.soso.service.CallService;
  26. import cn.soso.service.NetService;
  27. import cn.soso.service.SendService;
  28.  
  29. /**
  30.  * 手机卡工具类
  31.  *
  32.  * @author yu
  33.  *
  34.  */
  35. public class CardUtil {
  36.     Map<String, MobileCard> cards = new HashMap<String, MobileCard>(); // 所有手机卡的列表
  37.     Map<String, List<ConsumInfo>> consumInfos = new HashMap<String, List<ConsumInfo>>(); // 所有手机卡消费记录的列表
  38.     List<Scene> scenes = new ArrayList<Scene>();
  39.  
  40.     // 初始化用户
  41.     public void init() {
  42.         MobileCard card1 = new MobileCard("何玲玲", "123", "13965756432",
  43.                 new TalkPackage(), 58.0, 42.0);
  44.         MobileCard card2 = new MobileCard("黄露露", "123", "13956712467",
  45.                 new NetPackage(), 68.0, 32.0);
  46.         MobileCard card3 = new MobileCard("朱蓉蓉", "123", "13911568956",
  47.                 new SuperPackage(), 78.0, 22.0);
  48.         MobileCard card4 = new MobileCard("桃跑跑", "123", "13924221868",
  49.                 new TalkPackage(), 78.0, 2.0);
  50.         card4.setConsumAmount(98.0);
  51.         card4.setRealTalkTime(500);
  52.         card4.setRealSMSCount(100);
  53.         cards.put("13965756432", card1);
  54.         cards.put("13956712467", card2);
  55.         cards.put("13911568956", card3);
  56.         cards.put("13924221868", card4);
  57.     }
  58.  
  59.     /**
  60.      * 使用场景初始化
  61.      */
  62.     public void initScenes(){
  63.         scenes.add(new Scene("通话",90,"问候客户，谁知其如此难缠 通话90分钟"));
  64.         scenes.add(new Scene("通话",30,"询问妈妈身体状况 本地通话30分钟"));
  65.         scenes.add(new Scene("短信",5,"参与环境保护实施方案问卷调查 发送短信5条"));
  66.         scenes.add(new Scene("短信",50,"通知朋友手机换号，发送短信50条"));
  67.         scenes.add(new Scene("上网",1*1024,"和女友微信视频聊天   使用流量1G"));
  68.         scenes.add(new Scene("上网",2*1024,"晚上手机在线看韩剧，不留神睡着啦！ 使用流量 2G"));
  69.     }
  70.  
  71.     /**
  72.      * 是否存在此卡用户
  73.  
  74.      *
  75.      * @param number
  76.      * @param passWord
  77.      * @return
  78.      */
  79.     public boolean isExistCard(String number, String passWord) {
  80.         Set<String> numbers = cards.keySet();
  81.         Iterator<String> it = numbers.iterator();
  82.         while (it.hasNext()) {
  83.             String searchNum = it.next();
  84.             if (searchNum.equals(number)
  85.                     && (cards.get(searchNum)).getPassWord().equals(passWord)) {
  86.                 return true;
  87.             }
  88.         }
  89.         return false;
  90.     }
  91.  
  92.     /**
  93.      * 查找指定卡号是否已注册
  94.      *
  95.      * @param searchNumber
  96.      * @return 未注册：false 已注册：true
  97.      */
  98.     public boolean isExistCard(String searchNumber) {
  99.         Set<String> numbers = cards.keySet();
  100.         for (String number : numbers) {
  101.             if (number.equals(searchNumber)) {
  102.                 return true;
  103.             }
  104.         }
  105.         return false;
  106.     }
  107.  
  108.     /**
  109.      * 创建卡号（以139开头 11位）
  110.      *
  111.      * @return 生成的随机手机卡号
  112.      */
  113.     public String createNumber() {
  114.         Random random = new Random();
  115.         boolean isExist = false; // 记录现有用户中是否存在此卡号用户 是：true 否：false
  116.         String number = "";
  117.         int temp = 0;
  118.         do {
  119.             isExist = false; // 标志位重置为false,用于控制外重循环，当生成了
  120.             // 生成的随机数是8位 不能小于10000000，否则重新生成
  121.             do {
  122.                 temp = random.nextInt(100000000);
  123.             } while (temp < 10000000);
  124.             // 生成之前，前面加“139”
  125.             number = "139" + temp;
  126.             // 和现有用户的卡号比较，不能是重复
  127.             Set<String> cardNumbers = cards.keySet();
  128.             for (String cardNumber : cardNumbers) {
  129.                 if (number.equals(cardNumber)) {
  130.                     isExist = true;
  131.                     break;
  132.                 }
  133.             }
  134.         } while (isExist);
  135.         return number;
  136.     }
  137.  
  138.     /**
  139.      * 生成指定个数的新卡号列表
  140.      *
  141.      * @param count
  142.      *  指定个数
  143.      * @return 卡号列表
  144.      */
  145.     public String[] getNewNumbers(int count) {
  146.  
  147.         String[] numbers = new String[count];
  148.         for (int i = 0; i < count; i++) {
  149.             numbers[i] = createNumber();
  150.         }
  151.         return numbers;
  152.     }
  153.  
  154.     /**
  155.      * 添加新卡
  156.      *
  157.      * @param card
  158.      *  新卡
  159.      */
  160.     public void addCard(MobileCard card) {
  161.         cards.put(card.getCardNumber(), card);
  162.         System.out.print("注册成功！");
  163.         card.showMeg();
  164.     }
  165.  
  166.     /**
  167.      * 指定卡号办理退网
  168.      *
  169.      * @param card
  170.      */
  171.     public void delCard(String delNumber) {
  172.         if (isExistCard(delNumber)) {
  173.             cards.remove(delNumber);
  174.             System.out.println("卡号" + delNumber + "办理退网成功！");
  175.         } else {
  176.             System.out.println("对不起，该卡号未注册，不能办退退网！");
  177.         }
  178.     }
  179.  
  180.     /**
  181.      * 查询指定卡套餐余量
  182.      *
  183.      * @param number
  184.      */
  185.     public void showRemainDetail(String searchNumber) {
  186.         MobileCard card; // 要查询的卡
  187.         int remainTalkTime;
  188.         int remainSmsCount;
  189.         int remainFlow;
  190.         StringBuffer meg = new StringBuffer();
  191.         card = cards.get(searchNumber);
  192.         meg.append("您的卡号是" + searchNumber + "，套餐内剩余：\n");
  193.         ServicePackage pack = card.getSerPackage();
  194.         if (pack instanceof TalkPackage) {
  195.             //向下转型为话唠套餐对象
  196.             TalkPackage cardPack = (TalkPackage) pack;
  197.             // 话唠套餐，查询套餐内剩余的通话时长和短信条数
  198.             remainTalkTime = cardPack.getTalkTime() > card
  199.                     .getRealTalkTime() ? cardPack.getTalkTime()
  200.                     - card.getRealTalkTime() : 0;
  201.             meg.append("通话时长：" + remainTalkTime + "分钟\n");
  202.             remainSmsCount = cardPack.getSmsCount() > card
  203.                     .getRealSMSCount() ? cardPack.getSmsCount()
  204.                     - card.getRealSMSCount() : 0;
  205.             meg.append("短信条数：" + remainSmsCount + "条");
  206.         } else if (pack instanceof NetPackage) {
  207.             //向下转型为网虫套餐对象
  208.             NetPackage cardPack = (NetPackage) pack;
  209.             // 网虫套餐：查询套餐内剩余的上网流量
  210.             remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
  211.                     .getFlow() - card.getRealFlow() : 0;
  212.             meg.append("上网流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
  213.                     + "GB");
  214.         } else if (pack instanceof SuperPackage) {
  215.             //向下转型为超人套餐对象
  216.             SuperPackage cardPack = (SuperPackage) pack;
  217.             // 超人套餐：查询套餐内剩余的通话时长、短信条数、上网流量
  218.             remainTalkTime = cardPack.getTalkTime() > card
  219.                     .getRealTalkTime() ? cardPack.getTalkTime()
  220.                     - card.getRealTalkTime() : 0;
  221.             meg.append("通话时长：" + remainTalkTime + "分钟\n");
  222.             remainSmsCount = cardPack.getSmsCount() > card
  223.                     .getRealSMSCount() ? cardPack.getSmsCount()
  224.                     - card.getRealSMSCount() : 0;
  225.             meg.append("短信条数：" + remainSmsCount + "条\n");
  226.             remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
  227.                     .getFlow() - card.getRealFlow() : 0;
  228.             meg.append("上网流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
  229.                     + "GB");
  230.         }
  231.         System.out.println(meg);
  232.     }
  233.  
  234.     /**
  235.      * 查询指定卡当月消费详单
  236.      *
  237.      * @param searchNumber
  238.      */
  239.     public void showAmountDetail(String searchNumber) {
  240.         MobileCard card; // 要查询的卡
  241.         StringBuffer meg = new StringBuffer();
  242.         card = cards.get(searchNumber);
  243.         meg.append("您的卡号：" + card.getCardNumber() + ",当月账单：\n");
  244.         meg.append("套餐资费：" + card.getSerPackage().getPrice() + "元\n");
  245.         meg.append("合计：" + Common.dataFormat(card.getConsumAmount()) + "元\n");
  246.         meg.append("账户余额：" + Common.dataFormat(card.getMoney()) + "元");
  247.         // 显示本月消费详细信息
  248.         System.out.println(meg);
  249.     }
  250.  
  251.     /**
  252.      * 指定卡号换套餐
  253.      *
  254.      * @param number
  255.      * @param packType
  256.      */
  257.     public void changingPack(String number, String packNum) {
  258.         MobileCard card; // 指定的手机卡
  259.         ServicePackage pack; // 要换的套餐
  260.         if (isExistCard(number)) {
  261.             card = cards.get(number);
  262.             // 获取要换的套餐对象
  263.             switch (packNum) {
  264.                 case "1":
  265.                     pack = new TalkPackage();
  266.                     break;
  267.                 case "2":
  268.                     pack = new NetPackage();
  269.                     break;
  270.                 default:
  271.                     pack = new SuperPackage();
  272.                     break;
  273.             }
  274.             if (!(card.getSerPackage().getClass().getName().equals(pack.getClass().getName()))) {
  275.                 // 该卡余额中减去当月套餐资费
  276.                 if (card.getMoney() >= pack.getPrice()) {
  277.                     card.setMoney(card.getMoney() - pack.getPrice());
  278.                     // 换套餐
  279.                     card.setSerPackage(pack);
  280.                     // 当月实际使用数据清零
  281.                     card.setRealTalkTime(0);
  282.                     card.setRealFlow(0);
  283.                     card.setRealSMSCount(0);
  284.                     // 当月消费金额设置为新套餐月资费
  285.                     card.setConsumAmount(pack.getPrice());
  286.                     System.out.print("更换套餐成功！");
  287.                     pack.showInfo();
  288.                 } else {
  289.                     System.out.println("对不起，您的余额不足以支付新套餐本月资费，请充值后再办理更换套餐业务！");
  290.                     return;
  291.                 }
  292.             } else {
  293.                 System.out.println("对不起，您已经是该套餐用户，无需换套餐！");
  294.             }
  295.  
  296.         } else {
  297.             System.out.println("对不起，该卡号未注册，不能换套餐！");
  298.         }
  299.     }
  300.  
  301.     /**
  302.      * 为指定手机卡充值
  303.      *
  304.      * @param number
  305.      *  指定充值的卡号
  306.      * @param money
  307.      * 充值金额
  308.      */
  309.     public void chargeMoney(String number, double money) {
  310.         MobileCard card; // 指定的手机卡
  311.         if (money < 50) {
  312.             System.out.println("对不起，最低充值金额为50元！");
  313.             return;
  314.         }
  315.         card = cards.get(number);
  316.         card.setMoney(card.getMoney() + money);
  317.         System.out.println("充值成功，当前话费余额为" + Common.dataFormat(card.getMoney()) + "元。");
  318.     }
  319.  
  320.     /**
  321.      * 添加一条指定卡的消费记录
  322.      *
  323.      * @param number
  324.      *            要添加消费记录的卡
  325.      * @param info
  326.      *            要添加的消费记录
  327.      */
  328.     public void addConsumInfo(String number, ConsumInfo info) {
  329.         Set<String> numbers = consumInfos.keySet();
  330.         Iterator<String> it = numbers.iterator();
  331.         List<ConsumInfo> infos = new ArrayList<ConsumInfo>();
  332.         boolean isExist = false; // 现有消费列表中是否存在此卡号消费记录，是：true 否：false
  333.         while (it.hasNext()) {
  334.             if (it.next().equals(number)) {
  335.                 // 消费集合中已有该卡号消费记录，则找到该卡号的消费记录集合，添加一条即可
  336.                 infos = consumInfos.get(number);
  337.                 infos.add(info);
  338.                 isExist = true;
  339.                 System.out.println("已添加一条消费记录。");
  340.                 break;
  341.             }
  342.         }
  343.         // 该集合中没有此卡号消费记录，则添加
  344.         if (!isExist) {
  345.             infos.add(info);
  346.             consumInfos.put(number, infos);
  347.             System.out.println("不存在此卡的消费记录，已添加一条消费记录。");
  348.         }
  349.     }
  350.  
  351.     //打印消费记录
  352.     public void printConsumInfo(String number){
  353.         Writer fileWriter = null;
  354.         try {
  355.             fileWriter = new FileWriter(number+"消费记录.txt");
  356.             Set<String> numbers = consumInfos.keySet();
  357.             Iterator<String> it = numbers.iterator();
  358.             List<ConsumInfo> infos = new ArrayList<ConsumInfo>();//存储指定卡所有消费记录
  359.             boolean isExist = false; // 现有消费列表中是否存在此卡号消费记录，是：true 否：false
  360.             while (it.hasNext()) {
  361.                 if (it.next().equals(number)) {
  362.                     infos = consumInfos.get(number);
  363.                     isExist = true;
  364.                     break;
  365.                 }
  366.             }
  367.             if(isExist){
  368.                 //存在 此卡消费记录，写入文本文件
  369.                 StringBuffer content = new StringBuffer("******"+number+"消费记录******\n");
  370.                 content.append("序号\t类型\t数据（通话（条）/上网（MB）/短信（条））\n");
  371.                 for(int i=0;i<infos.size();i++){
  372.                     ConsumInfo info = infos.get(i);
  373.                     content.append((i+1)+".\t"+info.getType()+"\t"+info.getConsumData()+"\n");
  374.                 }
  375.                 fileWriter.write(content.toString());
  376.                 fileWriter.flush();
  377.  
  378.                 System.out.println("消费记录打印完毕！");
  379.             }else{
  380.                 System.out.println("对不起，不存在此号码的消费记录，不能打印！");
  381.             }
  382.         } catch (IOException e) {
  383.             e.printStackTrace();
  384.         }finally{
  385.             if(fileWriter!=null){
  386.                 try {
  387.                     fileWriter.close();
  388.                 } catch (IOException e) {
  389.                     e.printStackTrace();
  390.                 }
  391.             }
  392.         }
  393.     }
  394.  
  395.     /**
  396.      * 使用嗖嗖
  397.      * @param number 当前卡号
  398.      * @throws Exception
  399.      */
  400.     public void userSoso(String number)  {
  401.         MobileCard card = cards.get(number); // 获取此卡对象
  402.         ServicePackage pack = card.getSerPackage(); // 获取此卡所属套餐
  403.         Random random = new Random();
  404.         int ranNum = 0;
  405.         int temp = 0;  //记录各场景中实际消费数据
  406.         do{
  407.  
  408.             ranNum = random.nextInt(6);// 生成一个0~5之前的随机数
  409.             Scene scene = scenes.get(ranNum); //获取该序号所对应的场景
  410.             switch (ranNum) {
  411.                 //序号为0或1为通话场景
  412.                 case 0:
  413.                 case 1:
  414.                     // 判断该卡所属套餐是否支持通话功能
  415.                     if (pack instanceof CallService) {
  416.                         // 执行通话方法
  417.                         System.out.println(scene.getDescription());
  418.                         CallService callService = (CallService) pack;
  419.                         try {
  420.                             temp = callService.call(scene.getData(), card);
  421.                         } catch (Exception e) {
  422.                             e.printStackTrace();
  423.                         }
  424.                         // 添加一条消费记录
  425.                         addConsumInfo(number, new ConsumInfo(number,
  426.                                 scene.getType(), temp));
  427.                         break;
  428.                     } else {
  429.                         // 如果该卡套餐不支持通话功能，则重新生成随机数选择其他场景
  430.                         continue;
  431.                     }
  432.                     //序号为2或3为发短信场景
  433.                 case 2:
  434.                 case 3:
  435.                     // 判断该卡所属套餐是否支持短信功能
  436.                     if (pack instanceof SendService) {
  437.                         // 执行发短信方法
  438.                         System.out.println(scene.getDescription());
  439.                         SendService sendService = (SendService) pack;
  440.                         try {
  441.                             temp = sendService.sendMessage(scene.getData(), card);
  442.                         } catch (Exception e) {
  443.                             e.printStackTrace();
  444.                         }
  445.                         // 添加一条消费记录
  446.                         addConsumInfo(number, new ConsumInfo(number,
  447.                                 scene.getType(), temp));
  448.                         break;
  449.                     } else {
  450.                         // 如果该卡套餐不支持发短信功能，则重新生成随机数选择其他场景
  451.                         continue;
  452.                     }
  453.                     //序号为4或5为发上网场景
  454.                 case 4:
  455.                 case 5:
  456.                     // 判断该卡所属套餐是否支持上网功能
  457.                     if (pack instanceof NetService) {
  458.                         System.out.println(scene.getDescription());
  459.                         NetService netService = (NetService) pack;
  460.                         // 执行上网方法
  461.                         try {
  462.                             temp = netService.netPlay(scene.getData(), card);
  463.                         } catch (Exception e) {
  464.                             e.printStackTrace();
  465.                         }
  466.                         // 添加一条消费记录
  467.                         addConsumInfo(number, new ConsumInfo(number,
  468.                                 scene.getType(), temp));
  469.                         break;
  470.                     } else {
  471.                         // 如果该卡套餐不支持上网功能，则重新生成随机数选择其他场景
  472.                         continue;
  473.                     }
  474.             }
  475.             break;
  476.         }while(true);
  477.     }
  478.  
  479.     /**
  480.      * 根据套餐序号返回套餐对象
  481.      *
  482.      * @param packNum
  483.      *            套餐序号
  484.      * @return 套餐对象
  485.      */
  486.     public ServicePackage createPack(int packId) {
  487.         ServicePackage pack = null;
  488.         switch (packId) {
  489.             case 1:
  490.                 pack = new TalkPackage();
  491.                 break;
  492.             case 2:
  493.                 pack = new NetPackage();
  494.                 break;
  495.             case 3:
  496.                 pack = new SuperPackage();
  497.                 break;
  498.         }
  499.         return pack;
  500.     }
  501.  
  502.     /**
  503.      * 显示资费说明
  504.      */
  505.     public void showDescription(){
  506.         Reader rd = null;
  507.         try {
  508.             rd = new FileReader("套餐资费说明.txt");
  509.             char[] content = new char[1024];
  510.             int len = 0;
  511.             StringBuffer sb = new StringBuffer();
  512.             while((len=rd.read(content))!=-1){
  513.                 sb.append(content,0,len);  //拼接字符串
  514.             }
  515.             System.out.println(sb);
  516.         } catch (IOException e) {
  517.             // TODO Auto-generated catch block
  518.             e.printStackTrace();
  519.         }
  520.     }
  521.  
  522. }

Java面向对象和高级特性 项目实战（一）的更多相关文章

  1. Java开发知识之Java类的高级特性,内部类.以及包使用.跟常量关键字

    Java开发知识之Java类的高级特性,内部类.以及包使用.跟常量关键字 一丶Java中包的机制 首先包其实就是个文件夹.作用就是管理类. Java中每次定义一个类的时候.通过Java编译之后.都会生 ...

  2. Python面向对象编程高级特性

    ***这里还是根据网上资料,主要是廖雪峰老师的教程学习的笔记,主要介绍python面向对象的高级特性,笔记不全,只是记录自己觉得容易出错的地方*** 1.python作为一种动态语言,他的动态绑定机制 ...

  3. 谈谈Java面向对象的三大特性

    Java面向对象的三大特性就是指封装.继承.多态了. 一.封装: 概念:封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式. (举例:笔记本电脑就是一个封装体,Java语言中最小的封装体就是函数 ...

  4. Java学习笔记二十五:Java面向对象的三大特性之多态

    Java面向对象的三大特性之多态 一:什么是多态: 多态是同一个行为具有多个不同表现形式或形态的能力. 多态就是同一个接口,使用不同的实例而执行不同操作. 多态性是对象多种表现形式的体现. 现实中,比 ...

  5. Java学习笔记二十一:Java面向对象的三大特性之继承

    Java面向对象的三大特性之继承 一:继承的概念: 继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类. 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方 ...

  6. Java学习笔记十八:Java面向对象的三大特性之封装

    Java面向对象的三大特性之封装 一:面向对象的三大特性: 封装 继承 多态   二:封装的概念: 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访 ...

  7. JAVA面向对象编程课程设计——项目部署

    目录 一.Java环境的安装 1.下载 2.安装 3.配置环境变量 二.Tomcat的安装 1.下载 2.安装 3.启动Tomcat(默认已经安装好java环境,如果未安装java会报错.) 三.My ...

  8. java面向对象的三大特性

    1.面向对象的三大特性 继承.封装.多态 什么是继承? ①继承是面向对象程序设计能够提高软件开发效率的重要原因之一. ②继承是具有传递性的,就像现实中孙子不仅长得像爸爸而且还像他爷爷. ③继承来的属性 ...

  9. Java 面向对象的三大特性之一 继承

    继承: Java是继承的三大特性之一,是Java中实现代码重用的手段之一 将重复的代码抽取到父类中继承的有点或者现实 优点: 方便修改代码 减少代码量 Java中继承的语法: 修饰符 SubClass ...

随机推荐

  1. Python元组的一点用法

    #python的基本语法网上已经有很多详细的解释了,写在这里方便自己记忆一些 元组可以理解为不可变动的列表,访问元组中元素的方式和列表相同,但是需要注意的是元组中的元素是不可修改(增删)的 1.列表的 ...

  2. docker学习端口映射---第二章节

    一.运行一个web应用 首先,下载一个docker镜像: [root@k8s-01 ~]# docker pull training/webapp 运行webapp的容器: [root@k8s-01 ...

  3. unigui的页面布局使用

    (unigui的页面布局还是很强大的,基本什么的排版都能搞好.前面部分为原文章翻译,翻译不一定很准确,就能看吧,后面有使用说明,有什么不明白的欢迎加我QQ(910300653)一起交流学习) 一.布局 ...

  4. JS中的加减乘除和比较赋值

    隐式类型转换 使用Boolean(), Number(), String()去转换数据类型的方法叫显示类型转换,而与它相对的就是隐式类型转换,隐式类型转换并没有明显的标志,而是JS解释器觉得做这样一个 ...

  5. Shell 有类型变量

    1.通过 declare 和 typeset 命令 declare 和 typeset 两者等价 declare 和 typeset 都是用来定义变量类型的 下面以 declare 进行总结 2.de ...

  6. 基于Java Instrument的Agent实现

    使用 Instrumentation,使得开发者可以构建一个独立于应用程序的代理程序(Agent),用来监测和协助运行在 JVM 上的程序,甚至能够替换和修改某些类的定义.有了这样的功能,开发者就可以 ...

  7. PyQt5 -pycharm 环境搭建

    1.安装PyQt5 在CMD窗口执行命令: pip3 install PyQt5 安装 pyqt_toools pip3 install PyQt5-tools 2.配置PyCharm 1)打开PyC ...

  8. jdk环境变量配置改变不生效的问题

    在工作中两次遇到jdk配置上的这个问题:将环境变量中的jdk路径修改之后,使用-version查看,版本号还是之前的,也就是说修改未生效.甚至当我将Path变量中的jdk路径配置都删除了之后,使用-v ...

  9. mybatis进行一对多时发现的问题总结

    1.定义一对多xml文件时,所有的resultMap中的column的值一定不要重复,否则mybatis会发生错误,如果有重名,定义别名,column中的名字一定要与查询出的名字一致,如: 52行的别 ...

  10. 2017年5月12日15:10:46 rabbitmq不支持非阻塞调用服务器

    就像昨天碰到的问题描述一样,问题不是出在消费者上而是在生产者发送消息出现没有得到返回值时消息通道被挂起,rabbitmq发送的消息是阻塞调用即当发生阻塞时,继续发送的消息都堆在后面.在网上看到有两个方 ...