南昌大学JAVA期末大作业.docx

南昌大学JAVA期末大作业.docx

《南昌大学JAVA期末大作业.docx》由会员分享，可在线阅读，更多相关《南昌大学JAVA期末大作业.docx（79页珍藏版）》请在冰点文库上搜索。

南昌大学JAVA期末大作业

南昌大学实验报告

学生姓名：

学号：

专业班级：

实训类型：

□验证□综合□设计□创新实验日期：

2018.1.3实验成绩：

一、实验项目名称

2017~2018-1《java语言程序设计实验》期末大作业

二、实验的评分标准

实验分为A～F，A为最高，F最低。

F：

在规定时间内没有完成所有的实验，而且没有及时提交实验报告，或者实验过程中出现了抄袭复制他人实验代码。

D：

能完成实验，但是实验结果出现严重错误，不能体现对教学内容的理解。

C：

能基本完成实验，实验结果基本正确。

但是实验内容有较少的错误，提交的实验代码质量一般。

B：

能较好的完成实验，实验报告条理清楚，实验代码结构清晰，代码质量较高，及时更正试验中出现的错误，并对运行中一些异常错误进行分析，解释错误产生的原因。

A：

能较好的完成实验，实验代码质量高，实验报告完成度高，能在实验完成的基础上，根据个人的理解增加实验的新功能，具有一定的创新能力。

三、实验内容

1.8皇后问题（支持手动设置，判断位置，生成解决方案，n皇后扩展，图形界面）

当用户没有进行皇后数量设定时，默认为8

当用户输入皇后数量太大时，将自动纠正为正确范围，因为本程序提供了n皇后所有的解法，对于太大的n，将影响计算速度。

当在棋盘上点击，添加完N个皇后之后，棋盘会自动锁定，相应的事件被取消，单击Check按钮进行解法的检测，会有相应的弹出框提示解法的正确与否。

单击Reset，进行清盘，可以重新进行皇后的添加。

右上方有两种模式进行选择，PlayMode是玩家自己添加皇后，SoluMode是程序给出解决办法的模式。

单击Last和Next进行解法的查看。

因为程序中存储了所有的解法，这里的底层棋盘采用boolean类型，解法采用了byte类型的数组，进行减少空间的占用

退出游戏的一个提醒。

因为程序代码太多，这里给出它的一个源代码结构图（MVC模式）：

2.轻量级成绩管理系统（采用文件存储数据，支持成绩录入，成绩查询，三种排序下的成绩显示方式）

在右边选择不同的功能，主界面会跳转到相应的功能页面。

只有当查询功能被选中时，下面提供的三种排序选择方式才会显示可用。

简单的录入界面，将信息输入后，单击Submit，后台将记录存入文件。

单击Next进行下一条记录的输入。

输入完成后，单击Quit，返回主界面

单击成绩查询，刚才被锁定的三个排序选项可以使用了，点击不同的排序方式，中心文本域将出现不同排序方式的内容。

这里给出程序的源代码结构图（MVC模式）：

3.储蓄管理系统（面向用户！

支持开户，存取款功能，查询记录）

主界面提供不同的功能，同样的，单击不同的功能，主界面会进行跳转，然后到相应的界面完成功能即可。

开户：

正确填写信息后，单击提交。

开户成功，客户文件中会增加一条记录，同时有弹窗提醒。

这里给账户中设置一个默认金额1元。

存款界面：

正确填写信息，经办人签名，然后单击Comfirm，进行存款业务的提交。

存款成功后弹窗消息提醒。

取款操作时，会有一个检测的步骤，当取款金额大于了账户拥有的金额，会提示金额非法，不给予取款。

取款成功后也会有相应提醒。

同时在交易文件中会写入一条记录。

进行账户查询时，首先要求用户登录

因为系统面向用户，所以合法用户才能查看自己的交易记录和账户信息。

没有提供查看所有账户信息的接口，但是所有记录是存放在一起的！

如果用户不存在，或者密码输入错误，会禁止进入查询页面，同时弹窗提醒。

当身份信息验证合格后，跳转到信息界面，展示了该用户的所有信息。

其中：

上半部分信息来自客户文件。

下半部分信息来自交易记录文件内容的筛选。

这里是编号为0的一个测试账户，没有进行任何操作，所以记录为空。

这里给出源代码的结构图（MVC模式）：

4、实验小结

5、实验源代码

1.八皇后问题

packageone.model;

importjava.util.ArrayList;

publicclassEightQueenModel{

publicstaticintN=8;

privateboolean[][]arr;

privateArrayListsolutionList;

privateintpointer;

privatestaticEightQueenModeleightQueenModel=null;

publicstaticEightQueenModelgetInstance（）{

if（eightQueenModel==null）

eightQueenModel=newEightQueenModel（）;

returneightQueenModel;

}

publicstaticvoidsetN（intn）{

N=n;

}

privateEightQueenModel（）{

arr=newboolean[N][N];

solutionList=newArrayList<>（）;

pointer=0;

}

publicArrayListgetSolutionList（）{

returnsolutionList;

}

publicintgetPointer（）{

returnpointer;

}

publicvoidaddPointer（）{

pointer=（pointer+1）%solutionList.size（）;

}

publicvoidsubPointer（）{

pointer=（pointer-1+solutionList.size（））%solutionList.size（）;

}

publicbooleanaddQueen（inti,intj）{

if（i

arr[i][j]）{

arr[i][j]=true;

returntrue;

}

else

returnfalse;

}

publicbooleanisValid（intk,intj）{

for（inti=0;i

if（arr[i][j]）//conflictwithrow

returnfalse;

}

for（inti=k-1,m=j-1;i>=0&&m>=0;i--,m--）{

if（arr[i][m]）//left-up

returnfalse;

}

for（inti=k-1,m=j+1;i>=0&&m<=N-1;i--,m++）{

if（arr[i][m]）//right-up

returnfalse;

}

returntrue;

}

publicvoidfindSolution（inti）{

if（i==N）{

byte[]solution=newbyte[N];

for（byteq=0;q

for（bytet=0;t

if（arr[q][t]）{

solution[q]=t;

break;

}

}

}

solutionList.add（solution）;

return;

}

for（intm=0;m

if（isValid（i,m））{

arr[i][m]=true;

findSolution（i+1）;

arr[i][m]=false;//valueoflastlevel

}

}

}

publicvoidclear（）{

arr=newboolean[N][N];

pointer=0;

}

}

packageone.model;

importjavafx.scene.image.Image;

publicclassQueen{

privateintx;

privateinty;

privateImageimage;

publicQueen（intx,inty）{

this.x=x;

this.y=y;

this.image=newImage（"one/picture/blackQueen.png"）;

}

publicintgetX（）{

returnx;

}

publicintgetY（）{

returny;

}

publicImagegetImage（）{

returnimage;

}

}

packageone.model;

importjava.util.ArrayList;

publicclassQueenList{

privateArrayListlist;

privatestaticQueenListqueenList=null;

publicstaticQueenListgetInstance（）{

if（queenList==null）

queenList=newQueenList（）;

returnqueenList;

}

privateQueenList（）{

list=newArrayList<>（）;

}

publicvoidadd（Queenq）{

list.add（q）;

}

publicvoidclear（）{

list.clear（）;

}

publicintsize（）{

returnlist.size（）;

}

publicQueenget（inti）{

returnlist.get（i）;

}

}

packageone.view;

importjavafx.scene.canvas.Canvas;

importjavafx.scene.canvas.GraphicsContext;

importjavafx.scene.paint.Paint;

importone.model.EightQueenModel;

publicclassChessBoard{

publicstaticfinalintSIZE=66;

publicstaticfinalintPSIZE=52;

privateCanvascanvas;

privateGraphicsContextgc;

privatestaticChessBoardchessBoard=null;

publicstaticChessBoardgetInstance（）{

if（chessBoard==null）

chessBoard=newChessBoard（）;

returnchessBoard;

}

privateChessBoard（）{

canvas=newCanvas（SIZE*EightQueenModel.N,SIZE*EightQueenModel.N）;

gc=canvas.getGraphicsContext2D（）;

drawBoard（）;

}

publicvoidupdateChessBoard（）{

gc.clearRect（0,0,SIZE*EightQueenModel.N,SIZE*EightQueenModel.N）;

canvas.setHeight（SIZE*EightQueenModel.N）;

canvas.setWidth（SIZE*EightQueenModel.N）;

}

publicGraphicsContextgetGc（）{

returngc;

}

publicCanvasgetCanvas（）{

returncanvas;

}

publicvoiddrawBoard（）{

for（inti=0;i

for（intj=0;j

Stringcolor=（i+j）%2==0?

"white":

"dimgray";

gc.setFill（Paint.valueOf（color））;

gc.fillRect（i*SIZE,j*SIZE,SIZE,SIZE）;

}

}

}

}

packageone.view;

importjavafx.geometry.Insets;

importjavafx.geometry.Pos;

importjavafx.scene.control.Button;

importjavafx.scene.control.RadioButton;

importjavafx.scene.control.TextField;

importjavafx.scene.control.ToggleGroup;

importjavafx.scene.layout.VBox;

importjavafx.scene.text.Font;

publicclassConsoleView{

privateTextFieldtextField;

privateButtonset;

privateRadioButton[]modeSelection;

privateToggleGrouptgroup;

privateButton[]function;

privateVBoxconsole;

privateFontfont;

privatestaticConsoleViewconsoleView=null;

publicstaticConsoleViewgetInstance（）{

if（consoleView==null）

consoleView=newConsoleView（）;

returnconsoleView;

}

privateConsoleView（）{

font=Font.font（20）;

tgroup=newToggleGroup（）;

textField=newTextField（）;

textField.setPrefSize（120,40）;

textField.setFont（font）;

set=newButton（"SetN"）;

set.setPrefSize（100,28）;

set.setFont（font）;

modeSelection=newRadioButton[2];

for（inti=0;i<2;++i）{

modeSelection[i]=newRadioButton（）;

modeSelection[i].setFont（font）;

modeSelection[i].setToggleGroup（tgroup）;

}

function=newButton[5];

for（inti=0;i<5;i++）{

function[i]=newButton（）;

function[i].setFont（font）;

function[i].setPrefSize（100,28）;

}

function[3].setDisable（true）;

function[2].setDisable（true）;

console=newVBox（20）;

setModule（）;

loadModule（）;

}

publicButtongetSet（）{

returnset;

}

publicTextFieldgetTextField（）{

returntextField;

}

publicRadioButtongetMode（inti）{

returnmodeSelection[i];

}

publicButtongetFunction（inti）{

returnfunction[i];

}

publicVBoxgetConsole（）{

returnconsole;

}

privatevoidsetModule（）{

textField.setPromptText（"8~13"）;

modeSelection[0].setText（"PlayMode"）;

modeSelection[0].setSelected（true）;

modeSelection[1].setText（"SoluMode"）;

modeSelection[1].setSelected（false）;

function[0].setText（"Check"）;

function[1].setText（"Reset"）;

function[2].setText（"Last"）;

function[3].setText（"Next"）;

function[4].setText（"Quit"）;

}

privatevoidloadModule（）{

console.getChildren（）.addAll（modeSelection）;

console.getChildren（）.addAll（textField,set）;

console.getChildren（）.addAll（function）;

VBox.setMargin（textField,newInsets（20,0,0,0））;

VBox.setMargin（function[0],newInsets（20,0,0,0））;

console.setAlignment（Pos.CENTER）;

}

}

packageone.view;

importjavafx.application.Application;

importjavafx.geometry.Insets;

importjavafx.scene.Scene;

importjavafx.scene.layout.BorderPane;

importjavafx.stage.Stage;

importone.control.ChessBoardControl;

importone.control.ConsoleControl;

publicclassMainFrameextendsApplication{

publicvoidstart（Stagestage）{

BorderPaneborderPane=newBorderPane（）;

//getcomponents

ChessBoardboard=ChessBoard.getInstance（）;

ConsoleViewconsoleView=ConsoleView.getInstance（）;

//putcomponentsintorightplace

borderPane.setCenter（board.getCanvas（））;

borderPane.setRight（consoleView.getConsole（））;

//setmargin

BorderPane.setMargin（consoleView.getConsole（）,newInsets（0,20,0,20））;

//addalltheevents

ChessBoardControl.addChessBoardEvents（）;

ConsoleControl.addConsoleEvents（）;

//run

Scenescene=newScene（borderPane）;

stage.setScene（scene）;

stage.show（）;

}

}

packageone.control;

importjavafx.scene.image.Image;

importone.model.EightQueenModel;

importone.model.Queen;

importone.model.QueenList;

importone.view.ChessBoard;

publicclassChessBoardControl{

privatestaticChessBoardchessBoard=ChessBoard.getInstance（）;

privatestaticEightQueenModeleightQueenModel=EightQueenModel.getInstance（）;

privatestaticQueenListqlist=QueenList.getInstance（）;

privatestaticintnumOfQueen=0;

privateChessBoardControl（）{}

publicstaticvoidaddChessBoardEvents（）{

addQueenEvent（）;

}

publicstaticvoidaddQueenEvent（）{

chessBoard.getCanvas（）.setOnMouseClicked（event->{

if（numOfQueen

doubletempX=event.getX（）;

doubletempY=event.getY（）;

intx=（int）（tempX/ChessBoard.SIZE）;

inty=（int）（tempY/ChessBoard.SIZE）;

//positionisvalid

if（eightQueenModel.addQueen（x,y））{

Queenqueen=newQueen（x,y）;

qlist.add（queen）;

drawQueen（queen）;

numOfQueen++;//makesureonly8queensareavailable

}

}

}）;

}

publ