下载文档原格式
《Java语言与面向对象程序设计》实验指导书实验一Java开发环境和简单程序设计一、实验目的1、熟悉JDK开发环境2、了解Java应用程序和Java小程序的程序结构和开发过程3、掌握Java应用程序的简单输入和输出操作二、实验内容1、安装、设置和使用JDK2、掌握使用JDK命令行进行Java程序开发的过程和步骤编译命令：javac 源程序名.java运行Java应用程序的命令：java 主类名运行包含在网页中的Java小应用程序的命令：appletviewer 网页文件名.html3、使用JCreator Pro、NetBeans或其他开发环境来进行Java程序开发的过程和步骤4、编写程序：（1）编写应用程序，对输入的n，输出Fibonacci数列的前n个数：该数列的第1和第2项的值是1，以后各项是其前两项之和。
即1,1,2,3,5,8,13,21,34,55,...（2）编写小程序，输出二十六个英文字母表。
三、实验要求学习使用Java应用程序和小应用程序的输入输出方法控制台输出：PrintStream类的print、println、printf（format）方法等输入：Scanner类的各种类型数据的输入方法等。
实验1-1：import java.util.Scanner;class Fibonacci {public static void main(String args[]){System.out.print("please enter the n: ");Scanner sc=new Scanner(System.in);int n=sc.nextInt();int a=1,b=1,c;for(int i=1;i<=n;i++){System.out.println(a);c=a+b;a=b;b=c;}}}实验1-1运行结果如下图：实验1-2：package experiment;import java.awt.*;public class E1_2 extends java.applet.Applet {public void paint(Graphics g) {int i;for( i=0;i<26;i++){g.drawString(" "+(char)('A'+i),i*20,40);}}}试验心得体会：做完这个实验后，我开始慢慢学着用JCreator Pro、NetBeans编写简单的程序，虽然只有模仿着老师已经给我们写好的程序才会编写简单程序，不过看到程序运行后就会很有成就感。
![Java实验报告二[面向对象特性继承、封装、多态]](https://uimg.taocdn.com/be2fcbd69ec3d5bbfd0a743f.webp)
J a v a面向对象编程实验报告题目：继承、封装、多态专业：计算机科学与技术班级：学号： 2姓名：2014年 5 月 4 日一、实验目的与要求1、掌握面向对象编程中的封装特性3、掌握面向对象编程中的继承特性4、掌握面向对象编程中的多态特性实验内容根据如下类图创建每个类并进行以上内容的相关测试三、实施步骤1）：在Eclipse中创建一个抽象的MobilePhone父类，用abstract关键字修饰这个类，并且写入构造方法，类名如：MobilePhone_FatherClass2）：再给MobilePhone父类编写入一些抽象的属性和方法，并实现get(),set()方法（获取属性的方法）3）再创建四个子类继承MobilePhone父类，实现Student父类的方法，并且分别写入这些子类的自己的方法：NOKIA1：message（）；NOKIA2：netpay（）；MOTOROLA1：message（）；MOTOROLA2：metpay（）；4）再创建一个测试类：MobilePhoneTest ，实例化NOKIA1，NOKIA2，MOTOROLA1，MOTOROLA2四个子类，实现多态的输出！四、实验结果整个工程的类结构如下：①：MobilePhone父类：MobilePhone_FatherClass②：四个子类：NOKIA1,NOKIA2，MOTOROLA1，MOTOROLA2:（方法类似，只展示一个）：③：测试类：MobilePhoneTest④：实验结果：五、出现的问题及解决的方法问题：抽象类的分析，多态的实现解决方法：关键字abstract，需要继承父类使用extends关键字，不使用abstract修饰的类也是可以作为父类的！通过这次实验，我懂得了封装和继承是实现多态的前提，使自己更深的理解的封装，继承，多态的重要性。
一、摘要本次面向对象技术实训以Java编程语言为基础，通过实例分析和实践操作，让学生深入了解面向对象编程的基本概念、原则和方法。
实训过程中，学生掌握了面向对象编程的基本语法、类和对象的设计与实现、继承与多态等核心概念，并通过实际项目开发提高了编程能力。
本文将从实训内容、方法与收获三个方面进行总结。
二、实训内容1. 面向对象基本概念（1）面向对象编程（OOP）的基本概念：封装、继承、多态。
（2）Java编程语言中的面向对象编程特性：类、对象、构造方法、访问控制符等。
2. 类和对象的设计与实现（1）设计一个简单的Java程序，实现学生信息管理系统。
（2）设计并实现学生类、教师类、课程类等实体类，以及相关的方法。
3. 继承与多态（1）使用继承实现学生类和教师类的继承关系。
（2）通过多态实现不同类对同一方法的重写和重载。
4. 实际项目开发（1）设计并实现一个图书管理系统，包括图书类、读者类、借阅类等。
（2）实现图书的借阅、归还、查询等功能。
三、实训方法1. 理论学习：通过阅读教材、参考书籍，了解面向对象编程的基本概念和原理。
2. 实践操作：根据实训内容，动手编写Java程序，实现面向对象编程。
3. 交流与讨论：在实训过程中，与其他同学进行交流与讨论，共同解决遇到的问题。
4. 查阅资料：针对遇到的具体问题，查阅相关资料，提高编程能力。
四、实训收获1. 理论知识：掌握了面向对象编程的基本概念、原则和方法，为后续课程和实际项目开发奠定了基础。
2. 编程能力：通过实际项目开发，提高了编程能力，学会了如何将理论知识应用到实际项目中。
3. 团队协作：在实训过程中，与其他同学进行交流与讨论，提高了团队协作能力。
4. 问题解决能力：在遇到问题时，能够主动查阅资料、请教他人，提高了问题解决能力。
五、总结本次面向对象技术实训使我受益匪浅，不仅加深了对面向对象编程的理解，还提高了编程能力。
在今后的学习和工作中，我会继续努力，将所学知识运用到实际项目中，为我国信息技术领域的发展贡献自己的力量。
20155313实验三《Java⾯向对象程序设计》实验报告⼀、实验内容XP基础XP核⼼实践相关⼯具⼆、实验要求1.没有Linux基础的同学建议先学习《Linux基础⼊门（新版）》《Vim编辑器》课程2.完成实验、撰写实验报告，实验报告以博客⽅式发表在博客园，注意实验报告重点是运⾏结果，遇到的问题(⼯具查找，安装，使⽤，程序的编辑，调试，运⾏等)、解决办法（空洞的⽅法如“查⽹络”、“问同学”、“看书”等⼀律得0分）以及分析（从中可以得到什么启⽰，有什么收获，教训等）。
报告可以参考范飞龙⽼师的指导3.严禁抄袭，有该⾏为者实验成绩归零，并附加其他惩罚措施。
三、实验步骤1. 在IDEA中使⽤⼯具（Code->Reformate Code）把下⾯代码重新格式化，再研究⼀下Code菜单，找出⼀项让⾃⼰感觉最好⽤的功能。
提交截图，加上⾃⼰学号⽔印。
public class CodeStandard {public static void main(String [] args){StringBuffer buffer = new StringBuffer();buffer.append('S');buffer.append("tringBuffer");System.out.println(buffer.charAt(1));System.out.println(buffer.capacity());System.out.println(buffer.indexOf("tring"));System.out.println("buffer = " + buffer.toString());if(buffer.capacity()<20)buffer.append("1234567");for(int i=0; i<buffer.length();i++)System.out.println(buffer.charAt(i));}}2. 在码云上把⾃⼰的学习搭档加⼊⾃⼰的项⽬中，确认搭档的项⽬加⼊⾃⼰后，下载搭档实验⼆的Complex代码，加⼊不少于三个JUnit单元测试⽤例，测试成功后git add .; git commit -m "⾃⼰学号添加内容"；git push;提交搭档项⽬git log的截图，包含上⾯git commit的信息，并加上⾃⼰的学号⽔印信息。
实验二：对象的抽象、封装、继承、多态一、实验目的1．掌握类的声明。
2．掌握对象的创建。
3．掌握方法的定义和调用。
4．掌握构造函数的使用。
5．掌握类的继承方法。
6．掌握变量的继承和覆盖。
7．掌握方法的继承、重载和覆盖。
8．了解接口的实现方法。
二、实验内容1．编程创建一个Box类，在其中定义三个变量表示一个立方体的长、宽和高，再定义一个方法setDemo对这三个变量进行初始化，然后定义一个方法求立方体的体积。
创建一个对象，求给定尺寸的立方体的体积。
2．将上题的方法setDemo改用构造函数实现初始化。
三、思考题1．一个方法或一个块内定义的变量是否可以在方法外或块外使用？这种变量称为什么？方法的形式参数是否可以在方法之外使用？2．为什么说构造函数是一种特殊的方法？特殊在哪里？构造函数什么时候执行？被谁调用？3．编程创建一个Point类，在其中定义两个变量表示一个点的坐标值，再定义构造函数初始化为坐标原点，然后定义一个方法实现点的移动，再定义一个方法打印当前点的坐标。
并创建一个对象验证。
提示：关键代码如下：void move(int newX,int newY){x=newX;y=newY;}void print(){System.out.println(name+":x="+x+" y="+y);}…p.print();p.move(50,50);System.out.println("**after moving**");p.print(); //call method of an object4．定义一个类实现银行帐户的概念，包括的变量有"帐号"和"存款余额"，包括的方法有"存款"、"取款"和"查询余额"。
定义主类，创建帐户类的对象，并完成相应操作。
实验三继承和多态一、实验目的1.熟练掌握封装性，多态性的概念。
2.熟练掌握抽象类abstract的概念。
3.熟练掌握接口interface的概念。
4.熟练包package的概念以及编译运行的方法。
二、实验内容1.编写一个Java Application程序，该程序有个点Point类，它包含横坐标x和纵坐标y 两个属性，再给Point定义两个构造方法和一个打印点坐标的方法Show。
定义一个圆Circle 类，它继承Point类（它是一个点，圆心（Center）），除此之外，还有属性半径Radius，再给圆定义2个构造方法、一个打印圆的面积的方法PrintArea和一个打印圆中心、半径的方法Show（其中显示圆心可以用super.Show()的方式）。
编写一测试类，对其进行编译、运行。
结果如何？如去掉语句“super.Show();”，再看看运行结果。
理解程序中重载和多态性的运用。
2.完成以下步骤要求：（1）设计一个表示二维平面上点的类Point，包含有表示坐标位置的protected类型的成员变量x和y，获取和设置x和y值的public方法。
（2）设计一个表示二维平面上圆的类Circle，它继承自类Point，还包含有表示圆半径的protected类型的成员变量r，获取和设置r值的public方法、计算圆面积的public 方法。
（3）设计一个表示圆柱体的类Cylinder，它继承自类Circle，还包含有表示圆柱体高的protected类型的成员变量h、获取和设置h值的public方法、计算圆柱体体积的public 方法。
（4)建立若干个Cylinder对象，输出其轴心位置坐标、半径、高及其体积的值。
3.学校中有老师和学生两类人，而在职研究生既是老师又是学生，对学生的管理和对教师的管理在他们身上都有体现。
（1）设计两个信息管理接口StudentInterface和TeacherInterfaceo其中，StudentInterface接口包括setFee方法和getFee方法，分别用于设置和获取学生的学费；TeacherInterface接口包括setPay方法和getPay方法，分别用于设置和获取教师的工资。
上机实验三：面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础，是Java的核心和本质所在，在Java中，所有的语言元素都封装在类中。
编写java程序的过程就是从现实世界中抽象出java可实现的类，并用合适的语句定义它们的过程，本节将学习类的应用，以及如何创建类的实例，通过类的继承更有效的组织程序结构，明确类之间的关系。
掌握本节所讲的内容后，读者就可以使用面向对象技术编写java程序了。
接口是特殊的抽象类，只包含常量和方法的定义，而没有方法的实现，也就是说接口是方法定义和常量值的集合。
包是Java语言中有效管理类的一个机制。
通过关键字package声明包语句，package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。
使用import语句可以引入包中的类。
一、实验目的1)掌握类的定义和使用2)掌握对象的声明和使用3)了解构造函数的概念和使用4)掌握类的继承关系和派生方法5)掌握多态的概念与使用6)掌握接口的定义和使用7)掌握Java中包的应用二、实验内容1)类的声明2)定义类成员变量以及成员方法3)实例化类、创建类对象以及类方法的调用4)类的继承5)通过实例理解接口的定义6)通过实例熟悉接口的应用7)正确应用Java中包和import语句三、实验步骤1)类和类的实例化一个类的实现包括两部分：类声明和类体。
（1）、类声明[public][abstract][final] class className [extends superclassName][implements interfaceNameList]{……}期中修饰符[public][abstract][final]说明类的属性className为类名superclassName为父类的名字interfaceNameList为类实现的接口列表（2）、类体类体定义如下class className{[public|protected|private] [static] [final] [transient] [volatile]Type variableName; //成员变量[public|protected|private] [static] [final] [abstract] [native] [synchronized] returnType methondName ( [paramList] ) [throws exceptionList]{statements} //成员方法}（3）、成员变量成员变量的声明方式如下[public|protected|private] [static] [final] [transient] [volatile]Type variableName; //成员变量其中：[public|protected|private] →可见性[static] →静态变量（类变量），相当于实例变量[final] →常量[transient]→暂时性变量，用于对象存档[volatile]→变量，用于共发线程的共享（4）、成员方法[public|protected|private] [static] [final] [abstract] [native] [synchronized] returnType methondName ( [paramList] ) [throws exceptionList]//方法体的声明{statements} //方法体其中：[public|protected|private] →可见性[static] →静态方法，也叫类方法，可以通过类名直接调用[final] →方法不能被重写[abstract]→抽象方法，没有方法体（体现多态时常用）[native] →集成其他语言的代码[synchronized]→控制多个并发线程的访问例子3-1请根据注释填写语句，并上机调试成功根据注释添加语句，并调试和修改程序，使其能够执行。
一、实验目的1. 理解面向对象设计的核心概念，如封装、继承、多态等。
2. 掌握面向对象设计的方法和步骤。
3. 通过实际案例分析，提高面向对象设计的实践能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 面向对象设计的基本概念2. 类与对象3. 继承与多态4. 实际案例分析四、实验步骤1. 面向对象设计的基本概念（1）定义：面向对象设计（Object-Oriented Design，OOD）是一种以对象为中心的设计方法，通过将现实世界中的实体抽象为对象，以对象及其相互关系来描述系统的结构和行为。
（2）核心概念：a. 封装：将对象的属性（数据）和行为（方法）封装在一起，对外提供接口。
b. 继承：允许一个类继承另一个类的属性和方法，实现代码复用。
c. 多态：允许不同类的对象对同一消息作出响应，实现行为的变化。
2. 类与对象（1）定义：类是具有相同属性和行为的对象的抽象，对象是类的实例。
（2）步骤：a. 定义类：创建一个新的类，定义属性（成员变量）和方法（成员函数）。
b. 创建对象：使用new关键字创建类的实例。
c. 访问对象属性和方法：使用点号（.）操作符访问对象的属性和方法。
3. 继承与多态（1）继承：定义一个新的类（子类）继承自另一个类（父类），子类继承父类的属性和方法。
（2）多态：允许不同类的对象对同一消息作出响应，实现行为的变化。
（3）步骤：a. 定义父类：创建一个父类，定义属性和方法。
b. 定义子类：创建一个子类，继承自父类，并添加新的属性和方法。
c. 实现多态：使用子类对象调用父类方法，实现不同对象对同一消息的不同响应。
4. 实际案例分析（1）案例分析：设计一个简单的图书管理系统。
（2）设计步骤：a. 分析需求：图书管理系统需要管理图书的增删改查等功能。
b. 设计类：设计图书类（Book）、借阅者类（Borrower）和管理员类（Admin）。
信息科学与工程学院《Java程序设计》上机实验报告专业班级姓名学号实验时间指导教师成绩主要实验记录及个人小结（包括部分实验源程序、调试结果及实验结果分析等）Student(String name,String sex,int age,String sno,String classno) {super(name,sex,age);this.sno=sno;this.classno=classno;}public String toString(){ return("姓名:"+name+" 性别:"+sex +" 年龄:"+age+ " 学号:"+sno+" 班号:"+classno+" ");}}public class TestStudentPerson {public static void main(String[] args){int i;Student stu[]=new Student[3];stu[1]=new Student("小明","男",20,"200912135138","2班");stu[2]=new Student("小木","女",23,"200912135136","5班");stu [1].updateAge(25);stu [2].updateAge(26);for(i=1;i<3;i++){System.out.println(stu[i]);}}}2)调试结果:主要实验记录及个人小结（包括部分实验源程序、调试结果及实验结果分析等）调试结果:2)将Shape类定义为abstact class Shape{……}public class TestVirtualInvoke {static void doStuff(Shape s){s.draw();}public static void main(String[] args) {Circle c=new Circle();Triangle t=new Triangle();Line l=new Line();doStuff(c); //作为实参,调用对象是3个类对象,上溯造型使其隐藏.doStuff(t);doStuff(l);}}abstract class Shape{abstract void draw();}class Circle extends Shape{void draw(){System.out.println("Draw Circle");}} //定义Shape抽象类的派生类Circleclass Triangle extends Shape{void draw(){System.out.println("Draw Three Triangle");}}//定义Shape抽象类的派生类Triangleclass Line extends Shape{void draw(){System.out.println("Draw Line");}}//定义Shape抽象类的派生类Line主要实验记录及个人小结（包括部分实验源程序、调试结果及实验结果分析等）调试结果:3)将Shape定义为interface Shape{……}public class TestVirtualInvoke {static void doStuff(Shape s){s.draw();}public static void main(String[] args) {Circle c=new Circle();Triangle t=new Triangle();Line l=new Line();doStuff(c); //作为实参,调用对象是3个类对象,上溯造型使其隐藏.doStuff(t);doStuff(l);}}interface Shape{public void draw();} //定义一个Shape接口class Circle implements Shape{public void draw(){System.out.println("Draw Circle");}} //基于Shape接口利用implements实现类Circleclass Triangle implements Shape{public void draw(){System.out.println("Draw Three Triangle");}}class Line implements Shape{public void draw(){System.out.println("Draw Line");}}调试结果:3.思考题:某小型公司，主要有三类人员：经理、兼职技术人员和兼职推销员。
Java继承与多态实验报告.doc
Java的继承与多态实验报告
本报告致力于分析Java继承与多态的概念、原理和作用，以及相关实验过程及其结果。
继承，又称为分类，是Java面向对象程序设计语言中定义类之间关系的重要技术。
它使一个类可以使用另一个基类中定义的方法和属性，在基类中已经定义了一些功能，子
类可以对基类功能进行拓展与定制。
《Java技术手册》得出结论，继承可以有效提高软件的复用性、可维护性和可重用性，使大型的、复杂的程序有条理层次。
多态是Java中一种特殊的程序结构，允许不同类的对象对相同的消息作出不同的响应，由程序的消息而不是对象的类型来决定对象的行为。
它是Java多态性的基础，使程
序能够在不同对象上进行操作，统一实现。
从实验中，可以明显看出Java继承与多态之间的联系：多态必须依赖于继承，当子
类被创建时，它继承了母类的方法以及特性，这样，它才能以逐渐上升的方式处理所有消息，而多态给了子类独特-->性的功能。
同时，多态也方便了代码重用，因为子类会继承
母类的方法和属性。
此外，结果表明，多态的优点使程序可以提高可重用性，它也减少了代码的重复编写，同时允许特定类之外的类可以得到适用。
它促进了软件不断更新，因为多态给开发人员提
供了以对象层次组织代码的方法。
本练习涉及到Java继承与多态概念的整体概述和实现细节，为完全理解多态的概念
打下了坚实的基础。
它提供了一个理解和使用这些概念的有用方式和指导。
《面向对象程序设计》实验3内容及要求一、实验题目类的继承与多态（2学时）二、实验目的、任务通过使用类的继承与多态创建新类，进一步了解类的继承和多态概念，掌握java程序中类的继承和多态的使用方法，掌握类成员的重载和覆盖的区别及应用。
三、实验基本要求（1）认真学习、掌握与本实验相关的知识。
（2）设计并编写代码完成题目要求的任务。
（3）撰写实验报告。
实验报告统一采用洛阳理工学院实验报告纸张。
四、实验内容本次实验要求学生采用java语言编写使用类的继承和多态的应用程序，实现以下要求。
1. 定义描述平面中点的类Point，包含实数坐标值(x，y)，包含以下方法：（1）三个构造方法，分别为无参构造方法（x、y初始化为0）、提供x和y值的有参数构造方法，拷贝构造方法。
（2）转换为字符串（形式如“（12.5, 34）”）的方法toString( )。
（3）判断与另外点p是否位置相同的方法equals(Point p)。
（4）改变点自身位置的方法changeBy（dx，dy），dx、dy分别为该点在x、y坐标方向上的位移量。
2. 继承类Point定义像素类Pixel，增加数据成员color（其类型为实验2定义的颜色类Color），定义以下方法：（1）无参构造方法（x, y为0，color为黑色），提供x、y、color值的有参构造方法。
（2）覆盖toString()方法，转换为形式“（x, y）RGB（r, g, b）”的字符串。
（3）定义方法Point getPoint()，Color getColor()，分别获得Pixel对象的位置和颜色。
（4）改变像素自身值的方法changeBy（color），color为要改变的颜色值。
3. 另设计一个类，在其中定义main（）方法，测试以上两个类的功能，解释产生的结果。
（1）定义Point类的两个点p1(0,0)、p2(20,30)，拷贝构造p3(20,30)；（2）以字符串“p1(0,0)、p2(20,30)、p3(20,30)”形式输出三个点；（3）用equals判断p2与p3是否相等，输出结果；（4）定义Pixel类的两个像素pixel1(10,5，红色)、pixel2(10,5，蓝色)；（5）分别以字符串“（x, y）RGB（r, g, b）”形式输出像素pixel1、像素pixel2的值；（6）用equals判断pixel1与pixel2是否相等，输出结果；(解释结果和使用的方法)；（7）移动Pixel1的位置，移动量为（-5,5），改变Pixel1的颜色为绿色；（解释使用的方法）；（8）使p1=pixel1; 以字符串输出p1；（解释结果和使用的方法）；（9）使用p1.getPoint(); p1.getColor()获得pixel1像素的位置和颜色；（解释出现的情况）；。
一、实训背景随着信息技术的飞速发展，面向对象编程已成为当今软件开发的主流技术。
为了提高我们的编程能力和实际项目经验，我们选择了面向对象开发作为实训内容。
本次实训以Java语言为基础，结合实际项目需求，学习并实践面向对象编程的方法和技巧。
二、实训目标1. 掌握面向对象编程的基本概念和原理；2. 熟悉Java语言的基本语法和常用类库；3. 能够运用面向对象的方法设计、实现和维护软件系统；4. 培养团队协作和沟通能力。
三、实训内容1. 面向对象编程基本概念（1）面向对象的基本特征：封装、继承、多态；（2）面向对象的基本原理：抽象、类、对象、继承、多态、接口；（3）面向对象的设计模式：单例模式、工厂模式、观察者模式等。
2. Java语言基础（1）Java语言的基本语法；（2）常用类库：String、ArrayList、HashMap等；（3）异常处理、多线程编程。
3. 面向对象设计实现（1）设计一个简单的面向对象系统，包括用户管理、权限管理、数据管理等模块；（2）运用面向对象的设计原则和设计模式，提高代码的可读性、可维护性和可扩展性；（3）使用UML图进行需求分析和系统设计。
4. 项目实践（1）根据实际需求，设计并实现一个具有实际应用价值的软件系统；（2）在项目开发过程中，注重团队协作和沟通，提高项目进度和质量；（3）学会使用版本控制工具，如Git，进行代码管理。
四、实训过程1. 阶段一：理论学习（1）通过阅读教材、参考书籍和网上资料，学习面向对象编程的基本概念和原理；（2）通过课堂讲解和课后练习，掌握Java语言的基本语法和常用类库。
2. 阶段二：系统设计（1）分析项目需求，确定系统功能模块；（2）运用面向对象的设计原则和设计模式，进行系统设计；（3）使用UML图描述系统架构和类关系。
3. 阶段三：代码实现（1）根据系统设计，编写Java代码实现各个模块的功能；（2）在编写代码过程中，注意代码规范和性能优化；（3）使用版本控制工具进行代码管理。
实验报告课程名称面向对象课程设计实验项目名称类的继承班级与班级代码13计算机科学与技术1班实验室名称（或课室）SS1 205专业计算机科学与技术任课教师尹华学号：12251102120姓名：林淑英实验日期：2014 年4 月28 日广东财经大学教务处制姓名林淑英实验报告成绩评语：指导教师（签名）年月日说明：指导教师评分后，实验报告交院（系）办公室保存。
实验三类的继承、多态、接口、访问控制符与修饰符实验目的：通过编程练习掌握类的继承，多态，接口，访问控制符与修饰符的使用方法。
实验原理：类的继承，接口。
实验设备：计算机，Eclipse。
实验题目：1.设计一个Person 类，其成员变量有：姓名(name)、性别(gender)、年龄(age)；再设计一个Student类，它是类Person的子类，其成员变量有：学号(id)、班名(cname)、成绩(score)，类Student中要有一个方法 display()，用来显示一个学生的信息。
编写一个测试程序，创建一个Student类的对象，要求name和id 是自己的姓名和学号，输出学生的各种信息，学生的基本信息在类Student的带参数的构造方法中设定。
2.定义一个类A，该类有一个方法f，方法f可以输出英文字母，再定义一个类B是A的子类，子类B不能重写父类A的方法f，子类有一个方法g，可以输出中文字符串。
编写测试程序，创建B的对象，输出英文字母和中文字符串。
3.定义一个坐标类Pointer，成员变量包括x和y；成员方法有：（1）构造方法（2）setX、setY、getX、getY、display方法（3）类方法distance用来计算两点之间的距离编写测试程序，创建Pointer的两个对象并计算两个点坐标的距离。
4. 定义一个抽象类Area、两个Area的子类RectArea和RoundArea，以及一个实现类ImpleArea。
要求如下（1）抽象类Area类中只包含一个抽象方法double area()。
实验项目名称：继承和多态（所属课程：Java语言程序设计）院系：专业班级：姓名：学号：实验地点：指导老师：本实验项目成绩：教师签字：日期：1．实验目的（1）掌握类的继承机制。
（2）熟悉类中成员变量和方法的访问控制。
（3）熟悉方法或构造方法多态性。
2.实验内容（1）模拟编写程序，理解类的继承、多态、继承和多态规则。
（2）独立编程，实现类的继承和多态。
3.实验作业设计一个类Shape（图形）包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor()，并利用Java多态技术设计其子类Circle（圆形）类、Rectangle （矩形）类和Triangle（三角形）类，并分别实现相应的求面积和求周长的方法。
每个类都要覆盖toString方法。
海伦公式：三角形的面积等于s(s-a)(s-b)(s-c)的开方，其中s=(a+b+c)/2程序代码为：Class包package Class;public class Shape {private String color = "while";public Shape(String color){this.color = color;}public void setColor(String color){this.color = color;}public String getColor(){return color;精选文库}public double getArea(){return 0;}public double getPerimeter(){return 0;}public String toString(){return"color:" + color;}}package Class;public class Circle extends Shape {private double radius;public Circle(String color,double radius) {super(color);this.radius = radius;}public void setRadius(double radius){this.radius = radius;}public double getRadius(){return radius;}public double getCircleArea(){return 3.14*radius*radius;}public double getCirclePerimeter(){return 3.14*2*radius;}public String toString(){return"The Area is:" + getCircleArea()+ "\nThe Perimeter is:" + getCirclePerimeter();}}package Class;public class Rectangle extends Shape{private double width;private double height;public Rectangle(String color,double width,double height) { super(color);this.width = width;this.height = height;}public void setWidth(double width){this.width = width;}public double getWidth(){return width;}public void setHeight(double height){this.height = height;}public double getHeight(){return height;}public double getRectangleArea(){return width*height;}public double getRectanglePerimeter(){return 2*(width + height);}public String toString(){return"The Area is:" + getRectangleArea()+ "\nThe Perimeter is:" + getRectanglePerimeter();}}package Class;public class Triangle extends Shape{private double a;private double b;private double c;private double s;public Triangle(String color,double a,double b,double c, double s){ super(color);this.a = a;this.b = b;this.c = c;this.s = s;}public void setA(double a){this.a = a;}public double getA(){return a;}public void setB(double b){this.b = b;}public double getB(){return b;}public void setC(double c){this.c = c;}public double getC(){return c;}public double getTriangleArea(){return Math.sqrt(s*(s-a)*(s-b)*(s-c));}public double getTrianglePerimeter(){return a + b + c;}public String toString(){return"The Area is:" + getTriangleArea()+ "\nThe Perimeter is:" + getTrianglePerimeter();}}Main包package Main;import Class.Shape;import Class.Circle;import Class.Rectangle;import Class.Triangle;import java.util.Scanner;public class test {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.print("请输入圆的半径： ");double radius = input.nextDouble();Circle circle = new Circle(null, radius);System.out.println(circle.toString());System.out.print("\n请输入矩形的宽： ");double width = input.nextDouble();System.out.print("请输入矩形的高： ");double height = input.nextDouble();Rectangle rectangle = new Rectangle(null, width, height);System.out.println(rectangle.toString());System.out.print("\n请输入三角形的第一条边 a： ");精选文库double a = input.nextDouble();System.out.print("请输入三角形的第二条边 b： ");double b = input.nextDouble();System.out.print("请输入三角形的第三条边 c： ");double c = input.nextDouble();double s = (a + b + c)/2;Triangle triangle = new Triangle(null, a, b, c, s);System.out.println(triangle.toString());}}运行结果为：4．实验总结（1）通过实验掌握了类的继承机制。
20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态))上机实验三：面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础，是Java的核心和本质所在，在Java中，所有的语言元素都封装在类中。
编写java 程序的过程就是从现实世界中抽象出java可实现的类，并用合适的语句定义它们的过程，本节将学习类的应用，以及如何创建类的实例，通过类的继承更有效的组织程序结构，明确类之间的关系。
掌握本节所讲的内容后，读者就可以使用面向对象技术编写java程序了。
接口是特殊的抽象类，只包含常量和方法的定义，而没有方法的实现，也就是说接口是方法定义和常量值的集合。
包是Java语言中有效管理类的一个机制。
通过关键字package声明包语句，package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。
使用import语句可以引入包中的类。
一、实验目的1) 2) 3) 4) 5) 6) 7)掌握类的定义和使用掌握对象的声明和使用了解构造函数的概念和使用掌握类的继承关系和派生方法掌握多态的概念与使用掌握接口的定义和使用掌握Java中包的应用二、实验内容1) 2) 3) 4) 5) 6) 7)类的声明定义类成员变量以及成员方法实例化类、创建类对象以及类方法的调用类的继承通过实例理解接口的定义通过实例熟悉接口的应用正确应用Java中包和import语句三、实验步骤1) 类和类的实例化一个类的实现包括两部分：类声明和类体。
、类声明[public][abstract][final] class className [extends superclassName] [implements interfaceNameList] {……}期中修饰符[public][abstract][final]说明类的属性className为类名superclassName为父类的名字interfaceNameList为类实现的接口列表、类体类体定义如下 class className {[public|protected|private] [static] [final] [transient] [volatile] Type variableName; //成员变量[public|protected|private] [static] [final] [abstract] [native] [synchronized] returnTypemethondName ( [paramList] ) [throws exceptionList] {statements} //成员方法 }、成员变量成员变量的声明方式如下[public|protected|private] [static] [final] [transient] [volatile] Type variableName; //成员变量其中：[public|protected|private] →可见性[static] →静态变量，相当于实例变量[final] →常量[transient] →暂时性变量，用于对象存档[volatile] →变量，用于共发线程的共享、成员方法[public|protected|private] [static] [final] [abstract] [native] [synchronized] returnTypemethondName ( [paramList] ) [throws exceptionList]//方法体的声明 {statements} //方法体其中：[public|protected|private] →可见性[static] →静态方法，也叫类方法，可以通过类名直接调用 [final] →方法不能被重写[abstract] →抽象方法，没有方法体 [native] →集成其他语言的代码[synchronized] →控制多个并发线程的访问例子3-1请根据注释填写语句，并上机调试成功根据注释添加语句，并调试和修改程序，使其能够执行。
--------------------------------------------------------------------------------------------------------------------- class Retangle {publicRetangle(double l, double w) { length = l; width = w;}public double calcPerimeter //返回周长{ } public double calcArea //返回面积{ }public void Show //显示矩形的长和宽{ } protected double length; protected double width; } class Square extends Retangle {public Square(double side) //调用父类的构造方法{} public double calcPerimeter { return width * 4; } public void Show {( “边长为” + width + “的正方形”); } }publicclass Test{public static void main(String args){Square sq1=new Square ;;(\正方形的边长为\} return (width+length)*2; }return width*length; ----------------------------------------------------------------------------------------------------------------- (\；填写的语句是： super(side,side);classRetangle { publicRetangle(double l, double w) { length = l; width = w;}publicdoublecalcPerimeter //返回周长{return (width+length)*2;} publicdoublecalcArea //返回面积{ returnwidth*length; }publicvoid Show //显示矩形的长和宽{ (\+length+\+\+width ) ; }protecteddoublelength; protecteddoublewidth; }class Square extendsRetangle {public Square(double side) //调用父类的构造方法{ super(side,side); } publicdoublecalcPerimeter { returnwidth * 4; } publicvoid Show { ( \边长为\ + width + \的正方形\);} }publicclass Test{publicstaticvoid main(String args){ Square sq1=newSquare ; ;(\正方形的周长为\+ ); } }2) 类的继承继承是面向对象程序设计的方法中的一种重要手段，通过继承可以更有效的组织程序的结构，明确类之间的关系。
继承通过extends关键字来实现，子类继承父类的属性和行为，同时可以修改父类的属性和行为，并添加新的属性和行为。
Java不支持多重继承。
创建子类的格式如下classSubClass extends SuperClass{ …… }其中SubClass→子类的名称extends→继承的关键字 SuperClass→父类的名字例子3-2 请分析程序，填写语句的功能注释，并上机调试成功。
下面这个例子通过点、圆的层次结构，介绍类的继承。
---------------------------------------------------------------------------- import ; //调用格式化数字输出import ; // joptionpane让您轻松弹出一个标准的对话框class Point{//父类点的的定义protected intx,y ; // 定义点的坐标 public Point { // 确定构造函数setPoint(0,0);} public Point(inta,int b){ //构造函数重载带参数的构造函数setPoint(a,b); }public void setPoint(inta,int b){ // x=a;y=b; } public intgetX { return x;} //获得X的坐标 public intgetY { return y;} // 获得Y的坐标public String toString { return \ } }/*子类圆的定义*/class Circle extends Point { //圆类继承父类点类 protected double radius ;//定义圆的半径public Circle { setRadius(0);}// 定义子类的构造函数，隐含调用了父类的构造函数 public Circle(double r,inta,int b){ super(a,b);// setRadius(r); } public void setRadius(double r){ radius = (r>=r:); // } public double getRadius { // 获得圆半径return radius; }public double area { //return *radius*radius; } public String toString {//圆的半径。
以及圆心坐标转换成字符串输出 return \ } } public class InheritanceTest{ public static void main(String args){ Point pointRef,p;//声明两点对象Circle circleRef,c;//声明两圆对象 String output;//定义一个字符串变量 p=new Point(30,50);//给点对象赋值 c=new Circle (,120,89);//给圆对象赋值//把点对象和圆对象转换成字符串后给字符串output 赋值output=\pointRef=c; output=output+\。
