第一阶段-模块二-代码详解

1. 编程实现以下需求：

定义一个长度为[16][16]的整型二维数组并输入或指定所有位置的元素值，分别实现二维数组中所有行和所有列中所有元素的累加和并打印。

再分别实现二维数组中左上角到右下角和右上角到左下角所有元素的累加和并打印。

package com.lagou.module02;


/**
 * 定义一个长度为[16][16]的整型二维数组并输入或指定所有位置的元素值，分别实现二维数组中所有行和所有列中所有元素的累加和并打印。
 * 再分别实现二维数组中左上角到右下角和右上角到左下角所有元素的累加和并打印。
 *
 * 二维数组求列总和未解决
 */

//  第一步 封装一个类
public class Code0201 {
　　1、创建int类型的变量标记X、Y轴坐标
　　　 创建arr二维数组
    //  定义行/列/二位数组
    private int sumRows;
    //private int sumCols;
    private int sumLeft;
    private int sumRight;
    private int x;　　　　private int y;　　　　private int[][] arr;
　　
　　2、无参方式初始化二维数组
    public Code0201() {
        this.sumRows = 0;
        this.sumLeft = 0;
        this.sumRight = 0;
        this.x = 0;
        this.y = 0;
        arr = new int[16][16];　　
    }
　　
　　有参方式初始化二维数组，把X轴Y轴坐标传入数组中
    public Code0201(int rows, int cols) {
        this.sumRows = 0;
        this.sumLeft = 0;
        this.sumRight = 0;
        this.x = 0;
        this.y = 0;
        arr = new int[rows][cols];
    }

    public int[][] getArr() {
        return arr;
    }

    public void setArr(int[][] arr) {
        this.arr = arr;
    }

    3、嵌套for循环把二层数组打印出来
    public void addValue(){
        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr[i].length;j++){
                arr[i][j] = j;
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

　　4、求和
    public void addShow(){
　　　　　 　　for循环把外层数组的长度取出来，放在I中
        for (int i=0;i<arr.length;i++){
　　　　　　　　当i达到总长度的时候，累加器还原到0的状态
            if(x == i){
                sumRows = 0;
            }
　　　　　　　 　　for循环把内层数组的长度取出来，放在J中
            for (int j=0;j<arr[i].length;j++){
　　　　　　　　　　
　　　　　　　　　　存储每一个的总和，累加器等于当前i行j总长度的累加，j长度为16那么sumRows就等于0-15总和（就是当前i行的总和）
                sumRows += arr[i][j];
                if(j == arr[i].length-1) {
                    System.out.println("第" + i + "行的值为：" + sumRows);
                    x += 1;
                }

　　　　　　　　　　存储每列第一个元素的总和，每次循环当J为0时存储在Y中，累加并打印当前循环Y的累加数值
                if(0 == j){
                    y += arr[i][j];
                    System.out.println("Y = " + y);
                }
　　　　　　　　　　
　　　　　　　　　　存储左上角到右下角的总和，每行I与J的值相当把该元素存储在累加器中并打印（第一行0，0/第二行1，1如此类推）
                if(i == j) {
                    sumLeft += arr[i][j];
                }
　　　　　　　　　　
　　　　　　　　　　存储右上角到左下角的总和，当J的值等于每次循环每次循环最大长度1的时候的累加（第一次循环时16-1-0）
                if(j == arr[i].length-1-i){
                    sumRight += arr[i][j];
                }
            }
        }
        System.out.println("左上角到右下角的总和是："+sumLeft);
        System.out.println("右上角到左下角的总和是："+sumRight);
    }
}

------------------------------------测试类------------------------------------------------

package com.lagou.module02;

public class Code0201Test {
    public static void main(String[] args) {
        Code0201 code0201 = new Code0201(16,16);
        code0201.addValue();
        code0201.addShow();
    }
}

2. 编程实现控制台版并支持两人对战的五子棋游戏。 

（1）绘制棋盘 - 写一个成员方法实现 

（2）提示黑方和白方分别下棋并重新绘制棋盘 - 写一个成员方法实现。 

（3）每当一方下棋后判断是否获胜 - 写一个成员方法实现。

package com.lagou.module02;

import java.util.Scanner;

1、创建二维数组
public class Code0202 {
    private String[][] board;
    private char white;
    private char black;
    private int rows;   //  行
    private int cols;   //  列

    Code0202() {
    }
　　
2、初始化二维数组
    Code0202(int rows, int cols, char white, char black) {
        setBoard(rows, cols);
        setWhite(white);
        setBlack(black);
        setRows(rows);
        setCols(cols);
    }

    public void setRows(int rows) {
        this.rows = rows;
    }

    public void setCols(int cols) {
        this.cols = cols;
    }

    public int getRows() {
        return rows;
    }

    public int getCols() {
        return cols;
    }

    public void setBoard(int rows, int cols) {
        board = new String[rows][cols];
    }

    public void setWhite(char white) {
        this.white = white;
    }

    public void setBlack(char black) {
        this.black = black;
    }

    public String[][] getBoard(int rows, int cols) {
        return board;
    }

    public char getWhite() {
        return white;
    }

    public char getBlack() {
        return black;
    }
　　
　　3、打印棋盘
    public void getBoard() {
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
　　　　　　　　　　打印Y轴第一列，转为为整形十六进制打印
                if (i == 0) {
                    board[i][j] = String.format("%x", j - 1);
　　　　　　　　　　打印X轴第一列，转换为整型十六进制打印
                } else if (j == 0) {
                    board[i][j] = String.format("%x", i - 1);
                } else {
　　　　　　　　　　剩下全部打印+号
                    board[i][j] = "+";
                }
            }
        }
        board[0][0] = " ";
    }
　　
　　打印棋子
    public void showBoard() {
        for (String[] str : board) {
            for (int j = 0; j < board[0].length; j++) {
                if ("白".equals(str[j])) {
                    System.out.print(white + " ");
                } else if ("黑".equals(str[j])) {
                    System.out.print(black + " ");
                } else {
                    System.out.print(str[j] + " ");

                }
            }
            System.out.println();
        }
    }
　　
　　接受到游戏入口传来的参数判断获胜条件
    private Boolean isWin(int x, int y, String chess, int rows, int cols) {
        int countCol = -1;
        int countRow = -1;
        int countDiagonalLeft = -1;
        int countDiagonalRight = -1;
        int a;
        int b;
        a = x;
        b = y;
　　　　 无线循环，判断获胜条件
        while (true) {
　　　　　　　从右到左判断5个棋子是否连在一起，如果其中有一个棋子断开就执行break，b=0的时候也执行break
            if (chess.equals(board[a][b])) {
                countRow++;
                if (b == 0) {
                    break;
                }
                b--;
            } else {
                break;
            }
        }
        a = x;
        b = y;
        while (true) {
　　　　　　　左到右判断5个棋子是否连在一起，如果其中一个棋子断开就执行break，b达到数组最末尾的时候也执行break
            if (chess.equals(board[a][b])) {
                countRow++;
                if (b == (cols - 1)) {
                    break;
                }
                b++;
            } else {
                break;
            }
        }

        a = x;
        b = y;
        while (true) {
　　　　　　判断纵列是否连城5只棋子，判断条件与上述一样
            if (chess.equals(board[a][b])) {
                countCol++;
                if (a == 0) {
                    break;
                }
                a--;
            } else {
                break;
            }
        }
        a = x;
        b = y;
        while (true) {
　　　　　　判断纵列是否5只棋子连城5只，判断条件与上述一样
            if (chess.equals(board[a][b])) {
                countCol++;
                if (a == (rows - 1)) {
                    break;
                }
                a++;
            } else {
                break;
            }
        }
        a = x;
        b = y;
        while (true) {
　　　　　　判断左到右斜角线5只棋子是否连成5只，判断条件与上述一样
            if (chess.equals(board[a][b])) {
                countDiagonalLeft++;
                if (a == 0 || b == 0) {
                    break;
                }
                a--;
                b--;
            } else {
                break;
            }
        }
        a = x;
        b = y;
        while (true) {
　　　　　　判断右到左5只棋子连成5只，判断条件上述一样
            if (chess.equals(board[a][b])) {
                countDiagonalLeft++;
                if (a == (rows - 1) || b == (cols - 1)) {
                    break;
                }
                a++;
                b++;
            } else {
                break;
            }
        }
        a = x;
        b = y;
        while (true) {
　　　　　　　　判断右上到左下5只棋子是否连在一起，判断条件上述一样
            if (chess.equals(board[a][b])) {
                countDiagonalRight++;
                if (a == 0 || b == (cols - 1)) {
                    break;
                }
                a--;
                b++;
            } else {
                break;
            }
        }
        a = x;
        b = y;
        while (true) {
　　　　　　判断左下到右上5只棋子是否连在一起，判断条件与上述一样
            if (chess.equals(board[a][b])) {
                countDiagonalRight++;
                if (a == (rows - 1) || b == 0) {
                    break;
                }
                a++;
                b--;
            } else {
                break;
            }
        }

        System.out.println("countRow:" + countRow);
        System.out.println("countCol:" + countCol);
        System.out.println("countDiagonalLeft:" + countDiagonalLeft);
        System.out.println("countDiagonalRight:" + countDiagonalRight);

        return (countRow >= 5 || countCol >= 5 || countDiagonalLeft >= 5 || countDiagonalRight >= 5);
    }
　　
　　 4、编写游戏入口
　　　　注意：该方法会一直重复执行，直到黑棋或者白棋一方在siWin（）方法中获胜为止。
    public void startGame() {　　　　
　　　　 创建扫描器，获取X轴Y轴
        Scanner sc = new Scanner(System.in);
        boolean flag = true;
        int x;
        int y;
        String chess;
　　　　　编写无线循环切换白棋与黑棋下棋顺序
        while (true) {
            if (flag) {
                System.out.println("请白方落子。");
                chess = "白";
            } else {
                System.out.println("请黑方落子。");
                chess = "黑";
            }
            x = sc.nextInt() + 1;
            y = sc.nextInt() + 1;
　　　　　　  编写规则，不允许棋子超出棋盘范围或者坐标重复
            if (x < 0 || y < 0 || x > 16 || y > 16) {
                System.out.println("落子超出棋盘范围，请重新落子。");
                continue;
            }
            if ("+".equals(board[x][y])) {
                board[x][y] = chess;
            } else {
                System.out.println("当前坐标不可落子，请重新落子。");
                continue;
            }
            showBoard();
            flag = !flag;
　　　　　　　把获取到的横纵坐标，数组传入到iswin方法中
            boolean isWin = isWin(x, y, chess, getRows(), getCols());
            if (isWin) {
                System.out.printf("恭喜%s方获胜！", chess);
                break;
            }
        }
　　　　　游戏获胜后释放内存空间
        sc.close();
    }
}

-----------------------------------------------测试类----------------------------------------------------------

package com.lagou.module02;

public class Code0202Test {
    public static void main(String[] args) {
        // 自定义棋子
        char white = 0x25cb;
        char black = 0x25cf;
        Code0202 code = new Code0202(17, 17, white, black);
        // 绘制棋盘
        code.getBoard();
        // 显示棋盘
        code.showBoard();
        // 开始游戏
        code.startGame();
    }

}

3. 按照要求设计并实现以下实体类和接口。 

    3.1 第一步：设计和实现以下类 

    （1）手机卡类 特征：卡类型、卡号、用户名、密码、账户余额、通话时长(分钟)、上网流量 行为：显示（卡号 + 用户名 + 当前余额） 

    （2）通话套餐类 特征：通话时长、短信条数、每月资费 行为: 显示所有套餐信息     （3）上网套餐类 特征：上网流量、每月资费 行为：显示所有套餐信息 

    （4）用户消费信息类 特征：统计通话时长、统计上网流量、每月消费金额 

    3.2 第二步：设计和实现以下枚举类 手机卡的类型总共有 3 种：大卡、小卡、微型卡 

    3.3 第三步：实体类的优化 将通话套餐类和上网套餐类中相同的特征和行为提取出来组成抽象套餐类。 

    3.4 第四步：创建并实现以下接口 

    （1）通话服务接口 抽象方法: 参数1: 通话分钟, 参数2: 手机卡类对象 让通话套餐类实现通话服务接口。 

    （2）上网服务接口 抽象方法: 参数1: 上网流量, 参数2: 手机卡类对象 让上网套餐类实现上网服务接口。

3.5 第五步：进行代码测试

编写测试类使用多态格式分别调用上述方法，方法体中打印一句话进行功能模拟即可。

----------------------------------------抽象类--------------------------------------------------------
1、编写抽象类，抽象内中有两个成员对象以及一个抽象方法
package com.lagou.module02;

/**
 * 抽象类套餐类
 */
public abstract class Code0203Abstract {
    private int expenses;
    private int quantity;
    /**
     *  expenses    资费
     *  quantity    数量
     */

    public Code0203Abstract() {
    }

    public Code0203Abstract(int expenses,int quantity) {
        setExpenses(expenses);
        setQuantity(quantity);
    }

    public int getExpenses() {
        return expenses;
    }

    public void setExpenses(int expenses) {
        this.expenses = expenses;
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public abstract void show();
}
--------------------------------------通话接口-------------------------------------------------------
2、通话接口，接口中也有一个抽象方法传入时间与对象

package com.lagou.module02;

/**
 * 通话服务接口(通话分钟，手机卡类型)
 */
public interface Code0203CallInterface {
    public abstract void callPackage(int callTime,Code0203PhoneCard code0203PhoneCard);
}

--------------------------------------上网接口-------------------------------------------------------

3、上网接口，接口中也有抽象方法传入流量与对象

package com.lagou.module02;

/**
 * 上网流量接口（上网流量，手机卡类型）
 */
public interface Code0203InternetInterface {
    public abstract void internetPackage(int internetTraffic,Code0203PhoneCard code0203PhoneCard);
}

--------------------------------------普通通话类-------------------------------------------------------

4、编写普通通话类实现通话类，该类继承了抽象类并且实现通话接口

package com.lagou.module02;

import java.util.Scanner;

/**
 * 通话套餐类
 */
public class Code0203CallPackage extends Code0203Abstract implements Code0203CallInterface{
    private int message;

    Code0203Consumption code = new Code0203Consumption();
    /**
     *  expenses    资费
     *  quantity    赠送通话时间
     *  message     赠送短信
     */

    public Code0203CallPackage() {
    }

    public Code0203CallPackage(int expenses, int quantity, int message) {
        super(expenses, quantity);
        this.message = message;
    }

    public int getMessage() {
        return message;
    }

    public void setMessage(int message) {
        this.message = message;
    }
　　
　　重写通话接口，打印继承下来的抽象成员Expenses/quantity/以及自身的成员message
    //  通话类：打印套餐情况
    @Override
    public void show() {
        System.out.printf("通讯套餐：国内语音%d元/分钟，赠送%d分钟国内语音，赠送国内短彩信%d条，包含国内接听来电显示。",getExpenses(),getQuantity(),getMessage());
    }
　　
　　重写接口抽象方法，计算传入进来的时间并把时间和对象传回code类的countCalltime方法中
    //  重写通话服务接口方法
    @Override
    public void callPackage(int callTime,Code0203PhoneCard code0203PhoneCard) {
        if (getQuantity() == 0){
            setQuantity(1);
        }
        code.countCallTime(callTime,getQuantity(),code0203PhoneCard);
    }
}

--------------------------------------普通上网类-------------------------------------------------------

5、编写普通上网类，继承抽象方法并且实现接口

package com.lagou.module02;

/**
 * 上网套餐类
 */
public class Code0203InternetPackage extends Code0203Abstract implements Code0203InternetInterface{
    /**
     *  expenses    资费
     *  quantity    数量
     */

    Code0203Consumption code = new Code0203Consumption();
    Code0203InternetPackage() {
    }

    public Code0203InternetPackage(int expenses, int quantity) {
        super(expenses, quantity);
    }
　　
　　重写抽象方法，并且打印继承下来的抽象方法中的成员以及自身的成员
    //  重写抽象套餐类，打印套餐信息（充值）
    @Override
    public void show() {
        System.out.printf("上网套餐：国内流量日租%d元/GB，赠送国内流量%dGB",getExpenses(),getQuantity());
    }
　　
　　重写接口中的抽象方法，把流量、资费、对象传回code。countInternetTraffic方法中
    //  重写上网流量接口（使用）
    @Override
    public void internetPackage(int internetTraffic, Code0203PhoneCard code0203PhoneCard) {
        if(getExpenses() == 0){
            setExpenses(1);
        }
        code.countInternetTraffic(internetTraffic,getExpenses(),code0203PhoneCard);
    }
}

--------------------------------------枚举类-------------------------------------------------------

5、使用enum关键字创建枚举类

package com.lagou.module02;

/**
 * 枚举类
 */
public enum Code0203Enum {
　　枚举类要求最上面第一行创建对象，对象的数量固定好外部不能new新的对象
    A("大卡"),B("小卡"),C("微型卡");

    private final String size;

    private Code0203Enum(String size){
        this.size = size;
    }

    public String getSize() {
        return size;
    }
}

--------------------------------------手机卡类-------------------------------------------------------
6、创建手机卡类，并且打印手机卡信息

package com.lagou.module02;

import com.lagou.task10.StaticOuter;

import java.awt.print.Pageable;

/**
* 手机卡类
*/
public class Code0203PhoneCard {
    private String cardType;
    private String phoneNumber;
    private String name;
    private String password;
    private int accountBalance;
    private int callTime;
    private int internetTraffic;

    Code0203CallPackage callPackage = new Code0203CallPackage();
    Code0203InternetPackage internetPackage = new Code0203InternetPackage();
    /**
     * cardType         卡类型
     * phoneNumber      卡号
     * name             用户名
     * password         密码
     * accountBalance   账户余额
     * callTime         通话时间
     * internetTraffic  总上网流量
     */

    Code0203PhoneCard(){};
　　
　　初始化手机卡
    public Code0203PhoneCard(String cardType, String phoneNumber, String name, String password, int accountBalance, int callTime, int internetTraffic) {
        setCardType(cardType);
        setPhoneNumber(phoneNumber);
        setName(name);
        setPassword(password);
        setAccountBalance(accountBalance);
        setCallTime(callTime);
        setInternetTraffic(internetTraffic);
    }

    public String getCardType() {
        return cardType;
    }

    public void setCardType(String cardType) {
        this.cardType = cardType;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAccountBalance() {
        return accountBalance;
    }

    public void setAccountBalance(int accountBalance) {
        this.accountBalance = accountBalance;
    }

    public int getCallTime() {
        return callTime;
    }

    public void setCallTime(int callTime) {
        this.callTime = callTime;
    }

    public int getInternetTraffic() {
        return internetTraffic;
    }

    public void setInternetTraffic(int internetTraffic) {
        this.internetTraffic = internetTraffic;
    }

    //  订购上网套餐

　　1、show方法使用传多个参数方式接收对象
    //  打印账户信息
    public void show(int... args){
        System.out.println("============================手机卡信息==================================");
        for(int i = 0;i<args.length;i++){
            if(i == 0){
                setCallTime(args[i]);
            }else{
                setInternetTraffic(args[i]);
            }
        }
        showAccountBalance();
    }
　　
　　2、showAccountBalance方法打印账户情况
    public void showAccountBalance(){
        //  显示账户余额
        System.out.println("==============================账户余额================================");
        System.out.println("手机卡类型:"+getCardType()+"
卡号:"+getPhoneNumber()+"
用户名："+getName()+"
密码："+getPassword()+
                "
账户余额:"+getAccountBalance()+"
历史通话时长："+getCallTime()+"分钟
历史流量使用情况:"+getInternetTraffic()+"GB");
    }
　　
　　3、创建通话消费方法addCall，传入到普通通话类中
    //  通话消费
    public void addCall(int a,Code0203PhoneCard code0203PhoneCard){
        callPackage.callPackage(a,code0203PhoneCard);
    }
　　
　　4、创建流量消费方法addinternet，传入到普通上网类中
    //  流量消费
    public void addInternet(int a,Code0203PhoneCard code0203PhoneCard){
        internetPackage.internetPackage(a,code0203PhoneCard);
    }
}

--------------------------------------历史账单累计类-------------------------------------------------------

7、统计类

package com.lagou.module02;

import java.util.Scanner;

/**
 * 用户消费类
 * 1、统计通话时长
 * 2、统计上网流量
 * 3、每月消费金额
 */
public class Code0203Consumption {
    private int callTime;
    private int internetTraffic;
    private int expenses;
    /**
     *  callTime            统计通话时长
     *  internetTraffic     统计上网流量
     *  expenses            统计消费金额
     */

    Code0203Consumption() {
    }

    public Code0203Consumption(int callTime, int internetTraffic, int expenses) {
        setCallTime(callTime);
        setInternetTraffic(internetTraffic);
        setExpenses(expenses);
    }

    public int getCallTime() {
        return callTime;
    }

    public void setCallTime(int callTime) {
        this.callTime = callTime;
    }

    public int getInternetTraffic() {
        return internetTraffic;
    }

    public void setInternetTraffic(int internetTraffic) {
        this.internetTraffic = internetTraffic;
    }

    public int getExpenses() {
        return expenses;
    }

    public void setExpenses(int expenses) {
        this.expenses = expenses;
    }
　　通话时长方法与统计上网流量方法只能依顺序进行，确保账户扣款的准确性
　　1、接收到普通通话类传过来的参数，根据手机卡情况统计消费时长并且打印账户余额，如果账户中通话时长为0就是初始通话调用if中的语句，如果账户中通话时长大于0就是历史通话调用else语句
    public void countCallTime(int quantity,int expenses,Code0203PhoneCard code0203PhoneCard){
        //  统计通话时长
        if(code0203PhoneCard.getCallTime() == 0){
            code0203PhoneCard.setCallTime(quantity);    //  初次通话时间
        }else {
            setCallTime(code0203PhoneCard.getCallTime()+quantity);
            code0203PhoneCard.setCallTime(getCallTime());   //  登记历史通话时间
        }
        code0203PhoneCard.setAccountBalance(code0203PhoneCard.getAccountBalance()-(quantity*expenses));
        System.out.println("============================历史通话时间==================================");
        System.out.printf("历史通话时间：%d分钟，账户余额%d元
",code0203PhoneCard.getCallTime(),code0203PhoneCard.getAccountBalance());
    }
　　2、接收普通上网类传过来的参数，根据手机卡情况统计上网情况，原理与上述方法一致
    public void countInternetTraffic(int quantity,int expenses,Code0203PhoneCard code0203PhoneCard){
        //  统计上网流量
        if(code0203PhoneCard.getInternetTraffic() == 0){
            code0203PhoneCard.setInternetTraffic(quantity);    //初次登记历史通话时间
        }else {
            setInternetTraffic(code0203PhoneCard.getInternetTraffic()+quantity);
            code0203PhoneCard.setInternetTraffic(getInternetTraffic());
        }
        code0203PhoneCard.setAccountBalance(code0203PhoneCard.getAccountBalance()-(quantity*expenses));
        System.out.println("==========================历史流量使用情况================================");
        System.out.printf("历史流量使用情况：%dGB,账户余额%d元
",code0203PhoneCard.getInternetTraffic(),code0203PhoneCard.getAccountBalance());
    }

}

--------------------------------------测试类-------------------------------------------------------

package com.lagou.module02;

/**
 * 接口
 * 1、通话服务接口(通话时间，手机卡类型)            Code0203CallInterface
 * 2、上网流量接口（上网流量，手机卡类型）          Code0203InternetInterface
 * 抽象类
 * 1、抽象类                                      Code0203Abstract
 * 普通类
 * 1、通话套餐类      Code0203CallPackage         实现抽象类/通话服务接口    抽象类方法未重写
 * 2、上网套餐类      Code0203InternetPackage     实现抽象类/上网服务接口    抽象类方法未重写
 * 3、用户消费类      Code0203Consumption         未实现统计方法
 * 4、手机卡类        Code0203PhoneCard
 * 枚举类
 * 1、枚举类          Code0203Enum
 */
public class Code0203Test {
    public static void main(String[] args) {
        System.out.println("============================注册手机==================================");
        //  订购通话套餐
        Code0203Abstract code0203CallPackage = new Code0203CallPackage(1,0,0);
        //  订购上网套餐
        Code0203Abstract code0203InternetPackage = new Code0203InternetPackage(1,0);
        //  创建消费统计
        Code0203Consumption code0203Consumption = new Code0203Consumption(code0203CallPackage.getQuantity(),code0203InternetPackage.getQuantity(),20);
        //  注册一张手机卡，枚举手机卡类型：大卡
        Code0203PhoneCard phoneCard = new Code0203PhoneCard(Code0203Enum.B.getSize(),"10000","用户名","密码",1000,
                code0203CallPackage.getQuantity(),code0203InternetPackage.getQuantity());
        //  打印手机卡信息
        phoneCard.show(code0203CallPackage.getQuantity(),code0203InternetPackage.getQuantity());

        // 消费
        phoneCard.addCall(120,phoneCard);
        phoneCard.addInternet(20,phoneCard);

        //显示账户余额
        phoneCard.showAccountBalance();

        //再次消费测试
        phoneCard.addCall(120,phoneCard);
        phoneCard.addInternet(20,phoneCard);
        phoneCard.addCall(120,phoneCard);
        phoneCard.addInternet(20,phoneCard);
        phoneCard.showAccountBalance();
    }
}