小白有沒有和我相同的感覺，感覺自己還會點東西，這次作業就無情打臉，以後還是乖乖學，練手題二----看著簡單動手墨滴-突然感覺自己好水

模組二的練習來了-第二個題還是有點難的整了一天還是沒整出來，最後還是參考別人的

1. 程式設計實現以下需求：

定義一個長度為[16][16]的整型二維陣列並輸入或指定所有位置的元素值，分別實現二維陣列中所有行和所有列中所有元素的累加和並列印。

再分別實現二維陣列中左上角到右下角和右上角到左下角所有元素的累加和並列印。

實現類

package code_1;
import java.util.Random;
public class arr {

    //定義行列以及陣列
    private int row;
    private int column;
    private int [][] arrs;


    //定義行的和，列，對角線的和
    private int[] sumRows;
    private int[] sumCols;
    private int[] sumDiagonal;


    public arr() {
    }

    public arr(int row, int column) {
        this.row = row;
        this.column = column;
        setSumDiagonal(2);
        sumRows=new  int[row];
        sumCols=new  int[column];
        arrs = new int[row][column];

    }


    public void setRow(int row) {
        this.row = row;
    }

    public void setColumn(int column) {
        this.column = column;
    }

    public void setArrs(int[][] arrs) {
        this.arrs = arrs;
    }

    public void setSumRows(int[] sumRows) {
        this.sumRows = sumRows;
    }

    public void setSumCols(int[] sumCols) {
        this.sumCols = sumCols;
    }

    public void setSumDiagonal(int number) {
        sumDiagonal = new int[number];
    }

    public int getRow() {
        return row;
    }

    public int getColumn() {
        return column;
    }

    public int[][] getArrs() {
        return arrs;
    }


    /**
     * 得到所有行的和
     * @return
     */
    public int[] getSumRows() {
        System.out.println("\n====列印各行的和====");
        for (int i = 0; i < sumRows.length; i++) {
            System.out.println("第"+i+"列的和"+sumRows[i]);
        }

        return sumRows;
    }
    /**
     * 得到所有列的和
     * @return
     */
    public int[] getSumCols() {
        System.out.println("\n====列印各列的和====");
        for (int i = 0; i < sumCols.length; i++) {
            System.out.println("第"+i+"行的和"+sumCols[i]);
        }
        return sumCols;
    }

    public int[] getSumDiagonal() {
        System.out.println("\n====對角線的和====");
        System.out.println("從左上角到右下角的和"+ sumDiagonal[0]);
        System.out.println("從右下角到左上角的和"+sumDiagonal[1]);
        return sumDiagonal;
    }

    /**
     *指定所有位置的元素值
     */


    public void add(){
        Random ra=new Random();
        for (int i = 0; i <arrs.length; i++) {
            for (int j = 0; j < arrs[i].length; j++) {
                arrs[i][j]=ra.nextInt(10);
                sumRows[i] += arrs[i][j];
                sumCols[j] += arrs[i][j];
                if (i == j) {
                    sumDiagonal[0] += arrs[i][j];
                }
                if (i == (arrs[i].length -1-j )) {
                    sumDiagonal[1] += arrs[i][j];
                }
            }

        }
    }
    /**
     * 列印陣列
     */

    public void show(){
      for (int i = 0; i < arrs.length; i++) {
          for (int j = 0; j < arrs[i].length; j++) {
              System.out.print(" "+arrs[i][j]);
          }
          System.out.println();
      }
  }

}

測試類

package code_1;

public class it_test_1 {
    public static void main(String[] args) {
        arr array=new arr(16,16);
        array.add();//新增元素
        array.show();
        array.getSumRows();//行的和
        array.getSumCols();//列的和
        array.getSumDiagonal();//對角線的和




    }
}

2. 程式設計實現控制檯版並支援兩人對戰的五子棋遊戲。

（1）繪製棋盤 - 寫一個成員方法實現

（2）提示黑方和白方分別下棋並重新繪製棋盤 - 寫一個成員方法實現。

（3）每當一方下棋後判斷是否獲勝 - 寫一個成員方法實現。

（4）提示： 採用二維陣列來模擬並描述棋盤，棋盤如下：

實現類

package code_2;

import java.util.Scanner;

public class gobang {
    //（1）繪製棋盤 - 寫一個成員方法實現
            private String[][] checkerboard;
    //定義白棋黑棋
            private char black_mole;
            private char white_mole;
    // 棋盤大小
            private int rows;
            private int cols;

    public gobang() {
    }

    public gobang( char black_mole, char white_mole, int rows, int cols) {
        setCheckerboardint(rows,cols);
        setBlack_mole(black_mole);
        setWhite_mole(white_mole );
        setCols(cols);
        setRows(cols);
    }


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

    public char getBlack_mole() {
        return black_mole;
    }

    public void setBlack_mole(char black_mole) {
        this.black_mole = black_mole;
    }

    public char getWhite_mole() {
        return white_mole;
    }

    public void setWhite_mole(char white_mole) {
        this.white_mole = white_mole;
    }

    public int getRows() {
        return rows;
    }

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

    public int getCols() {
        return cols;
    }

    public void setCols(int cols) {
        this.cols = cols;
    }
//繪製棋盤
    public void getCheckerboard(){
        for (int i = 0; i < checkerboard.length; i++) {
            for (int j = 0; j < checkerboard[i].length; j++) {
                checkerboard[0][0]=" ";
                if (0==i) {checkerboard[i][j]=String.format("%x",j-1);}
                else if (0==j) {checkerboard[i][j]=String.format("%x",i-1);}
                else {checkerboard[i][j]="+";}
            }
        }

    }
//列印棋盤
    public void showcheckerboard() {
        for (String[] str : checkerboard) {
            for (int j = 0; j < checkerboard[0].length; j++) {
                if ("白".equals(str[j])) {
                    System.out.print(white_mole + " ");
                } else if ("黑".equals(str[j])) {
                    System.out.print(black_mole + " ");
                } 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){
            if (chess.equals(checkerboard[a][b])) {
                countRow++;
                if (b == 0) {
                    break;
                }
                b--;
            }else {
                break;
            }
        }
        // 行：向右數相同的棋子
        a = x;//行
        b = y;//列
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countRow++;
                // 防止陣列下標越界
                if (b == (cols - 1)) {
                    break;
                }
                b++;
            } else {
                break;
            }
        }

        // 列：向下數相同的棋子
        a = x;//行
        b = y;//列
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countCol++;
                // 防止陣列下標越界
                if (a == 0) {
                    break;
                }
                a--;
            } else {
                break;
            }
        }
        // 列：向上數相同的棋子
        a = x;
        b = y;
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countCol++;
                // 防止陣列下標越界
                if (a == (rows - 1)) {
                    break;
                }
                a++;
            } else {
                break;
            }
        }
        // 左對角：左上數相同的棋子
        a = x;
        b = y;
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countDiagonalLeft++;
                // 防止陣列下標越界
                if (a == 0 || b == 0) {
                    break;
                }
                a--;
                b--;
            } else {
                break;
            }
        }
        // 左對角：右下數相同的棋子
        a = x;
        b = y;
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countDiagonalLeft++;
                // 防止陣列下標越界
                if (a == (rows - 1) || b == (cols - 1)) {
                    break;
                }
                a++;
                b++;
            } else {
                break;
            }
        }

        // 右對角：右上數相同的棋子
        a = x;
        b = y;
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countDiagonalRight++;
                // 防止陣列下標越界
                if (a == 0 || b == (cols - 1)) {
                    break;
                }
                a--;
                b++;
            } else {
                break;
            }
        }
        // 右對角：左下數相同的棋子
        a = x;
        b = y;
        while (true) {
            if (chess.equals(checkerboard[a][b])) {
                countDiagonalRight++;
                // 防止陣列下標越界
                if (a == (rows - 1) || b == 0) {
                    break;
                }
                a++;
                b--;
            } else {
                break;
            }
        }


        return (countRow >= 5 || countCol >= 5 || countDiagonalLeft >= 5 || countDiagonalRight >= 5);
    }

//遊戲入口
    public void startGame() {
        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(checkerboard[x][y])) {
                checkerboard[x][y] = chess;
            } else {
                System.out.println("當前座標不可落子，請重新落子。");
                continue;
            }
            showcheckerboard();
            flag = !flag;
            boolean isWin = isWin(x, y, chess, getRows(), getCols());
            if (isWin) {
                System.out.printf("恭喜%s方獲勝！", chess);
                break;
            }
        }
    }
}

測試類

/**
 * 2. 程式設計實現控制檯版並支援兩人對戰的五子棋遊戲。

 （1）繪製棋盤 - 寫一個成員方法實現

 （2）提示黑方和白方分別下棋並重新繪製棋盤 - 寫一個成員方法實現。

 （3）每當一方下棋後判斷是否獲勝 - 寫一個成員方法實現。
 */
public class it_test_2 {
    public static void main(String[] args) {

        char black_mole=0x2665;
        char white_mole=0x2022;
        gobang go=new gobang(black_mole,white_mole,17,17);
        go.getCheckerboard();
        go.showcheckerboard();
        go.startGame();

    }



}

3. 按照要求設計並實現以下實體類和介面。

   3.1 第一步：設計和實現以下類

   （1）手機卡類 特徵：卡型別、卡號、使用者名稱、密碼、賬戶餘額、通話時長(分鐘)、上網流量 行為：顯示（卡號 + 使用者名稱 + 當前餘額）

   （2）通話套餐類 特徵：通話時長、簡訊條數、每月資費 行為: 顯示所有套餐資訊 （3）上網套餐類 特徵：上網流量、每月資費 行為：顯示所有套餐資訊

   （4）使用者消費資訊類 特徵：統計通話時長、統計上網流量、每月消費金額

   3.2 第二步：設計和實現以下列舉類 手機卡的型別總共有 3 種：大卡、小卡、微型卡

   3.3 第三步：實體類的優化 將通話套餐類和上網套餐類中相同的特徵和行為提取出來組成抽象套餐類。

   3.4 第四步：建立並實現以下介面

   （1）通話服務介面 抽象方法: 引數1: 通話分鐘, 引數2: 手機卡類物件 讓通話套餐類實現通話服務介面。

   （2）上網服務介面 抽象方法: 引數1: 上網流量, 引數2: 手機卡類物件 讓上網套餐類實現上網服務介面。

3.5 第五步：進行程式碼測試

編寫測試類使用多型格式分別呼叫上述方法，方法體中列印一句話進行功能模擬即可。

消費類

public class UserConsume {
    // 統計餘額、通話時長、上網流量
    private int consumeValue;
    private int consumeCallDuration;
    private int consumeNetworkData;

    public void setConsumeValue(int consumeValue) {
        this.consumeValue = consumeValue;
    }

    public void setConsumeCallDuration(int consumeCallDuration) {
        this.consumeCallDuration = consumeCallDuration;
    }

    public void setConsumeNetworkData(int consumeNetworkData) {
        this.consumeNetworkData = consumeNetworkData;
    }

    public int getConsumeValue() {
        return consumeValue;
    }

    public int getConsumeCallDuration() {
        return consumeCallDuration;
    }

    public int getConsumeNetworkData() {
        return consumeNetworkData;
    }

    // 列印消費情況
    public void showInfo() {
        System.out.printf("\n消費情況：您已通話 "+consumeCallDuration+"分鐘；流量使用"+consumeNetworkData+"GB;合計消費"+consumeValue+"元。");
    }
}

手機卡類

public class PhoneCard {


        private String cardType;
        private String cardId;
        private String userName;
        private String password;
        private int accountBalance;
        private int callDuration;
        private int networkData;
        private UserConsume userConsume;

        public PhoneCard() {
        }


        public PhoneCard(String cardType, String cardId, String userName, String password, int accountBalance,
                                 int callDuration, int networkData, UserConsume userConsume) {
            setCardType(cardType);
            setCardId(cardId);
            setUserName(userName);
            setPassword(password);
            setAccountBalance(accountBalance);
            setCallDuration(callDuration);
            setNetworkData(networkData);
            setUserConsume(userConsume);
        }

        public UserConsume getUserConsume() {
            return userConsume;
        }

        public void setUserConsume(UserConsume userConsume) {
            this.userConsume = userConsume;
        }

        public String getCardType() {
            return cardType;
        }

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

        public String getCardId() {
            return cardId;
        }

        public void setCardId(String cardId) {
            this.cardId = cardId;
        }

        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 int getAccountBalance() {
            return accountBalance;
        }

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

        public int getCallDuration() {
            return callDuration;
        }

        public void setCallDuration(int callDuration) {
            this.callDuration = callDuration;
        }

        public int getNetworkData() {
            return networkData;
        }

        public void setNetworkData(int networkData) {
            this.networkData = networkData;
        }

        /**
         * 增加消費方法
         *
         * @param consumeValue 消費金額
         * @param consumeCallDuration 通話時長
         * @param consumeNetworkData 上網流量
         */
        public void addComsume(int consumeValue, int consumeCallDuration, int consumeNetworkData) {
            // 記錄消費金額
            getUserConsume().setConsumeValue(getUserConsume().getConsumeValue() + consumeValue);
            // 記錄通話時長
            getUserConsume().setConsumeCallDuration(getUserConsume().getConsumeCallDuration() + consumeCallDuration);
            //記錄上網流量
            getUserConsume().setConsumeNetworkData(getUserConsume().getConsumeNetworkData() + consumeNetworkData);
        }

        //列印資訊
        public void showInfo() {
            System.out.printf("卡號：%s\n使用者名稱：%s\n當前餘額：%d元\n", getCardId(), getUserName(), getAccountBalance());
            // 列印消費情況
            getUserConsume().showInfo();

        }

        /**
         * 多型
         * 列印使用者所有資訊與各類套餐內容
         *
         *
         * @param abstractPackage 套餐抽象類物件
         */
        public void showOnCreate(AbstractPackage... abstractPackage) {
            System.out.printf("卡號：%s\n型別：%s\n使用者名稱：%s\n密碼：%s\n時長包：%d分鐘\n流量包：%dGB\n當前餘額：%d元\n", getCardId(), getCardType(),
                    getUserName(), getPassword(), getCallDuration(), getNetworkData(), getAccountBalance());
            for (int i = 0; i < abstractPackage.length; i++) {
                abstractPackage[i].showInfo();
            }

        }


}

通話套餐類

public class PhonePackage extends AbstractPackage implements ServeCall {
    // 記錄簡訊條數
    private int message;

    //初始化通話套餐
    public PhonePackage(int price, int phonePackage,int message) {
        // 繼承抽象套餐類
        super(price,phonePackage);
        // 設定簡訊
        setMessage(message);
    }

    public void setMessage(final int message) {
        this.message = message;
    }

    public int getMessage() {
        return message;
    }

    // 重寫抽象套餐類，列印套餐資訊；
    @Override
    public void showInfo() {
        System.out.printf("通話套餐：時長包"+getPhonePackage()+"分鐘;每月資費"+getPrice()+"元/分鐘;簡訊"+getMessage()+"條");
    }
    @Override
    // 重寫通話服務介面方法
    public void server(int number, PhoneCard phoneCard) {
        // 消費金額=通話數量*資費
        int consumeValue=number*getPrice();
        // 手機餘額減消費
        phoneCard.setAccountBalance(phoneCard.getAccountBalance() - consumeValue);
        // 新增通話消費時長
        phoneCard.addComsume(consumeValue,number,0);
        // 列印手機卡當前消費資訊
        phoneCard.showInfo();
    }



}

抽象類

public abstract class AbstractPackage {
    // 套餐資費
    private int price;
    // 套餐數量
    private int phonePackage;

    // 無參構造
    public AbstractPackage() {
    }

    // 初始化套餐
    public AbstractPackage(int price, int phonePackage) {
        setPrice(price);
        setPhonePackage(phonePackage);
    }

    // 設定資費
    public void setPrice(int price) {
        this.price = price;
    }

    // 獲取資費
    public int getPrice() {
        return price;
    }

    // 設定套餐數量
    public void setPhonePackage(int phonePackage) {
        this.phonePackage = phonePackage;
    }

    // 獲取套餐
    public int getPhonePackage() {
        return phonePackage;
    }

    // 列印套餐資訊
    public abstract void showInfo();


}

上網套餐類

public class NetworkPackage extends AbstractPackage implements ServerNtework {

    public NetworkPackage(int price, int phonePackage) {
        // 繼承抽象類套餐
        super(price,phonePackage);
    }


    //重寫抽象套餐類，列印套餐資訊；
    @Override
    public void showInfo() {
        System.out.printf("上網套餐：流量包"+getPhonePackage()+"GB;每月資費"+getPrice()+"元/GB");
    }

    // 重寫上網服務介面方法
    // 重寫上網服務介面方法
    @Override
    public void server(int networkData, PhoneCard phoneCard) {
        // 消費金額=上網流量*資費
        int consumeValue=networkData*getPrice();
        // 手機餘額減消費
        phoneCard.setAccountBalance(phoneCard.getAccountBalance() - consumeValue);
        // 新增流量消費數量
        phoneCard.addComsume(consumeValue,0,networkData);
        // 列印手機卡當前消費資訊
        phoneCard.showInfo();
    }

}

卡型列舉類

public enum Type_enum {

    BIG("大卡"), SMALL("小卡"), MINI("微型卡");

    private final String cardType;

    private Type_enum(String cardType) {
        this.cardType = cardType;
    }

    public String getCardType() {
        return cardType;
    }

}

*** 通話服務介面：**

public interface ServeCall {
    // 通話數量，手機卡物件
    public abstract void server(int number, PhoneCard phoneCard);

}

流量服務介面

public interface ServerNtework {
    // 流量數量，手機卡物件
    public abstract void server(int networkData, PhoneCard phoneCard);
}

測試類

public class it_test_3 {
    public static void main(String[] args) {
        System.out.println("========註冊卡=========");
        // 定義通話套餐數量與資費
        PhonePackage call = new PhonePackage(1, 0, 0);
        // 定義上網套餐與資費
        NetworkPackage network = new NetworkPackage(1, 0);
        // 消費統計物件
        UserConsume consume = new UserConsume();
        // 註冊一張手機卡  型別：大卡
        PhoneCard card = new PhoneCard(Type_enum.BIG.getCardType(), "110120130150",
                "username", "******", 1000, call.getPhonePackage(), network.getPhonePackage(), consume);
        // 多型：列印套餐資訊：抽象套餐類->通話套餐、上網套餐
        card.showOnCreate(call, network);
        System.out.println("=================\n\n");
        // 開始消費
        System.out.println("========使用通話=========");
        call.server(30, card);
        System.out.println("\n=================\n\n");

        System.out.println("========使用流量=========");
        network.server(100, card);
        System.out.println("\n=================\n\n");


    }

}

這次作業拖時間挺長的，國慶節，和學校實習，哎痛疼。加油吧少年~~~~~~~~~~