Java实验报告Word文档下载推荐.docx
《Java实验报告Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《Java实验报告Word文档下载推荐.docx（12页珍藏版）》请在冰豆网上搜索。
{
intx,y;
Point2D（intx,inty）{this.x=x;
this.y=y;
}
voidoffset（inta,intb）{this.x+=a;
this.y+=b;
voidprint（）{System.out.printf（"
Point2D:
（%d,%d）\n"
x,y）;
classPoint3DextendsPoint2D
intz;
Point3D（intx,inty,intz）{super（x,y）;
this.z=z;
voidoffset（inta,intb,intc）{this.x+=a;
this.z+=c;
Point3D:
（%d,%d,%d）\n"
x,y,z）;
publicclassMain{
staticdoubledistance（Point2Da,Point2Db）{
returnjava.lang.Math.sqrt（（（a.x-b.x）*（a.x-b.x）+（a.y-b.y）*（a.y-b.y）））;
}
staticdoubledistance（Point3Da,Point3Db）{
returnjava.lang.Math.sqrt
（（（a.x-b.x）*（a.x-b.x）+（a.y-b.y）*（a.y-b.y）+（a.z-b.z）*（a.z-b.z）））;
publicstaticvoidmain（Stringargs[]）
{
Point2Dp2d1=newPoint2D（1,1）,p2d2=newPoint2D（2,2）;
Point3Dp3d1=newPoint3D（1,1,1）,p3d2=newPoint3D（2,2,2）;
System.out.printf（"
%f%f\n"
distance（p2d1,p2d2）,distance（p3d1,p3d2））;
intT=10;
Point2Darr[]=newPoint2D[T];
for（inti=0;
i<
T;
i++）{
inttype=（int）（java.lang.Math.random（）*2）;
intx=（int）（java.lang.Math.random（）*100）,
y=（int）（java.lang.Math.random（）*100）,
z=（int）（java.lang.Math.random（）*100）;
if（type==0）arr[i]=newPoint2D（x,y）;
elsearr[i]=newPoint3D（x,y,z）;
}
i++）{arr[i].print（）;
四、思考题
1．你对面向对象的理解。
答：
面向对象最重要的三大特性：
封装、继承、多态。
围绕这三个核心特性，
面向对象程序设计方法给软件工程带来的全新的程序结构设计模式。
面向对象和核心概念就是理解【类】、和【对象】。
具体来讲，首先我对【类】一词的理解如下：
类就是一组有共性的对象。
它描述一个特定的抽象并提供创建对象的模板，如果类不具备某中特性，那么它的对象也不能具备该特性。
类就是分类，比如人类，就是关于人的定义，包括一些属性和操作这些属性的动作，是对一个实体的抽象的描述。
因为是一个抽象概念，在使用的时候必须进行实例化，即将类具体为一个具体的实体。
由类牵扯出【对象】的理解：
对象，是一个类的具体实现，比如某人Jack，就是拥有一个名字属性为Jack的人类，他可以有其他的属性，具有人类里的所有方法（可以简单的理解为行为和操作属性的）。
对象需要有状态，用以描述对象的特征和当前的状态。
对象还需要有行为，定义其他对象对该对象所施加的动作。
行为可能需要依赖于对象的状态。
在某种情况下，对象可以有某种行为，而在另外一些情况下，则不能。
每一个对象都必须被唯一的标识（对象的名字不能相同，至少在一个场景中）。
对象通过协作，通信来完成一个比较完整的分工，这些分工整合起来，就是整个软件系统。
2.什么是多态？
Java中如何实现多态？
【概念理解】
多态就是说，比较低层次的抽象的实体可以被支持比较高层次抽象的一些操作的实体所支持。
实现这些概念需要的工具，或者说描述方式，关于多态的描述有一个比较传统的例子：
一个比较高层次的抽象，称为形状，然后从形状继承而来的有圆，长方形（也可以有由长方形继承而来正方形），三角形等低层次抽象，有这样一个外部实体，它支持对形状的操作，比如计算形状的面积（不用考虑怎么计算，也不用考虑计算的形状是那种），由于它支持的是形状（比较高层次的抽象），那么不论是圆，长方形，三角形它就都支持。
而具体到每个低层次的抽象的实际计算时，各自使用各自的计算方法，最终返回结果就可以了。
这样做的一个明显的好处是，如果以后发现新的比较低层次的抽象后，直接加入系统即可，无需考虑上层使用者的修改。
在运行时，编译器会知道需要计算哪个。
【Java实现机制】
Java中实现多态的机制靠的是父类或者接口定义的引用变量可以指向子类或者具体的实现类的实例对象，而程序调的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
实验二货物进销管理系统
1．掌握Java中文件的读写操作。
2．学会使用Java提供的实用类（Vector,ArrayList）来完成特定的功能。
3．掌握字符串类（String,StringBuffer）的使用。
4．掌握用面向对象的方法分析和解决复杂问题。
编写一个Inventory.java完成以下功能（没有学过Java文件处理之前，各位同学可以使用硬编码将数据放进两个Vector变量里。
等学过Java文件处理之后，再补充数据文件读取部分）：
1．程序首先打开并读取Inventory.dat中记录的所有库存记录，然后读取Transactions.dat，处理这个文件中包含的事务，记录发货记录到Shipping.dat，并记录错误信息到Errors.dat中。
最后更新库存到另外一个文件NewInventory.dat中。
2．文件Inventory.dat和NewInventory.dat的每行包含一个存货记录，没条记录包含下面一些字段息，这些字段之间用一个tab分开（见后面的文件格式）：
字段
格式和含义
Itemnumber
字符串型，货物编号
Quantity
整型，货物数量
Supplier
字符串型，供应商编号
Description
货物描述
3．字段Items按照从小到大的顺序写如文件的。
注意Item号不必连续，如Item号为752的后面可能是800。
4．文件Transactions.dat包含几个不同的事务处理记录（每行一条记录）。
每条记录前面以一个大写字母开头，表示这条记录是什么类型的事务。
在不同的大写字母后面是不同的信息格式。
所有的字段也是以tab键分开的（见Transactions.dat文件格式）。
5．以'
O'
开头的事务表示这是一个发货，即某一种货物应该发给特定的客户。
Item号和数量Quantity的格式如上面表格定义。
Custom编号和上面的Supplier编号一致。
处理一条定单记录（以'
开头的事务）意味着从减少库存记录中相应货物的数量（减少的数量=发货单中的数量），记录发货信息到Shipping.dat中。
注意：
Inventory.dat中的quantity不应该小于0，如果对于某一种货物，库存的数量小于发货单的数量的话，系统应该停止处理发货单，并记录出错信息到Errors.dat。
如果对于某一种货物有多个发货单，而且库存总量小于这些发货单的总和的话，系统应该按照发货单中的数量从小到大的有限原则满足客户。
也就是说，对于某一种货物如果一个数量Quantity少的发货单没有处理之前，数量Quantity多的发货单永远不会被处理。
（这种处理原则不受发货单记录在Transactions.dat的先后顺序影响）
6．以'
R'
开头的事务表示这是一个到货单记录，在'
后面是Item号和它的数量。
处理一条到货单意味着增加库存中相应货物的数量（增加的数量=到货单中的数量）。
注意如果在Transactions.dat文件中，到货单出现在发货单之后，到货单中的货物数量可以用来填补发货单中的数量（可以理解成在Transactions.dat中，优先处理到货单）。
7．以'
A'
开头的事务表示向库存中增加一种新的货物（即这种货物以前库存中没有），在'
后面是Item号，供应商supplier以及货物的描述description。
处理一个新增货物记录意味着向库存中增加一个数量Quantity为0的新的Item。
你可以假设在一个Transactions.dat中，新增货物记录总是出现在第一个到货单之前。
8．以'
D'
开头的事务表示从库存中删除一种货物，在'
后面是Item号。
删除操作总是在所有的事物处理之后才被处理，以保证对于可能出现的同一种货物的发货单的操作能在删除之前被正确处理。
如果要删除的某种货物的库存量Quantity不为0的话，系统应该向Errors.dat记录出错信息。
9．文件Shipping.dat中的每一行代表给某一客户的发货信息。
Shipping.dat中的每一行分别是客户编号、Item号、货物数量，它们之间用tab键分隔。
如果发货单中有两条客户编号和Item编号一样的记录，在Shipping.dat中应该将这两条发货信息合并（即将它们的数量相加）。
10．Errors.dat文件包含未发送的发货记录和库存量大于0的删除记录。
Errors.dat每一行包含Custom编号、Item编号以及发货单上的数量Quantity。
对于删除操作，Custom编号为0，数量Quntity为库存中的Quantity.
11．实验测试数据:
classItem
Stringnumber,supplier,description;
intquantity;
Item（Stringnumber,intquantity,Stringsupplier,Stringdescription）{
this.number=number;
this.quantity=quantity;
this.supplier=supplier;
this.description=description;
classTransCompareimplementsComparator
publicintcompare（Objecto1,Objecto2）{
Iteme1=（Item）o1;
Iteme2=（Item）o2;
if（e1.quantity>
e2.quantity）return1;
elseif（e1.quantity<
e2.quantity）return-1;
elsereturn0;
publicstaticvoidmain（Stringargs[]）throwsIOException{
FileReaderin=newFileReader（"
Inventory.txt"
）;
FileWriterout1=newFileWriter（"
Shipping.txt"
FileWriterout2=newFileWriter（"
Errors.txt"
BufferedWritershipping=newBufferedWriter（out1）;
BufferedWritererrors=newBufferedWriter（out2）;
Scannerscan=newScanner（in）;
Stringnumber=null,supplier,description;
intquantity;
Map<
String,Item>
map=newHashMap<
（）;
transHash=newHashMap<
Vector<
Item>
trans=newVector<
（）,del=newVector<
（）,
rec=newVector<
（）,add=newVector<
//记录生成
while（scan.hasNext（））
{
number=scan.next（）;
quantity=scan.nextInt（）;
supplier=scan.next（）;
description=scan.next（）;
map.put（number,newItem（number,quantity,supplier,description））;
Stringtype;
in=newFileReader（"
Transactions.txt"
scan=newScanner（in）;
//数据读入-离线存储
while（scan.hasNext（））{
type=scan.next（）;
if（type.equals（"
0"
））{
number=scan.next（）;
quantity=scan.nextInt（）;
supplier=scan.next（）;
StringhashText=number+"
###"
+supplier;
if（!
transHash.containsKey（hashText））{//Hash发货单
transHash.put
（hashText,newItem（number,quantity,supplier,"
None"
））;
}
elsetransHash.get（hashText）.quantity+=quantity;
}elseif（type.equals（"
R"
rec.add（newItem（number,quantity,"
"
D"
del.add（newItem（number,-1,"
"
A"
description=scan.next（）;
add.add（newItem（number,0,supplier,description））;
}
//
for（Map.Entry<
entry:
transHash.entrySet（））
trans.add（newItem（entry.getValue（）.number,entry.getValue（）.quantity,entry.getValue（）.supplier,"
//合并发货单写入
shipping.write（entry.getValue（）.number+"
"
shipping.write（String.valueOf（entry.getValue（）.quantity）+"
shipping.write（entry.getValue（）.supplier）;
shipping.newLine（）;
Collections.sort（trans,newTransCompare（））;
//按发货数量升序排序
add.size（）;
i++）//添加
Itemitem=add.get（i）;
map.put（item.number,item）;
System.out.printf
（"
添加存种：
%s供应商：
%s描述:
%s\n"
item.number,item.supplier,item.description）;
rec.size（）;
i++）//收货
Itemitem=rec.get（i）,ret=map.get（item.number）;
ret.quantity+=item.quantity;
map.put（ret.number,ret）;
收货：
%s数量：
%d剩余：
%d\n"
item.number,item.quantity,ret.quantity）;
trans.size（）;
i++）//发货
Itemitem=trans.get（i）,ret=map.get（item.number）;
if（ret.quantity<
item.quantity）{
System.out.printf（"
发货%s给%s失败，剩余：
%d需求：
item.number,item.supplier,ret.quantity,item.quantity）;
errors.write（item.supplier+"
errors.write（item.number+"
errors.write（String.valueOf（（item.quantity）））;
errors.newLine（）;
continue;
ret.quantity-=item.quantity;
map.put（item.number,ret）;
System.out.printf（"
发货%s给%s成功，剩余：
del.size（）;
i++）//删除
Itemitem=del.get（i）,ret=map.get（item.number）;
if（ret==null）continue;
//去除无效
if（ret.quantity!
=0）{
System.out.printf
删除%s失败，数量剩余：
item.number,ret.quantity）;
errors.write（"
0"
errors.write（String.valueOf（（ret.quantity）））;
删除%s成功，\n"
item.number）;
map.remove（item.number）;
shipping.flush（）;
errors.flush（）;
四、实验结果
五、思考题
1.对整个实验进行总结，写出实验心得。
【摘要】
该实验本质就是一个模拟题。
要求模拟一个进货发货系统。
注意关键点：
数据不能在线处理。
体现在两个方面：
①读入操作顺序与实际工作顺序不符
②读入操作需要Hash与合并
因此，只能采取离线保存+处理的手段。
由于数据主键并非整型值，如果是用数组来保存，需要手写一个Hash表来Hash。
考虑到基于红黑树实现的关联Map容器，所以使用Map来Hash和模拟数据库。
【数据结构设计】
Map<
map——作为
升级会员 