第二个题还是有点难的整了一天还是没整出来，最后还是参考别人的
编程实现以下需求：
定义一个长度为[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
for(intj=0;j
System.out.print(" "+arrs[i][j]);
}
System.out.println();
}
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134
测试类
package code_1;
publicclassit_test_1{
publicstaticvoidmain(String[] args){
arrarray=newarr(16,16);
array.add();//添加元素
array.show();
array.getSumRows();//行的和
array.getSumCols();//列的和
array.getSumDiagonal();//对角线的和
}
}
12345678910111213141516
编程实现控制台版并支持两人对战的五子棋游戏。
（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; } } }}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
测试类
/**
* 2. 编程实现控制台版并支持两人对战的五子棋游戏。
（1）绘制棋盘 - 写一个成员方法实现
（2）提示黑方和白方分别下棋并重新绘制棋盘 - 写一个成员方法实现。
（3）每当一方下棋后判断是否获胜 - 写一个成员方法实现。
*/
publicclassit_test_2{
publicstaticvoidmain(String[] args){
charblack_mole=0x2665;
charwhite_mole=0x2022;
gobang go=newgobang(black_mole,white_mole,17,17);
go.getCheckerboard(); go.showcheckerboard(); go.startGame(); }}123456789101112131415161718192021222324
按照要求设计并实现以下实体类和接口。3.1 第一步：设计和实现以下类（1）手机卡类 特征：卡类型、卡号、用户名、密码、账户余额、通话时长(分钟)、上网流量 行为：显示（卡号 + 用户名 + 当前余额）（2）通话套餐类 特征：通话时长、短信条数、每月资费 行为: 显示所有套餐信息 （3）上网套餐类 特征：上网流量、每月资费 行为：显示所有套餐信息（4）用户消费信息类 特征：统计通话时长、统计上网流量、每月消费金额3.2 第二步：设计和实现以下枚举类 手机卡的类型总共有 3 种：大卡、小卡、微型卡3.3 第三步：实体类的优化 将通话套餐类和上网套餐类中相同的特征和行为提取出来组成抽象套餐类。3.4 第四步：创建并实现以下接口（1）通话服务接口 抽象方法: 参数1: 通话分钟, 参数2: 手机卡类对象 让通话套餐类实现通话服务接口。（2）上网服务接口 抽象方法: 参数1: 上网流量, 参数2: 手机卡类对象 让上网套餐类实现上网服务接口。
3.5 第五步：进行代码测试
编写测试类使用多态格式分别调用上述方法，方法体中打印一句话进行功能模拟即可。
消费类
public class UserConsume {
//统计余额、通话时长、上网流量
privateintconsumeValue;
privateintconsumeCallDuration;
privateintconsumeNetworkData;
public void setConsumeValue(intconsumeValue) {
this.consumeValue = consumeValue; } public void setConsumeCallDuration(intconsumeCallDuration) {
this.consumeCallDuration = consumeCallDuration; } public void setConsumeNetworkData(intconsumeNetworkData) {
this.consumeNetworkData = consumeNetworkData; } publicintgetConsumeValue() {
returnconsumeValue;
} publicintgetConsumeCallDuration() {
returnconsumeCallDuration;
} publicintgetConsumeNetworkData() {
returnconsumeNetworkData;
} // 打印消费情况 public void showInfo() { System.out.printf("\n消费情况：您已通话 "+consumeCallDuration+"分钟；流量使用"+consumeNetworkData+"GB;合计消费"+consumeValue+"元。");
}}123456789101112131415161718192021222324252627282930313233343536
手机卡类
publicclassPhoneCard{
privateString cardType;
privateString cardId;
privateString userName;
privateString password;
privateintaccountBalance;
privateintcallDuration;
privateintnetworkData;
privateUserConsume userConsume;
publicPhoneCard(){
}publicPhoneCard(String cardType, String cardId, String userName, String password,intaccountBalance,
intcallDuration,intnetworkData, UserConsume userConsume){
setCardType(cardType); setCardId(cardId); setUserName(userName); setPassword(password); setAccountBalance(accountBalance); setCallDuration(callDuration); setNetworkData(networkData); setUserConsume(userConsume); }publicUserConsumegetUserConsume(){
returnuserConsume;
}publicvoidsetUserConsume(UserConsume userConsume){
this.userConsume = userConsume;
}publicStringgetCardType(){
returncardType;
}publicvoidsetCardType(String cardType){
this.cardType = cardType;
}publicStringgetCardId(){
returncardId;
}publicvoidsetCardId(String cardId){
this.cardId = cardId;
}publicStringgetUserName(){
returnuserName;
}publicvoidsetUserName(String userName){
this.userName = userName;
}publicStringgetPassword(){
returnpassword;
}publicvoidsetPassword(String password){
this.password = password;
}publicintgetAccountBalance(){
returnaccountBalance;
}publicvoidsetAccountBalance(intaccountBalance){
this.accountBalance = accountBalance;
}publicintgetCallDuration(){
returncallDuration;
}publicvoidsetCallDuration(intcallDuration){
this.callDuration = callDuration;
}publicintgetNetworkData(){
returnnetworkData;
}publicvoidsetNetworkData(intnetworkData){
this.networkData = networkData;
}/**
* 增加消费方法
*
*@paramconsumeValue 消费金额
*@paramconsumeCallDuration 通话时长
*@paramconsumeNetworkData 上网流量
*/
publicvoidaddComsume(intconsumeValue,intconsumeCallDuration,intconsumeNetworkData){
// 记录消费金额
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();
}
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134
通话套餐类
public class PhonePackage extends AbstractPackage implements ServeCall {
//记录短信条数
privateintmessage;
//初始化通话套餐
public PhonePackage(intprice,intphonePackage,intmessage) {
//继承抽象套餐类
super(price,phonePackage);//设置短信
setMessage(message); } public void setMessage(finalintmessage) {
this.message = message; } publicintgetMessage() {
returnmessage;
} // 重写抽象套餐类，打印套餐信息； @Override public void showInfo() { System.out.printf("通话套餐：时长包"+getPhonePackage()+"分钟;每月资费"+getPrice()+"元/分钟;短信"+getMessage()+"条");
} @Override // 重写通话服务接口方法 public void server(intnumber, PhoneCard phoneCard) {
//消费金额=通话数量*资费
intconsumeValue=number*getPrice();
//手机余额减消费
phoneCard.setAccountBalance(phoneCard.getAccountBalance() - consumeValue);//添加通话消费时长
phoneCard.addComsume(consumeValue,number,0);
//打印手机卡当前消费信息
phoneCard.showInfo(); }}1234567891011121314151617181920212223242526272829303132333435363738394041
抽象类
public abstract class AbstractPackage {
//套餐资费
privateintprice;
//套餐数量
privateintphonePackage;
//无参构造
public AbstractPackage() { } // 初始化套餐 public AbstractPackage(intprice,intphonePackage) {
setPrice(price); setPhonePackage(phonePackage); } // 设置资费 public void setPrice(intprice) {
this.price = price; } // 获取资费 publicintgetPrice() {
returnprice;
} // 设置套餐数量 public void setPhonePackage(intphonePackage) {
this.phonePackage = phonePackage; } // 获取套餐 publicintgetPhonePackage() {
returnphonePackage;
} // 打印套餐信息 public abstract void showInfo();}1234567891011121314151617181920212223242526272829303132333435363738394041
上网套餐类
publicclassNetworkPackageextendsAbstractPackageimplementsServerNtework{
publicNetworkPackage(intprice,intphonePackage){
// 继承抽象类套餐
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();
}
}
1234567891011121314151617181920212223242526272829
卡型枚举类
publicenumType_enum {
BIG("大卡"), SMALL("小卡"), MINI("微型卡");
privatefinalString cardType;
privateType_enum(String cardType){
this.cardType = cardType;
}publicStringgetCardType(){
returncardType;
}}12345678910111213141516
*** 通话服务接口：**
publicinterfaceServeCall{
// 通话数量，手机卡对象
public abstract void server(int number, PhoneCard phoneCard);
}
12345
流量服务接口
publicinterfaceServerNtework{
// 流量数量，手机卡对象
public abstract void server(int networkData, PhoneCard phoneCard);
}
1234
测试类
publicclassit_test_3{
publicstaticvoidmain(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");
}
}
网友评论