科学实验报告册

第一篇：科学实验报告册

实验名称：蜡烛的变化

实验材料：蜡烛、火柴、干玻璃片、试管夹 实验步骤：

1、检验试验用品是否齐全。

2、点燃蜡烛，观察现象。

3、试管夹夹住干玻璃片，放在火焰上方，观察现象。

4、整理器材。

实验现象：蜡烛开始燃烧，火焰下方蜡烛由固态变成液态，玻璃片上变黑。实验结论：蜡烛燃烧，一是形态发生了变化，二是生成新的物质——烟。

实验名称：探究水泥的变化

实验材料：火柴、杯子、盘子、酒精灯、玻璃棒、石棉网、水泥、铁架台、坩埚 实验步骤：

1、检查实验用品是否齐全。

2、将水泥倒入盘中，往盘中的水泥加水，观察水泥变化。

3、将水泥块放入坩埚。

4、点燃酒精灯，给水泥块加热，观察现象。

5、整理器材。

实验现象：

1、往盘中的水泥加水，过了一会，水泥凝固了。

2、点燃酒精灯，给水泥块加热，水泥块没有变化。实验结论：水泥不能恢复原状。

实验名称：食盐的变化

实验材料：火柴、杯子、盘子、酒精灯、玻璃棒、石棉网、食盐、铁架台、坩埚 实验步骤：

1、检验试验用品是否齐全。

2、向杯中倒入水，把食盐放入水中。

3、用玻璃棒搅拌，观察想象。

4、把食盐水放入坩埚，放在铁架台上。

5、点燃酒精灯，给食盐水加热，观察现象。

6、整理器材。

实验现象：把食盐放在水中，用玻璃棒搅拌，食盐在水中溶解了，看不到了。

点燃酒精灯，给食盐水进行加热，坩埚上可以清晰地看到已经析出的食盐颗粒。实验结论：通过给食盐水加热的方法可以使溶解的食盐恢复原状。

实验名称：铁生锈的条件

（一）实验材料：铁钉、砂纸、玻璃棒、碱、盐、油、醋 实验步骤：

1、检验试验用品是否齐全。

2、用砂纸打磨铁钉，去掉其表面覆盖物。

3、把铁钉放在瓶子里，放在一个地方，并编好号：

1、空气，2、装满水，3、半

瓶水，4、盐水，5、碱溶液、醋溶液......同时放入相同铁钉，相同时间后观察铁钉生锈情况。

4、整理器材

实验现象：水中，轻微生锈；一半水，一半空气，严重生锈；空气中，轻微生锈；

醋、碱、盐、水中，严重生锈；

油中无锈。

实验结论：铁在空气和水同时存在、有酸、碱、盐的情况下容易生锈。

实验名称：铁生锈的条件

（二）实验材料：三枚相同的铁钉、三个相同的试管、三个试管塞、干燥剂一小袋、水适量。实验步骤：

1、检验实验用品是否齐全。

2、把三枚铁钉分别放入三个试管中。

3、一个试管放少量水，浸没铁钉的一部分；另一个试管放满水，将铁钉完全浸没；一个试管放干燥剂。

4、最后分别用试管塞把三个试管塞紧。

5、整理器材。实验现象：放置几天后取出三枚铁钉观察，发现第一个试管中的铁钉在紧密接触水面的地方有铁锈，而其他两个铁钉无铁锈。

实验结论：潮湿的空气是铁生锈的重要条件。

实验名称：牛奶的变化

实验材料：烧杯、玻璃棒、醋、啤酒、食盐、柠檬汁、牛奶 实验步骤：

1、检验试验用品是否齐全。

2、将醋加入装有四分之一牛奶的烧杯中，搅拌，观察现象。

3、将啤酒加入装有四分之一牛奶的烧杯中，搅拌，观察现象。

4、将食盐加入装有四分之一牛奶的烧杯中，搅拌，观察现象。

5、将柠檬汁加入装有四分之一牛奶的烧杯中，搅拌，观察现象。

6、整理器材。

实验现象：牛奶中放醋，牛奶中出现混合物凝结现象。

牛奶中放入啤酒，牛奶变成絮状。

牛奶中加入食盐，牛奶没有变化。

牛奶中加入柠檬汁，牛奶中有沉淀生成。实验结论：现象同结论。

实验名称：测量速度 实验材料：米尺、秒表

实验步骤：

1、检查实验用品是否齐全。

2、用正常的步伐走5米、10米，测出你用了多长时间。

3、用正常的步伐走5秒、10秒，量出你走的路程。

4、比正常步伐走得慢一点，测出走5米、10米用的时间和走5秒、10秒的路程。

5、比正常步伐走得快一点，测出走5米、10米用的时间和走5秒、10秒的路程。

6、整理器材。

实验现象：用的时间长，路程长；时间短，路程就短。

实验结论：相同时间比较运动的距离，跑的距离远，说明运动的速度快，反之则运动的速度

慢；相同距离比较所用的时间，用的时间越少，说明速度越快，反之则运动的速度慢。

实验名称：惯性试验

实验材料：鱼缸一个、鸡蛋一个、光滑的薄木板一个、小锤一个 实验步骤：

1、检查实验用品是否齐全。

2、把鱼缸装入二分之一的水，盖上薄木板，然后把鸡蛋放在木板上面。

3、用小锤沿水平方向迅速敲击木板、看鸡蛋如何运动。

4、整理器材。实验现象：鸡蛋会掉入水中。

实验结论：鸡蛋没有随木板一起运动，而是保持了它原有的运动趋势，木板抽掉后，只好掉进鱼缸内，说明鸡蛋具有惯性。

实验名称：昼夜交替的模拟实验 实验材料：地球仪、手电筒、大头针 实验步骤：

1、检查实验用品是否齐全。

2、用手电筒的光代表太阳光把地球仪照亮。观察地球仪上是否分成了明暗两部分，思考哪边是白天，哪边是黑夜。

3、自西向东转动地球仪，观察是否出现昼夜交替现象，分别在什么位置是早上、正午和傍晚。

4、整理器材。

实验现象：

1、地球仪上分成了明暗两部分，向着“太阳”的那面是白天，背着“太阳”的那面是黑夜。

2、地球自西向东转动，同一个地方出现了昼夜交替现象。当这个地方转到刚被光照射到是早晨，正对“太阳”时是正午，转到刚被光照不到时是傍晚。

实验结论：地球是个球体，太阳只能照亮地球的一半，向着太阳的那面是白天，背着太阳的那面是黑夜。地球不停的自转，昼夜现象就会交替出现。

实验名称：四季更替的模拟实验 实验材料：地球仪、手电筒

实验步骤：

1、检查实验用品是否齐全。

2、在桌子上画一个圆，把地球仪放在画好的轨道上运动。

3、手电筒在中间始终照着地球仪。

4、地球仪在转动过程中倾斜角度要保持一致。

5、观察与思考：仔细观察，“太阳”的光芒分别直射在什么地方？这与四季的形成又有什么关系呢？

6、整理器材。

实验现象：地球仪上的南北半球接受手电光的照射程度不断变化。

实验结论：地球在绕太阳公转的过程中，地轴总是倾斜的，并且倾斜的方向保持不变。由于地轴的倾斜，当地球处在公转轨道不同位置时，南北半球接受太阳光的照射程度也不断的变化，从而形成了寒来暑往的四季。

实验名称：月相变化模拟实验 实验材料：电灯、皮球

实验步骤：

1、检查实验用品是否齐全。

2、在教室里准备一盏瓦数大的电灯，用这盏灯当作太阳，学生自己当作地球，用皮球当作月球。

3、把“月球”举在空中，使“阳光”照到“月球”上，观察此时“月球”的明亮部分是什么形状。

4、然后使“月球”围绕“地球”公转一周，观察“月球”的明亮部分有什么变化。

5、整理器材。

实验现象：当“月球”亮面转到背着“地球”的方向时，“月球”几乎全是黑的；当“月球”亮面转到向着“地球”的方向时，“月球”几乎全是光明的；当“月球”亮面由向着“地球”到背着“地球”时，“月球”的明亮部分逐渐减少。

实验结论：月球是一个不发光、不透明的球体，我们看到的月光是它反射太阳的光。月相实际上就是人们从地球上看到的月球被太阳照亮的部分。由于观察的角度不同，所以看到的月相亮面大小、方向也就不同。

实验名称：日食和月食的形成模拟实验 实验材料：电灯、圆形小镜子

实验步骤：

1、检查实验用品是否齐全。

2、在与你的眼睛同样高的墙壁上悬挂一盏电灯，用它当作太阳。手持一面圆形的小镜子当作月亮，与你电灯的视线大体相平。

3、面对电灯，闭上一只眼睛，调整“月亮”与眼睛的距离，使“月亮”能完全遮住“太阳”。这时就发生了日食。

4、保持原有姿势，沿逆时针方向原地转动，当你的头部（相当于地球）遮住射向“月亮”的光辉时，便发生了“月食”。

5、再重复几次实验，观察“日食”和“月食”时哪边先亏。

6、整理器材。实验现象：“日食”时总是太阳的西边先亏。“月食”时总是月亮的东边先亏。

实验结论：月球围绕地球转，地球围绕太阳转，当月球转到地球和太阳中间，三个天体大致呈一条直线的时候，月球的影子就会投在地球上，处在月影里的人由于被月球挡住了视线，就看不见太阳或只能看见一部分太阳，这就是日食。

实验名称：蚯蚓对干湿环境的反应

实验材料：蚯蚓5条、长方形纸盒、黑湿布、透明的塑料薄膜 实验步骤：

1、检查实验用品是否齐全。

2、找一个长方形纸盒把里面涂黑，把盒底挖掉一半，贴一块透明的塑料薄膜。

3、在桌上铺一块黑湿布，在布上放上5条蚯蚓，用盒罩住，使蚯蚓正好在盒内的明暗交界处，观察蚯蚓往哪爬，比较亮处和暗处蚯蚓的数量。

4、用一个长方形纸盒，在纸盒垫上塑料薄膜，在盒左边放干土，在盒右边放湿土，干土与湿土间隔一段距离。

5、在盒中间没有土的地方，放5条蚯蚓，观察蚯蚓往哪爬，比较干土与湿土中蚯蚓的数量。

6、整理器材。

实验现象：

1、蚯蚓都爬到阴暗处。

2、蚯蚓都爬到湿土里。

实验结论：蚯蚓适宜生活在阴暗潮湿的环境中。

实验名称：植物的向光性实验

实验材料：植物幼苗（玉米、小麦等）、火柴杆、小花盆（或培养皿）、泥土、不透光的纸盒、台灯、剪刀

实验步骤：

1、检查实验用品是否齐全。

2、用剪刀在不透光的纸盒一侧挖一个直径为1cm的孔，待模拟单侧光照射时使用。

3、将几株长势相同但其尚未出胚芽鞘的小麦幼苗依次排开，分别栽种在两个花盆中，幼苗的旁边插一根火柴杆，作为对比的参照物。

4、将制好的遮光罩扣住花盆（一组用不透光的纸盒，另一组用一侧带小孔的纸盒），白天将装置置于阳光充足的地方，夜间以台灯代替光源，并使光从小孔中透入纸盒。

5、每天打开纸盒，观察幼苗的生长情况，记录下高度、倾斜角度及当日的温度、天气等情况。

6、整理器材。

实验现象：幼苗朝纸盒开孔的方向生长，也就是向着光源的方向生长。实验结论：植物的生长具有向光性。实验名称：馒头发霉的对比试验 实验器材：四片馒头片、塑料袋、放大镜、滴管、镊子 实验步骤：

1、检验实验用品是否齐全。

2、选四片馒头，分别贴上号码。

3、在1、3号上滴水，将2、4号烤干。

4、将4片馒头分别装入袋中。

5、将1、2号放在窗台上，3、4号放在冰箱里。

6、几天后，观察4片馒头，看看发生了什么变化，并记录下来。

7、整理器材。

实验现象：1号馒头发霉最早，发霉面积最大。

2号、3号馒头发霉时间和面积居中。

4号馒头发霉时间晚，发霉面积小。实验结论：馒头在温暖、潮湿的情况下容易发霉。

第二篇：青岛版六年级科学下册实验报告册

实验名称：观察洋葱表皮细胞

实验材料：显微镜、洋葱、刀片、载玻片、盖玻片、镊子、碘酒、滴管、吸水纸 实验步骤：

1、检验试验用品是否齐全。

2、准备好显微镜。

3、将洋葱切开，掰开一块内的鳞片；用刀片在鳞片表面轻轻划一个“#”，用镊

子在“#”字中间轻轻撕下一块洋葱鳞叶的表皮。

4、在载玻片上滴几滴水，用镊子夹住洋葱表皮，放在载玻片的水中展平，用镊

子夹住盖玻片盖上，注意不要有气泡。

5、在盖玻片的左边有水处滴一滴稀释的碘液，用吸水纸在盖玻片的右边将碘液

吸过来，给洋葱表皮染色。

6、将做好的切片放在显微镜的载物台上，夹好。

7、利用低倍镜进行观察。

8、整理器材。

实验现象：洋葱表皮是有一个个小格子构成，同一个物体的不同部位，它的细胞结构也是不

一样的。

实验结论：生物体是由细胞构成的，细胞是生物体的基本单位。

实验名称：摆的秘密

实验材料：细线、钩码、铁架台、秒表 实验步骤：

1、检验试验用品是否齐全。

2、做好一个摆。

3、利用秒表测量摆摆动10S摆动的次数。

4、在不改变其他条件的情况下，改变摆线的长度。测量新摆10S摆动的次数，并记录。

5、在不改变其他条件的情况下，将摆锤的质量增加。测量新摆10S摆动的次数，并记录。

6、在不改变其他条件的情况下，改变摆幅的大小。测量新摆10S摆动的次数，并记录。

7、整理器材。

实验现象：

1、摆线越长，摆动越慢，摆线越短，摆动越快。

2、改变摆锤的质量，摆摆动的次数不变。

3、改变摆幅的大小，摆摆动的次数不变。

实验结论：摆摆动的快慢与摆线长短有关，与摆锤的质量、摆幅的大小无关。摆线越长，摆

动越慢，摆线越短，摆动越快。

实验名称：模拟钻木取火试验 实验材料：砂纸、铁丝

实验步骤：

1、检验试验用品是否齐全。

2、用砂纸宝珠铁丝。

3、反复快速摩檫一段时间。

4、用手摸铁丝。

5、整理器材。

实验现象：用手摸铁丝，铁丝变热了。

实验结论：摩擦产生热量，机械能转化成热能。

实验名称：电磁铁的磁力

实验材料：电池、包皮细电线、铁钉、大头针、导线、电池盒 实验步骤：

1、检验试验用品是否齐全。

2、在铁钉上缠绕一定圈数的包皮细电线，然后串联不同数量的电池，分别观察

并记录吸起大头针的数量。

3、在同一铁钉上先后缠绕不同圈数的包皮细电线，分别观察吸起大头针的数量。

4、整理器材。

实验现象：

1、串联电池数量多的电磁铁，吸起的大头针多。

2、缠绕圈数多的电磁铁，吸起的大头针多。实验结论：

1、串联电池数量多的电磁铁磁力大；反之小。

2、缠绕圈数多的电磁铁磁力大；反之小。

实验名称：电磁铁的磁极

实验材料：自制的电磁铁、电池、指南针或小磁针 实验步骤：

1、检验试验用品是否齐全。

2、给电磁铁通电后，让其一端与指南针接近，找出电磁铁的两极。

3、改变电池的正负极，看电磁铁的两极有没有变化。

4、改变线圈的缠绕方向，看电磁铁的两极有没有变化。

5、整理器材。

实验现象：

1、改变电池的正负极，电磁铁的两极有变化。

2、改变线圈的缠绕方向，电磁铁的两极有变化。实验结论：电磁铁的两极会变化，电池正负极方向改变或线圈缠绕方向改变都会改变电磁铁的正负极。实验名称：无处不在的能量

实验材料：铁丝、烧杯、乒乓球、热水、塑料梳子、碎纸屑等 实验步骤：

1、检查试验用品是否齐全。

2、用手弯铁丝，反复多次，观察现象。

3、把瘪了的乒乓球放入热水中，观察现象。

4、用塑料梳子在头上来回梳头，接着拿塑料梳子往碎纸屑里一放，观察发生的现象。

5、整理器材。

实验现象：

1、铁丝弯折处变热。

2、乒乓球鼓起来了。

3、碎纸屑粘到了塑料梳子上。实验结论：

1、机械能转化为热能。

2、热能转化为机械能。

3、机械能转化为电能。

实验名称：风的成因模拟实验

实验材料：大可乐瓶、小刀、火柴、纸条、蚊香、蜡烛、胶带。实验步骤：

1、检验试验用品是否齐全。

2、用小刀将大可乐瓶的底部裁掉。

3、用小刀从大可乐瓶底部向上大约6CM处刻一个直径约2CM的圆孔。

4、点燃蜡烛、蚊香。

5、用可乐瓶罩住蜡烛，将蚊香冒烟处置于可乐瓶底部圆孔约1CM处。

6、整理器材。

实验现象：蚊香的烟被吸到瓶子里去了，瓶口处的纸条在上下晃动。

实验结论：空气被蜡烛加热变成热空气，热空气比冷空气轻，会顺着瓶口上升，冷空气则会

由底部的小孔流进去补充，这样就形成了风。

实验名称：影响降落伞下降快慢的因素 实验材料：自制的降落伞

实验步骤：

1、检验试验用品是否齐全。

2、选择悬吊物重量、绳长、绳子数量、伞面材料相同，伞面大小不同的两个降

落伞。将两个降落伞从同一高度释放，观察降落伞哪个先落地。

3、选取伞面大小、绳长、绳子数量、伞面材料相同，悬吊物重量不同的两个降

落伞。将两个降落伞从同一高度释放，观察降落伞哪个先落地。

4、选择悬吊物重量、伞面大小、绳长、绳子数量相同，伞面材料不同的两个降

落伞。将两个降落伞从同一高度释放，观察降落伞哪个先落地。

5、选取悬吊物质量、伞面大小、伞面材料、绳子数量相同，绳子长短不同的两

个降落伞。将两个降落伞从同一高度释放，观察降落伞哪个先落地。

6、整理器材。

实验现象：

1、其他材料相同，伞面大小不同的两个降落伞，伞面大的下降慢。

2、其他材料相同，悬吊物重量不同的两个降落伞，悬吊物质量轻的下降慢。

3、其他材料相同，伞面材料不同的两个降落伞，透气性差的下降的慢。

4、其他材料相同，绳子长短不同的两个降落伞，绳子短的下降慢。

实验结论：降落伞下降的快慢与伞面大小、伞绳长短、悬吊物质量、伞面材料有关，伞面越

大，下降越慢；悬吊物越重，下降越慢；伞面透气性差，下降就慢；伞绳越短，下降越慢。

第三篇：实验报告册封皮

小果园小学三年级实验报告册

（2015—2016学年第二学期）

2016年2月

小果园小学四年级实验报告册

（2015—2016学年第二学期）

2016年2月

小果园小学五年级实验报告册

（2015—2016学年第二学期）

2016年2月

小果园小学六年级实验报告册

（2015—2016学年第二学期）

2016年2月

第四篇：JAVA实验报告册

《面向对象程序设计》

实验报告与习题册

2013 / 2014 学年 第1学期

系 别 计算机科学与技术系 专 业 班 级 姓 名

计算机软件 软件一班 罗晓薇

朱强 指导教师 目 录

实验一 开发环境的搭建及使用

一 实验目的与要求

1、进行java开发环境的配置；

2、熟悉eclipse集成开发环境；

3、编写简单的java application 和 java applet程序，并在eclipse中编辑、编译并运行这两种程序。

二 实验内容

1、安装jdk并配置环境变量，在下面写出如何判断环境变量是否配置成功；安装eclipse集成开发环境。

答：安装过程 双击jdk图标，点击新窗口中的“接受”按钮，选择安装位置再点击“下一步”，最后“完成”。

设置环境变量并测试 右击“我的电脑”，选择“属性”项，在新窗口选择“高级”选项，再选择“环境变量”选项，在“系统变量”栏选择“path”栏，双击此栏，在编辑系统变量窗口中修改“变量值”，输入“c:javajdk1.6.0_18bin;”，再新建环境变量“classpath”在变量值中输入“.;c:javajdk1.6.0_18bin”。点击“开始”中的“运行”，输入命令“cmd”，输入“java

”回车，如果出现了代码，就说明已经设置好环境变量了。

2、使用eclipse编写java application其功能是显示字符串“hello world！”，请将源代码和运行结果截图写在下面的空白处。答：源代码 public class helloworld { /** * @param args*/ public static void main(string[] args){ // todo auto-generated method stub system.out.println(hello world!);} } 运行结果

三 实验内容中遇到的问题、解决方法和体会。

答：问题 在安装java软件包时设置环境变量时，对path变量的变量值不知道用什么，还有新建classpath变量时也不知道怎么设置变量值； 在检测环境变量是否设置好时，也不知道怎么检测。

解决办法 查书本上的安装步骤，和询问同学，开始也不知道怎么检测环境变量已经设好了，后来看同学演示并解释了一下，知道软件已经安装成功，可以直接使用了。

体会 安装java软件并投入使用时，需要设置环境变量，而这些环境变量可以使我们的一些功能得以实现和利用；

在不知道怎么安装和使用一个新的软件时，可以查询书籍，也可以询问同学。

实验二 java程序设计基本语法

一 实验目的与要求

1、java常见数据类型、运算符和各种控制结构的简单应用；

2、理解递归原理；

3、实现数组的简单应用。

二 实验内容

1、编程输出0~100间所有能被3或5整除的数，每行输出不多于5个数。答： public class testcontinue { public static void main(string[] args){ int n=0;int i=0;for(n=0;n<=100;n++){ if(n % 3!=0 && n % 5!=0)//不能被3或5整除，结束本次循环 continue;i++;system.out.print(n+);if(i % 5==0){ //每五个数一行system.out.println();} } } } 运行结果

2、编写功能要求：按照考试成绩的等级输出百分制分数段，a等为85分以上，b等为70～84分，c等为60～69分，d等为 60分以下。成绩的等级由键盘输入。

运行结果

3、运用java二维数组打印“魔方阵”。所谓魔方阵是指这样的矩阵，它的每一行、每一列和对角线之和均相等，要求打印1~25之间由自然数构成的魔方阵。

答：

public class magics { public static void main(string[] args){ int i=0;int j=0;int m=0;int n=5;j=(n+1)/2-1;int[][]a=new int[n][n];a[i][j]=++m;while(m1){ } if(i<0)} for(i=0;i(n-1))a[i][j]=++m;i=i+2;j=j-1;运行结果

三 实验内容中遇到的问题、解决方法和体会。

实验二 方法与递归

一 实验目的与要求

1、理解递归原理；

2、掌握递归方法的设计与调用。

二 实验内容

1、输入两个整数m和n，求其最大公约数和最小公倍数。public static void main(string[] args){ int m,n,r,gcd,lcm=0;m = integer.parseint(args[0]);//把字符串转换整型

n = integer.parseint(args[1]);lcm = m*n;while((r=m%n)!=0){ m=n;n=r;} gcd=n;lcm=lcm/gcd;system.out.println(最大公约数:+gcd);//打印出最大公倍数system.out.println(最小公倍数:+lcm);//打印出最小公倍数 } } 运行结果

输入6,21

2、设计一个递归程序，计算n！。

答：public class factorial { } static int f(int n){ return n==0?1:n*f(n-1);} public static void main(string[] args){ system.out.println(10!是:+f(10));} 运行结果

三 实验内容中遇到的问题、解决方法和体会。

问题 进行实验内容1时，编写代码处没有显示错误，运行程序时出现了下面的情况。

体会 后来听老师讲到包时，才知道java.lang是一个包，想到可能是我用到的方法在包中，但没有引入它。

实验三 面向对象程序设计

一 实验目的与要求

1、编写java应用程序，完成类、对象的创建及使用；完成成员方法和构造方法的创建及使用。

2、掌握权限访问控制符public和private的用法；实现类的继承；实现变量的隐藏和方法的重写；实现成员方法和构造方法的重载；掌握多态的意义，学会多态在程序设计中的应用。

3、编写java应用程序，完成接口的实现；体会抽象类和接口的区别；体会接口的继承原理；将接口和类分别定义在不同的包中，掌握包的使用。

二 实验内容

1、定义一个学生类，为其添加成员变量为学号、年龄、姓名、班级和学校，其中学号为最终变量，学校为类变量；为其添加构造方法以完成对学生对象的初始化；为其添加成员方法getinfo（），作用是获取学生的所有信息；在main中创建一个学生对象，并验证学生类中所有方法。

class student { public final int id;public int age;public string name;public string remove;public static string school;student(){ id=0;age=20;name=小明;remove=一班;school=师范;} public string getinfo(){ return id=:+id+n+age=:+age+n+name=:+name+n+remove=:+remove+n+school=:+school;} public static void setschool(string school){ } public static void main(string[] args){ student student=new student();student.school = school;system.out.println(student.getinfo());} }

2、在第一题的基础上，添加三个成员方法以用来改变年龄、姓名、班级的值；添加五个成员方法以用来分别获取学号、年龄、姓名、班级和学校的值；在main中创建一个学生对象，并验证这些方法。class student { public final int id;public int age;public string name;public string remove;public static string school;student(){} id=0;age=20;name=小明;remove=一班;school=师范;public int getage(){ } public void setage(int age){ } public string getname(){ } public void setname(string name){ } public string getremove(){ } public string setremove(string remove){ return this.remove = remove;} public int getid(){ } public static string getschool(){ } public string getinfo(){ return return school;return id;return remove;this.name = name;return name;this.age = age;return age;id=:+id+n+age=:+age+n+name=:+name+n+remove=:+remove+n+school=:+school;} } public static void main(string[] args){ student student=new student();system.out.println(student.getinfo());}

3、修改学生类中成员的访问权限，体会public和private两种访问权限的用法。

答： 类中成员的访问权限：继承有关 public 此成员都可公开调用

private 只有本类实例成员方法才可调用

如果子类继承了父类，而基类中成员变量或成员方法有private的，子类就不能访问那个成员。

4、定义一个people类，它包含属性有姓名name和性别sex，为people类派生出一个子类employee类，为其增加两个属性年龄age和工资等级grade，工资等级分a、b、c三个等级，在子类中增加用于打印出员工的姓名、性别、年龄和工资等级的方法print，编写一个应用程序，测试定义的类。class people { public string name;public string sex;} enum grade{a,b,c;} class employee extends people{ public int age;public string grade;this.name=name;employee(string name,string sex,int age,string grade){ } } this.sex=sex;this.age=age;this.grade=grade;void print(){ system.out.println(输出职工信息：);system.out.println(姓名：+name);system.out.println(性别：+sex);

system.out.println(年龄：+age);system.out.println(工资等级：+grade);} public class test{ }

public static void main(string[] args){ } employee employee=new employee(mary,f,19,a);employee.print();

5、定义一个people类，它包含属性有姓名name和性别sex和年龄age，一个构造方法，用来初始化这三个属性；定义一个people类的子类student，添加一个属性学号number，添加两个构造方法，一个有参构造方法，一个无参构造方法，他们都要调用父类的构造方法或本类的构造方法来完成对象的初始化，添加两个成员方法，一个是选课choose()，用来输出“我没有选课”，另一个是选课choose(string)，用来选择由参数指定的课程。class people{ public string name;public string sex;public int age;people(){} people(string name,string sex,int age){ this.name = name;this.sex = sex;this.age = age;} } class student extends people{ public int id;student(){ super();} public student(int id,string name,string sex,int age){ super(name,sex,age);this.id = id;} void choosing(){ system.out.println(我没有选课);} void choosing(string n){ system.out.println(我选的课程是：+n);} public string getinfo(){ return 学号:+id+n+姓名:+name+n+性别:+sex+n+年龄:+age;} } public class choose { public static void main(string[] args){ student student = new student(123456,rose,f,18);system.out.println(student.getinfo());student.choosing();student.choosing(java);} }

6、创建一个接口shape，其中有抽象方法area，类circle、rectangle实现area方法计算其面积并返回，又有star类实现shape的area方法，其返回值是0，star类另有一返回值boolean型的方法isstar；在main方法中创建一个数组，根据随机数向其中加入shape的不同子类对象，然后将数组元素依次取出，判断其是否为star类，如是返回其个数，否则返回其面积。

interface shape { double area();} class circle implements shape { private double radius;public circle(double radius){ this.radius = radius;} public double area(){ return 3.14*radius*radius;} } class rectangle implements shape { private double wide;private double length;rectangle(double length,double wide){ this.length = length;this.wide = wide;} public double area(){ return wide*length;} } class star implements shape { public double area(){ return 0.0;} public static boolean isstar(shape s){ return(s instanceof star)? true: false;} } public class test { public static void main(string[] args){ circle c = new circle(3);rectangle r = new rectangle(3,6);star star = new star();shape[] array = new shape[]{c,r,star,star,star,c };

for(int i=0,j=1;i

三 实验内容中遇到的问题、解决方法和体会。

遇到的问题：在实验中，在类中设置构造方法时遇到了问题和困难，不知道怎样设置参数，还有创建接口时对它的继承不是很了解，用类来实现抽象方法也不是很熟练。

解决办法：参考书上创建类和接口的例子进行操作，问同学和老师，查询书本。

体会：要创建好一个类，不仅要熟悉创建类的方法，对接口、静态方法、抽象方法的运用更要熟练才行。在创建一个对象时，要对需要调用的方法中的参数、类型都要有一个了解，不然创建的对象就会不伦不类了。实验四 输入和输出流

一 实验目的与要求

1、掌握java常用i/o输入流和输出流；

2、掌握各种类型数据写入文件或读出文件的操作。

二 实验内容

1、编程利用文件流和缓冲流把一个文本文件中的内容复制到另外一个文件中。

运行结果

2、定义一个类，把这个类所生成的若干对象写入到文件中，然后从文件

中读出对象，测试读出对象的正确性。

运行结果

三 实验内容中遇到的问题、解决方法和体会。

实验五 gui图形界面设计

一 实验目的与要求

1、掌握awt与swing的区别与联系；掌握swing常用图像组件的使用；掌握主要的布局管理器的使用方法；

2、了解事件处理机制；掌握swing常用图像组件的使用；掌握固定菜单和弹出式菜单的创建和使用；

二 实验内容

1、设计并实现一个类似于windows操作系统附件中自带的计算器的一款简单的计算器，要求界面美观，设计合理；带有常用的菜单并实现其功能；能完成加、减、乘、除等简单的计算，在下面写出其核心代码。

实验时间：实验地点： 实验学时：

运行结果

三 实验内容中遇到的问题、解决方法和体会。

习题一

1.java源文件中最多只能有一个 类，其他类的个数不限。2.java应用程序的执行入口是 方法。

3.在jdk环境下，用什么命令编译java程序？用什么命令执行java程序？

习题二

1.数组对象中的哪个成员变量可以测得数组中的元素个数？

2.如果定义“int[] b=new b[10];”,b数组中的个元素值是多少？ 3.同一个数组中可否存放不同类型的数据？

习题三

1.简述this引用的作用。

2.类的成员初始化的顺序如何？

3.什么是接口？什么是抽象类？二者有何区别？ 4.简述java运行多态时的含义。5.简述java继承的主要内容。

习题四

1.什么是异常？java中的异常对象分为哪两类？ 2.简述try-catch-finally语句的执行过程 3.throws子句与throw语句的区别和联系。

习题五

1.字符输出流类都是 抽象类的子类。2.对java对象读、写的过程被称为。

3.什么是流？什么是输入/输出流？什么是字节流和字符流，它们对应的基础

抽象类分别是什么？

第五篇：数据结构实验报告册

实验一 线性表的操作

实验类型：验证性 实验要求：必修 实验学时： 2学时

一、实验目的：

参照给定的线性表顺序表类和链表类的程序样例，验证给出的线性表的常见算法。

二、实验要求：

1、掌握线性表顺序表类和链表类的特点。掌握线性表的常见算法。

2、提交实验报告，报告内容包括：目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。

三、实验内容：

1．设计一个静态数组存储结构的顺序表类，要求编程实现如下任务：建立一个线性表，首先依次输人数据元素1，2，3，…，10，然后删除数据元素6，最后依次显示当前线性表中的数据元素。要求采用顺序表实现，假设该顺序表的数据元素个数在最坏情况下不会超过10个。

第一题源代码： #include using namespace std;template

//定义模板类SeqList class SeqList { private: int length,x,j,data[10];public: public: SeqList()

//无参构造函数

{

length=0;

}

SeqList(T a[ ], int n)

//有参构造函数

{

for(int i=0;i

data[i]=a[i];

length=n;} ~SeqList()

//析构函数为空

{

}

int Length()

//求线性表的长度

{

return length;}

T Get(int i)

//按位查找，取线性表的第i个元素

{ } int Locate(T x)

//按值查找，求线性表中值为x的元素序号

{ } void Insert(int i, T x)

//在线性表中第i个位置插入值为x的元素

{ } T Delete(int i)

{

if(length==0)

throw“下溢”;

if(i<1||i>length)

throw“位置异常”;

x=data[i-1];

for(j=i;j

data[j-1]=data[j];

length--;

return x;} void PrintList()

{

for(int i=0;i

cout<

”;

cout<

void main(){ int n=10,a[10]={1,2,3,4,5,6,7,8,9,10};SeqList theseqlist(a,n);cout<<“删除前元素： ”;for(int i=0;i

cout<

//删除线性表的第i个元素

//注意此处j已经是元素所在的数组下标 //遍历线性表，按序号依次输出各元素

-------------------------2．设计一个带头结点的单链表类，要求：

(1)带头结点单链表类的成员函数包括取数据元素个数、插入元素、删除所有值为k的元素、取数据元素。

(2)设计一个测试主函数，实际运行验证所设计循环单链表类的正确性。第二题源代码： #include using namespace std;template

struct Node { T data;Node *next;};/*****************************/ template class LinkList { private:

Node *first;

//单链表头指针

int length;public:

LinkList()

{

first=new Node;

first->next=NULL;

}

LinkList(T a[],int n)

//建立n个节点的指针

{

Node *s;

first=new Node;

first->next=NULL;

//初始化一个空链表

for(int i=0;i

{

s=new Node;

s->data=a[i];

s->next=first->next;

first->next=s;

}

length=n;

}

~LinkList()

{

Node *p=first;

while(p)

{

Node *q;

q=p;

p=p->next;

delete q;

}

}

int Length();

//求单链表长度

T Get(int i);

//取单链表第i个节点元素值

int Locate(T x);

//求单链表值为x的元素序号

void Insert(int i,T x);//在单链表中第i个位置插入元素值x的节点

T Delete(int i);

//在单链表中删除第i个节点

void PrintList();

// 遍历单链表，按序号依次输出个元素 };/********************************/ template int LinkList::Length(){ return length;} /******************************/ template T LinkList::Get(int i){ int j;Node *p;p=first->next;j=1;while(p&& j

p=p->next;

j++;} if(!p)

throw “位置”;else

return p->data;} /***********************************/ template int LinkList::Locate(T x){ Node *p;p=first;for(int i=0;i

p=p->next;

if(p->data==x)

return i+1;} } /***********************************/ template void LinkList::Insert(int i,T x){ Node *p;int j;p=first;j=0;while(p&&j

p=p->next;

j++;} if(!p)

throw“位置”;else {

Node *s;

s=new Node;

s->data=x;

s->next=p->next;

p->next=s;} length++;} /**************************************/ template T LinkList::Delete(int i){ Node *p;int j;p=first;j=0;while(p&&j

p=p->next;

j++;} if(!p||!p->next)

throw“位置”;else {

Node *q;

q=new Node;

int x;

q=p->next;

x=q->data;

p->next=q->next;

delete q;

length--;

return x;}

} /*******************************************/ template void LinkList::PrintList()

// 遍历单链表，按序号依次输出个元素 { Node *p;p=first;for(int i=0;i

p=p->next;

cout<<“第”<<(i+1)<<“个元素为：”<<(p->data)<

int r[ ]={10,9,8,7,6,5,4,3,2,1};

LinkList a(r , 10);

cout<<“原表为:”<

a.PrintList();

cout<

a.Insert(1,-2);

//执行插入操作;

a.Insert(2,-1);

a.Insert(3,0);

cout<<“执行插入后输出为:”<

a.PrintList();

cout<

a.Delete(1);

a.Delete(1);

a.Delete(1);

cout<<“执行删除后输出为:”<

a.PrintList();

cout<

cout<<“按位查找元素:”<

cout<<“第 5 个元素为: ”;

cout<

//查找链表中第 5 个元素

cout<

心得体会：

实验二 栈、队列、串的操作

实验类型：验证性 实验要求：必修 实验学时： 2学时

一、实验目的：

参照给定的栈类和队列类的程序样例，验证给出的栈和队列的常见算法，并结合线性表类实现有关串的操作。

二、实验要求：

1、掌握栈、队列、串的特点。掌握特殊线性表的常见算法。

2、提交实验报告，报告内容包括：目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。

三、实验内容：

1.堆栈类测试和应用问题。要求：

设计一个主函数实现对顺序堆栈类和链式堆栈类代码进行测试。测试方法为：依次把数据元素1,2,3,4,5入栈，然后出栈堆栈中的数据元素并在屏幕上显示。第一题源代码： #include using namespace std;/********************************************************/ const int StackSize=10;template class SeqStack { private:

T data[StackSize];

int top;public:

SeqStack()

{

top=-1;

}

~SeqStack()

{

}

void push(T x);

T pop();

T GetTop()

{

if(top!=-1)

return data[top];

}

bool Empty()

{

top=-1?(return 1):(return 0);

} };

template void SeqStack::push(T x){ if(top==StackSize-1)

throw “上溢”;top++;data[top]=x;} template T SeqStack::pop(){ T x;if(top==-1)

throw “下溢”;x=data[top--];return x;}

/****************************************************/ template struct Node { T data;Node *next;};

template class LinkStack { private: Node *top;public: LinkStack(){

top=NULL;} ~LinkStack(){

while(top)

{

Node *p;

p=top->next;

delete top;

top=p;

}

} void push(T x);T pop();T gettop(){

if(top!=NULL)

return top->data;} bool Empty(){

top==NULL?return 1:return 0;} };

template void LinkStack::push(T x){ Node *s;s=new Node;

//没有申请空间时 会出现错误！

s->data=x;s->next=top;top=s;} template T LinkStack::pop(){ T x;Node *p;if(top==NULL)

throw “下溢”;x=top->data;p=top;top=top->next;delete p;return x;}

/******************************************************/ void main(){ SeqStack aa;LinkStack bb;

for(int i=1;i<=5;i++)

aa.push(i);

cout<<“顺序栈出栈：”;for(i=0;i<5;i++){

int k=0;

k=aa.pop();

cout<

”;}

cout<

for(i=1;i<=5;i++)

bb.push(i);

cout<<“链式栈出栈：”;for(i=1;i<=5;i++){

int j=0;

j=bb.pop();

cout<

”;} cout<

2.队列类测试和应用问题。要求：

设计一个主函数对循环队列类和链式队列类代码进行测试.测试方法为：依次把 1,2,3,4,5入队，然后出队中的数据元素并在屏幕上显示。

第二题源代码： #include #include using namespace std;

const int QueueSize=100;

/**************************************/ template class CirQueue { public: T data[QueueSize];

int front, rear;

CirQueue(){

front=rear=0;}

~ CirQueue(){

}

void EnQueue(T x)

{

if((rear+1)% QueueSize ==front)

throw “上溢”;

rear=(rear+1)% QueueSize;

data[rear]=x;

} T GetQueue()

{

if(rear==front)throw “下溢”;

int i=(front+1)% QueueSize;

return data[i];} T DeQueue(){

if(rear==front)

throw “下溢”;

front=(front+1)% QueueSize;

return data[front];

} };/*********************************************/ template struct Node { T data;Node *next;};

/*********************************************/ template class LinkQueue { private: Node *front,*rear;

//队头队尾指针 public: LinkQueue();

~LinkQueue(){ } void EnQueue(T x);

//将x入队

T DeQueue();

//将队头元素出队

T GetQueue()

{

if(front!=rear)

return front->next->data;

//取对头元素

} bool Empty()

//判断链队列是否为空

{

front==rear?return 1:return 0;} };/***************************************/ template LinkQueue::LinkQueue(){ Node *s;s=new Node;s->next=NULL;

//创建头结点s front=rear=s;} /***************************************/ template void LinkQueue::EnQueue(T x){ Node *s;s=new Node;s->data=x;s->next=NULL;rear->next=s;rear=s;} /***************************************/ template T LinkQueue::DeQueue(){ Node *p;T x;if(rear==front)

throw“下溢”;p=front->next;x=p->data;front->next=p->next;if(p->next==NULL)

rear=front;delete p;return x;} /***********************************************/ void main(){ CirQueue a;LinkQueue b;for(int i = 1;i <= 5;i++){

a.EnQueue(i);

b.EnQueue(i);} for(i = 1;i <= 5;i++){

int k,j(0);

k = a.DeQueue();

j=b.DeQueue();

cout<<“循环队列输出：”<< k<<“

”<<“链队列输出：”<

心得体会：

实验三 多维数组和广义表的操作

实验类型：验证性 实验要求：必修 实验学时： 2学时

一、实验目的：参照给定的多维数组类和广义表类的程序样例，验证给出的多维数组和广义表的常见算法，并实现有关的操作。

二、实验要求：

1、掌握多维数组和广义表的特点。掌握它们的常见算法。

2、提交实验报告，报告内容包括：目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。

三、实验内容：

1.设计函数建立一个n*n阶的对称矩阵。要求：

（1）实现将对称矩阵用一维数组存储输出。（2）实现矩阵转置算法。（3）实现魔方阵算法。

（4）设计一个测试例子，并编写主程序进行测试。

第一题源代码： 1.1 #include using namespace std;int a[10][10];int save[100];int main(){ int n,i,j;puts(“输入矩阵的维数 N”);cin >> n;for(i = 0;i < n;i++)

for(j =0;j < n;j++){

a[i][j] = rand()% 10 + 1;

a[j][i] = a[i][j];

}

for(i = 0;i < n;i++){

for(j = 0;j < n;j++)

cout<

cout<

}

puts(“转化后: ”);

int k = 0;

for(i = 0;i < n;i++)

for(j = 0;j <= i;j++)

{

k = i *(i + 1)/ 2 + j;

save[k] = a[i][j];k++;}

for(i = 0;i < n *(n + 1)/ 2;i++)cout<

cout<

运行结果：

1.2 #include using namespace std;const int MaxTerm=100;

template

struct element { int row, col;T item;};

struct SparseMatrix { element data[MaxTerm];int mu, nu, tu;};

void Trans1(SparseMatrix A, SparseMatrix &B){ B.mu=A.nu;B.nu=A.mu;B.tu=A.tu;if(B.tu>0)

{

int pb = 0;

for(int col = 0;col

for(int pa = 0;pa < A.tu;pa++)

if(A.data[pa].col==col)

{

B.data[pb].row= A.data[pa].col;

B.data[pb].col= A.data[pa].row;

B.data[pb].item= A.data[pa].item;

pb++;

} } } int main(){ int i;SparseMatrix AA,BB;puts(“输入行数 列数 非零元素个数”);cin >> AA.mu >> AA.nu >> AA.tu;puts(“输入三元表:”);

//puts()与 cout 一样

for(i = 0;i < 7;i++){

cin >> AA.data[i].row;

cin >> AA.data[i].col;

cin >> AA.data[i].item;} Trans1(AA,BB);puts(“输出三元表í:”);for(i = 0;i < 7;i++){

cout<

cout<

cout<

return 0;} 运行结果：

心得体会：

实验四 树和二叉树

实验类型：验证性 实验要求：必修 实验学时： 2学时

一、实验目的：

参照给定的二叉树类的程序样例，验证给出的有关二叉树的常见算法，并实现有关的操作。

二、实验要求：

1、掌握二叉树、哈夫曼树和树的特点。掌握它们的常见算法。

2、提交实验报告，报告内容包括：目的、要求、算法描述、程序结构、主要变量说明、程序清单、调试情况、设计技巧、心得体会。

三、实验内容：

1．设计实现二叉树类，要求：

（1）编写一个程序，首先建立不带头结点的二叉链式存储结构的二叉树，然后分别输出按照前序遍历二叉树、中序遍历二叉树和后序遍历二叉树访问各结点的序列信息，最后再测试查找函数和撤销函数的正确性。

（2）实现二叉树层次遍历的非递归算法。

（3）假设二叉树采用链式存储结构进行存储，编写一个算法，输出一个二叉树的所有叶子结点，并统计叶子结点个数。（4）编写求二叉树高度的函数（5）编写一主函数来验证算法实现 第一题源代码：

#include using namespace std;template

struct BiNode { T data;BiNode *lchild,*rchild;};

template class BiTree { private:

static int i;

BiNode * root;

void Creat(BiNode *&root)

{

char ch;

cin>>ch;

if(ch=='#')root=NULL;

else

{

root=new BiNode;

root->data=ch;

Creat(root->lchild);

Creat(root->rchild);

}

}

void Release(BiNode *root)

{

if(root!=NULL)

{

Release(root->lchild);

Release(root->rchild);

delete root;

}

}

//前序建立扩展二叉树 //建立一棵空树

//生成一个结点 //递归建立左子树 //递归建立右子树

void PreOrder(BiNode * root)

//前序遍历 { if(root==NULL)

return;else {

cout<data;

PreOrder(root->lchild);

PreOrder(root->rchild);}

} void InOrder(BiNode *root)

{ if(root==NULL)

return;else {

InOrder(root->lchild);

cout<<(root->data);

InOrder(root->rchild);} } void PostOrder(BiNode * root)

{ if(root==NULL)

return;else {

InOrder(root->lchild);

InOrder(root->rchild);

cout<<(root->data);} } void LevelOrder(BiNode* root){

BiNode * Q[100];

int front = 0, rear = 0;

//中序遍历二叉树

//后序遍历二叉树

//采用顺序队列，并假定不会发生上溢

if(root==NULL)

return;

Q[++rear]=root;

while(front!=rear)

{

BiNode * q=Q[++front];

cout<data;

if(q->lchild!=NULL)

Q[++rear]=q->lchild;

if(q->rchild!=NULL)

Q[++rear]=q->rchild;

}

}

void showleaf(BiNode *root)

//显示叶子节点，并统计个数

{

if(root==NULL)

{

return;

}

else

{

if((root->lchild==NULL)&&(root->rchild==NULL))

{

cout<data;

i++;

}

else

{

showleaf(root->lchild);

showleaf(root->rchild);

}

}

}

int Depth(BiNode *root)

//算法求二叉树的深度

{

if(root==NULL)

return 0;

else

{

int hl= Depth(root->lchild);

int hr= Depth(root->rchild);

if(hl>hr)

return hl+1;

else

return hr+1;

}

} public: BiTree(){

Creat(root);

}

BiTree(BiNode *root){ } ~BiTree(){

Release(root);}

void display(){

cout<<“前序遍历二叉树：

PreOrder(root);

cout<

cout<<”中序遍历二叉树：

InOrder(root);

cout<

cout<<“后序遍历二叉树：

PostOrder(root);

cout<

cout<<”层序遍历二叉树：

LevelOrder(root);

cout<

cout<<“输出叶子节点：

showleaf(root);

”;“;”;“;”;

cout<

cout<<“叶子节点数为：”<

cout<<“树的深度为：

”<

} };template int BiTree::i=0;

void main(){ cout<<“前序建立扩展二叉树：”< AA;AA.display();}

运行结果：