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

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

編程實作以下需求：

定義一個長度為[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();//對角線的和




    }
}

編程實作控制臺版并支持兩人對戰的五子棋游戲，

（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.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");


    }

}

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/163369.html

標籤：其他

上一篇：2020藍橋杯B 組省賽計蒜客模擬賽（一）題解

下一篇：Voting Judges(AtCoder agc041_B)