实验报告_实验5 类与类关系与抽象类(学生学号_姓名)

浙江大学城市学院实验报告课程名称面向对象程序设计实验项目名称类与对象基础实验（一）学生姓名专业班级学号一. 实验目的和要求1. 掌握对象与类的关系2. 掌握类的域、方法、构造器的概念3. 掌握对象的创建与初始化4. 掌握方法和域（静态和非静态）的使用方式5. 掌握Math类，掌握静态成员的使用方式6. 理解方法和构造器重载现象二. 实验内容1. 程序阅读并回答问题2. 类的使用3. 编程实验：猜数字4. 编程实验：素数判断与统计三. 实验结果与分析（可将程序运行结果截屏，也可分析运行结果）1. . 程序阅读并回答问题：阅读实验讲义的对应代码，回答以下问题。

(1)将上述代码编译运行，将运行结果截图。

(2)上述源码中共定义了几个类？分别刻画了哪些数学图形？Triangle类有哪些域和方法？Triangle的这些域和方法是静态的还是非静态的？答：(3)类和对象是什么关系？请从上述AreaAndLength.java中举例说明如何创建对象。

答：(4)Triangle类中出现的Math.sqrt是什么？请举例说明Math类中还有哪些常用域和方法？答：(5)静态域和方法与非静态域和方法在使用时有什么区别？请从上述AreaAndLength.java中举例说明。

答：(6)什么是构造器？构造器与一般方法的区别是什么？构造器可以重载吗？请从上述AreaAndLength.java中举例说明。

答：2. 已有Rectangle类（矩形类），它有两个浮点型属性length（长）和width（宽）。

该类具有两个构造函数（无参和有参），perimeter()和area()方法分别返回矩形的周长和面积, 请编写相应的包含main方法的类和main方法来测试Rectangle类。

（程序结构参考讲义）(1)请将源码编写完整如下：(2)程序运行结果截图如下：3. 编程实验：猜数字。

程序运行的界面截屏如下：4. 编程实验：素数判断与统计。

类和对象实验报告类和对象实验报告引言：在计算机科学领域中，类和对象是面向对象编程的基本概念。

通过类和对象的使用，可以将现实世界中的事物抽象为计算机程序中的实体，从而更好地描述和处理问题。

本实验将通过一个简单的示例来介绍类和对象的基本概念，并展示它们在实际编程中的应用。

实验目的：1. 理解类和对象的概念；2. 学会创建类和对象，并进行基本的操作；3. 掌握类和对象在程序中的应用。

实验过程：1. 定义一个类：首先，我们需要定义一个类来表示一个学生。

一个学生通常有姓名、年龄和成绩等属性。

我们可以使用Python语言来定义这个类，如下所示：```pythonclass Student:def __init__(self, name, age, score): = nameself.age = ageself.score = score```在上述代码中，我们使用了Python中的类和构造函数的概念。

`__init__`方法是类的构造函数，用于初始化类的属性。

`self`表示类的实例对象本身。

2. 创建对象：在类定义完成后，我们可以创建类的对象。

通过创建对象，我们可以访问和操作类的属性和方法。

下面是创建一个学生对象的示例代码：```pythonstudent1 = Student("张三", 18, 90)```在上述代码中，我们使用`Student`类的构造函数创建了一个名为`student1`的学生对象。

通过传入相应的参数，我们可以为学生对象的属性赋值。

3. 访问对象的属性和方法：一旦对象创建成功，我们就可以通过对象来访问和操作类的属性和方法。

下面是一些访问对象属性和方法的示例代码：```pythonprint() # 输出学生的姓名print(student1.age) # 输出学生的年龄print(student1.score) # 输出学生的成绩def study(self):print(f"{}正在学习")student1.study() # 调用学生对象的study方法```在上述代码中，我们通过对象的名称和点操作符来访问对象的属性和方法。

[实验报告]类和对象
一、实验目的
通过本次实验，了解抽象的一种程序设计概念“类”和“对象”，理解类之间的继承与多态性，以及封装对对象的各种属性和行为，实现软件对象模型与真实世界对象间的映射。

二、实验内容
1.定义类与对象
(1)类是代表一类实体的抽象。

它包含了一个共同拥有的结构和行为。

类是面向对象程序设计的基本元素。

(2)对象是一个实例。

它拥有一个特定于其类型的属性，并表现出对应的行为。

对象是程序中实际的可操作的元素。

2.类的成员
(1)类的成员可以是变量，函数，常量等等。

(2)变量：类的成员变量可以存储数据成员和提供给类的方法，这些变量被称为实例变量；类变量存储类及其对象的信息。

(3)函数：类的成员函数用于封装一定的行为或对对象的设置，它可以访问实例变量和类变量的值，以及实现一定的功能。

多态性是指一个类可以根据不同环境要求而采用不同的行为。

接口就是把数据和逻辑封装在一起的内部接口。

抽象数据类型试验报告
实验目的：
掌握抽象数据类型的概念与实现方式，并进一步理解面向对象程序设计的思想。

实验内容：
设计并实现一个简单的学生信息管理系统，采用抽象数据类型的思想实现。

实验步骤：
1. 设计抽象数据类型：学生信息类。

学生信息类的属性包括姓名、学号、性别、年龄和班级等基本信息。

2. 编写类的定义文件，包括类名、类属性、构造函数和访问方法等。

3. 编写测试程序，实例化学生信息类并设置学生信息。

测试程序应能够对学生信息进行增、删、改、查等操作。

4. 运行测试程序，检查学生信息管理系统功能是否正常。

实验结果：
实验结果显示，学生信息管理系统可以有效地管理学生的基本信息，能够满足学校信息管理的基本需求。

抽象数据类型的应用让程序具有了更好的可维护性和可扩展性，也更符合面向对象程序设计的思想。

实验结论：
抽象数据类型是现代程序设计中的一种重要思想和技术手段，能够有效地提高程序的可重用性和可扩展性，并使程序的设计更加合理和安全。

学生信息管理系统的实现也反映了抽象数据类型的优越性，使得程序开发人员能够更加便捷和高效地开发与维护程序。

类与对象的设计实验报告一、实验目的本实验旨在通过设计类与对象，加深对面向对象编程的理解，掌握类的定义、对象的创建和调用以及类与对象之间的关系。

二、实验过程1. 类的定义首先根据需求分析，确定了需要设计的类，包括Student类和Course 类。

其中Student类包括学生的姓名、学号、性别和年龄等属性，还包括选修的课程信息；Course类包括课程的名称、学分和教师等属性。

pythonclass Student:def __init__(self, name, student_id, gender, age): = nameself.student_id = student_idself.gender = genderself.age = ageself.courses = []def add_course(self, course):self.courses.append(course)def show_courses(self):for course in self.courses:print(course)class Course:def __init__(self, name, credit, teacher): = nameself.credit = creditself.teacher = teacherdef __str__(self):return f"Course: {}, Credit: {self.credit}, Teacher: {self.teacher}"2. 对象的创建和调用在主程序中，我们可以创建相应的对象并进行属性赋值、方法调用等操作。

pythons1 = Student("Tom", 1001, "male", 18)c1 = Course("Math", 4, "Mr. Smith")c2 = Course("English", 3, "Ms. Johnson")s1.add_course(c1)s1.add_course(c2)s1.show_courses()3. 类与对象之间的关系通过调用对象的方法，我们可以为一个学生对象添加多门课程，进一步说明了类与对象之间的关系。

类与对象实验报告类与对象实验报告引言在计算机科学领域，类与对象是面向对象编程的基本概念之一。

通过定义类，我们可以创建对象，从而实现对数据和行为的封装和抽象。

本实验旨在通过实际操作，深入理解类与对象的概念，并掌握其在程序设计中的应用。

实验目的1. 理解类与对象的概念和关系；2. 学会使用类和对象进行数据封装和行为抽象；3. 掌握类与对象在程序设计中的应用。

实验过程1. 类的定义在本实验中，我们以一个简单的学生类为例进行说明。

首先，我们需要定义一个类来表示学生。

在类的定义中，我们可以包含学生的属性和行为。

比如，学生的姓名、年龄、性别等属性，以及学生的学习、休息等行为。

2. 对象的创建在类的定义完成后，我们可以通过创建对象来实例化这个类。

对象是类的具体实例，每个对象都有自己的属性和行为。

比如，我们可以创建一个名为"张三"的学生对象，给该对象的属性赋值，并调用对象的方法来执行相应的行为。

3. 属性的访问和修改通过对象，我们可以访问和修改类中定义的属性。

比如，我们可以通过对象的属性来获取学生的姓名和年龄，并通过修改属性的值来更新学生的信息。

4. 方法的调用类中的方法是对行为的抽象，通过方法，我们可以对对象进行操作。

比如，我们可以调用学生对象的学习方法，来模拟学生的学习行为。

同时，方法也可以接受参数，以实现更加灵活的功能。

实验结果通过实验，我们成功创建了一个学生类，并实例化了一个学生对象。

通过对象的属性和方法，我们可以获取和修改学生的信息，同时也可以模拟学生的行为。

这样，我们就实现了对学生的封装和抽象，提高了程序的可读性和可维护性。

实验总结通过本次实验，我深刻理解了类与对象的概念和关系。

类是对一类具有相同属性和行为的对象的抽象，而对象则是类的具体实例。

通过定义类和创建对象，我们可以实现对数据和行为的封装和抽象，提高了程序的可读性和可维护性。

在实际的程序设计中，类与对象是非常重要的概念，对于理解和应用面向对象编程具有重要意义。

《Python程序设计》-实验报告-(5)(总7页)实验目的：
本实验旨在通过Python语言学习类、实例、构造函数、多态和类与函数的结合来综合应用Python程序设计的基本知识。

实验内容：
本次实验依据《Python程序设计》的内容，具体实验内容分为五个部分：
一、类的定义
1. 编写类、属性、方法来模拟一个商品，然后实例化一个对象并调用方法，查看结果；
2. 使用类创建至少三种不同动物类并实例化，直接调用它们的方法，查看输出；
二、实例属性
1. 使用类和实例定义一个人类来模拟一个人，然后调用实例方法，查看结果；
2. 为实例属性设置getter和setter方法，查看是否可以获取和设置实例属性；
三、构造函数
1. 使用类的构造函数创建几个实例，检查构造函数执行的命令是否正确；
2. 在构造函数中增加参数来隐藏实例属性，检查实例属性是否被正确隐藏。

四、多态
1. 使用多态和继承来模拟猫与狗，查看调用多态后的对象；
2. 依据实验要求，使用多态机制和函数结合的方式进行多种计算，输出结果。

五、类与函数
1. 使用print()函数输出实例的相关属性信息，检查程序的输出结果是否符合要求；
2. 使用私有方法来获得两个实例的属性值并返回，检查结果是否正确。

实验心得：
通过本次实验，我学会了面向对象程序设计的基本思想，对Python程序设计有了更深入的理解，同时也提升了自己的编程实践能力。

安徽机电职业技术学院实验报告一、实验目的1、进一步掌握类和对象的基本概念，掌握类字段和属性的使用；2、掌握类的索引器的用途和使用；3、了解类的静态成员用其作用；4、掌握使用类来构造应用程序。

二、实验内容使用Visual Studio .NET 2005，完成以下程序：程序1、完成“使用索引器”的课堂示例(CSharp示例\第5课\Country)；程序2、“使用类的静态成员”的课堂练习(CSharp示例\第5课\Static)；程序3、使用贷款类完成“贷款计算器” (CSharp示例\第5课\Loan)；三、实验步骤1、将服务器上“面向对象”课件的文件夹中的“Csharp示例\第5课\ Country”文件夹复制到本地磁盘上。

打开其中的“Country.sln”，完成其中的2个任务。

将这两个任务的代码写在下面。

// TODO 1: 完成下面的索引器，该索引器可以返回peoples数组中index下标的人口数量public double this[int index]{get{return this.peoples[index];}// TODO 2: 书写第2个索引器，该索引器接收一个字符串格式的国家名称，可以返回对应的peoples数组中的国家人口数量public class CountryPeoples{private string[] country = { "中国", "美国", "法国", "日本", "韩国", "印度" };private double[] peoples = { 1.306e+10, 2.5e+9, 6.09e+8, 1.274e+9, 4.829e+8,1.027e+10 };public double this[string index]{get{int i=0;foreach (string c in country ){if ( c ==index ) break;i++;}if (i>=peoples.Length) return 2;else return peoples[i];}}}}CountryPeoples c1 = new CountryPeoples();Output("韩国的人口数量是：" + c1["韩国"]);Output("法国的人口数量是：" + c1["法国"]);Output("美国的人口数量是：" + c1["美国"]);Output("日本的人口数量是：" + c1["日本"]);Output("印度的人口数量是：" + c1["印度"]);2、将服务器上“面向对象”课件的文件夹中的“Csharp示例\第5课\Static”文件夹复制到本地磁盘上。

实验报告题目类定义与类的继承姓名学号B09050124时间2011.04.12 地点实验B楼1．实验内容要求定义Student类和Graduate类，Graduate类从Student类派生。

2．实验要求(1) 设计一个学生类，学生类包括私有访问类型的学号、姓名、性别、成绩等数据成员和设置成绩、求总成绩、平均成绩、构造函数等方法成员。

(2)设计一个研究生类，添加导师数据成员，研究生类从学生类派生；(3)写出测试代码。

3．试验步骤源代码：public class StudentClass {public static void main(String args[]){Student st1 = new Student();Student st2 = new Student("b09050429","sjc","man",(byte)60,(byte)80,(byte)80);Student st3 = new Student(st2);Graduate gst = new Graduate();System.out.println("st1:");st1.print();System.out.println("st2:");st2.print();System.out.println("st3:");st3.print();System.out.println("修改成绩后：");st3.SetScore((byte)60,(byte)60,(byte)60);st3.print();System.out.println("Graduate:");gst.print();System.out.println("修改成绩后：");gst.SetScore((byte)100,(byte)100,(byte)100);gst.print();}}class Student{ //学生类String no;String name;String sex;byte chinese;byte math;byte java;Student(){ //默认构造函数no = "00";name = "000";sex = "man";chinese = (byte)20;math = (byte)20;java = (byte)20;}Student(String no,String name,String sex,byte chinese,byte math,byte java){this.no = no; = name;this.sex = sex;this.chinese = chinese;this.math = math;this.java = java;}Student(Student st){ //拷贝构造函数this(st.no,,st.sex,st.chinese,st.math,st.java);}void SetScore(byte ch,byte ma,byte ja){ //设置成绩chinese = ch;math = ma;java = ja;}short GetTotalScore(){ //得到总成绩return (short)(chinese+math+java);}float GetAverageScore(){ //得到平均成绩return (float)(GetTotalScore()/3.0);}void print(){ //显示学生信息System.out.println("学生信息: "+" 学号:"+no+" 姓名:"+name+" 性别:"+sex);System.out.println("成绩: "+"语文 "+chinese+" 数学:"+math+" Java:"+java);System.out.print("\n");}}class Graduate extends Student{String supervisor;Graduate() {super("钱森","nb74110","Man",(byte)99,(byte)99,(byte)99);supervisor="爱因斯坦";}}实验结果：st1:学生信息: 学号:00 姓名:000 性别:man成绩: 语文 20 数学:20 Java:20st2:学生信息: 学号:b09050410 姓名:zjl 性别:man成绩: 语文 60 数学:80 Java:80st3:学生信息: 学号:b09050429 姓名:zjl性别:man成绩: 语文 60 数学:80 Java:80修改成绩后：学生信息: 学号:b09050429 姓名:zjl 性别:man成绩: 语文 60 数学:60 Java:60Graduate:学生信息: 学号:钱森姓名:nb74110 性别:Man成绩: 语文 99 数学:99 Java:99修改成绩后：学生信息: 学号:钱森姓名:nb74110 性别:Man成绩: 语文 100 数学:100 Java:100。

实验五.类和对象（综合）一、实验目的1．熟悉和掌握如何声明类、创建类的实例。

2. 熟悉和掌握类的成员对象的修饰符的使用。

3. 熟悉和掌握类的构造函数的使用方法二、实验内容1.定义一个描述长方体的类Box，类中有三个private的整型成员变量：length、width和height，分别表示长方体的长、宽和高。

定义构造函数，初始化这三个变量；定义方法求长方体的体积并返回整型结果；定义方法求长方体的表面积并返回整型结果；定义方法把长方体的体积和表面积转化为字符串并返回字符串。

2. 编写一个类实现银行帐户（BankAccount）的概念。

银行帐户的属性有“帐号”、“储户姓名”、“储户身份证号”、“日期”、“金额”、“存款余额”、“累计余额”。

银行帐户的方法有“存款”、“取款”、“查询”。

（1）阅读下面程序，注意其中成员变量声明为private，成员方法声明为public，从中体会封装的意义。

（2）读懂程序，理解其中成员变量和方法的作用，将横线处的程序补充完整，并编译运行成功。

（3）将语句“private int Ac_sum=0;//累计余额”改为“private static int Ac_sum=0;//累计余额”，调试并运行，观察输出结果，说明为什么会得到这种结果？static的作用是什么？//BankAccount.javaimport java.util.*;class Account{final int Max=5;//操作的次数private int top;//储户帐目管理的指针private int Ac_id;//帐号private String Ac_name;//储户姓名private long Ac_card;//储户身份证号private String Ac_date[]=new String[Max];//日期private int Ac_money[]=new int[Max];//金额private int Ac_rest[]=new int[Max];//余额private int Ac_sum=0;//累计余额public Account()//构造函数，设置各参数{top=0;//储户帐目管理的指针Ac_id=0;//帐号Ac_name="";//储户姓名Ac_card=0;//储户身份证号}void Ac_in(String Ac_name,String aAc_date,int aAc_money)//存款方法{Ac_date[top]=aAc_date;Ac_money[top]=aAc_money;Ac_sum=Ac_sum+_____①____;Ac_rest[top]=Ac_sum;System.out.println("储户姓名 "+Ac_name+" 日期 "+Ac_date[top]+" 存入 "+Ac_money[top]+" 存款余额 "+Ac_rest[top]);top++;}void Ac_out(String Ac_name,String aAc_date,int aAc_money)//取款方法{Ac_date[top]=aAc_date;Ac_money[top]=-aAc_money;Ac_sum=Ac_sum-aAc_money;Ac_rest[top]=___②____;System.out.println("储户姓名 "+Ac_name+" 日期 "+Ac_date[top]+" 取出 "+(-Ac_money[top])+" 存款余额 "+Ac_rest[top]);______③_______;}void Ac_ask(String Ac_name,String aAc_date) //定义查询的方法{Ac_date[top]=aAc_date;Ac_money[top]=0;Ac_rest[top]=____④_____;System.out.println("储户姓名 "+Ac_name+" 日期 "+Ac_date[top]+" 查询存款余额 "+Ac_rest[top]);top++;}}public class BankAccount{public static void main(String args[]){//利用实例，调用储蓄用户___________⑤___________;zhang.Ac_in("张良","2008.6.6",3000);zhang.Ac_out("张良","2008.6.8",2000);zhang.Ac_in("张良","2008.7.4",3000);zhang.Ac_in("张良","2008.7.26",1500);zhang.Ac_ask("张良","2008.8.6");System.out.println();____________⑥____________;li.Ac_in("李岩","2008.8.16",3000);li.Ac_in("李岩","2008.8.28",2000);li.Ac_in("李岩","2008.9.17",3000);li.Ac_out("李岩","2008.9.21",1500);li.Ac_ask("李岩","2008.9.25");}}。

实验五抽象类、接口与包一、实验目的1、熟练掌握抽象类abstract的概念。

2、熟练掌握接口interface的概念。

3、熟练包package的概念以及编译运行的方法。

4、熟练掌握内部类inner class的概念。

5、熟练掌握递归的概念。

6、理解面向对象的程序设计方法。

二、实验内容与要求1．编写求解几何图形（如三角形，矩型，圆，多边型）的周长、面积的应用程序，要求用到继承、多态、抽象类、接口、内部类等面向对象程序设计技术的特点。

2、重写上面的程序，要求三角形，矩型，圆，多边型的类放到不同的包中，用包的技术组织程序的设计。

同时要求程序能从键盘上接受数据以便求解不同的几何图形的周长面积。

提示：从键盘上输入双精度数的一种方法(程序片段)……public static void main(String args[]) throws IOException{BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));String x;x=keyin.readLine();double a=Double.parseDouble(x);……３．练习ng.Class类的使用，通过一个对象返回一个Class对象，如何获取一个类的名称，如何使用class生成一个类的对象。

获取类的描述信息。

4、编写一个应用程序，实现以下功能：①声明一个接口(Calculability)，接口中包含一个方法area()。

②声明一个三角形类继承该接口，类名为Triangle，类中包含两个变量、一个带参数的构造方法和一个计算三角形面积的方法：三角形的底边长w三角形的高h构造方法Triangle(double width,double height)。

计算三角形面积的方法area()，该方法覆盖接口(Calculability)的同名方法，计算三角形的面积（w*h/2）。

抽象类的使用实验报告计算机0903班胡笑梅学号：********抽象类的使用一、实验目的（1）.在Visual C++6.0的开发环境下定义抽象类，并进一步派生最终形成一个类族。

二、实验任务使用Visual C++建立标准C++程序。

编写一个程序计算正方形、球体和圆柱体的表面积和体积。

三、实验步骤1.启动Visual C++6.0开发环境。

从“开始”菜单里选择“程序”|Microsoft Visual Studio 6.0 | Microsoft Visual C++ 6.0 ，显示Visual C++ 6.0开发环境主窗口。

2.创建一个项目。

单击File菜单中的New选项，进行新建。

选择Win32控制台应用程序。

在文本框里输入项目名称“lab1”，单击ok按钮。

3.建立C++源程序文件。

4.编辑C++源程序文件内容。

5.程序源代码为：#include<iostream>using namespace std;class CCt //定义抽象类CContaineer{protected:float radius; //公共的数据成员radiusdouble area,volume; //表面积area,体积volumepublic：virtual void Area()=0; //求表面积的纯虚函数virtual void V olume()=0; //求体积的纯虚函数CCt(float a,double b,double c) {radius=a;area=b;volume=c;} //基类的构造函数};class Square:public CCt //派生类Square{public:Square(float a,double b,double c): CCt (a,b,c) { }void Area() //虚函数Area() {area=6*radius*radius;cout<<"Square's area="<<area<<endl;}void V olume() //虚函数V olume (){volume=radius*radius*radius;cout<<" Square's volume="<<volume<<endl;}};class circle:public CCt //派生类circle{public:circle(float a,double b,double c): CCt (a,b,c){} //派生类circle构造函数void Area(){area=4*3.14*radius*radius;cout<<"circle's area="<<area<<endl;}void V olume(){volume=3.14*radius*radius*radius*4/3;cout<<" circle's volume="<<volume<<endl;}};class CCtlinder:public CCt//派生类CCtlinder{float high;public:CCtlinder(float h,float r,double a,double v): CCt (r,a,v) {high=h;}void Area() //派生类CCtlinder的虚函数定义{area=2*3.14*radius*radius+2*3.14*radius*high;cout<<" CCt linder's area="<<area<<endl;}void V olume(){volume=3.14*radius*radius*high;cout<<" CCt 's volume="<<volume<<endl;}};void Areafun(CCt *p)//根据p所指向的对象不同，调用不同的派生类Area{p->Area();}void V olumefun(CCt *p) //根据p所指向的对象不同，调用不同的派生类V olume{p->V olume();}void main(){Square r1(5,0,0);// Square的对象r1circle c1(8,0,0); // circle的对象c1CCtlinder cc2(2,14,0,0); // CCt linde的对象cc2Areafun(&r1);//调用的将是派生类Square的Area虚函数V olumefun(&r1);// 调用的将是派生类Square的V olume虚函数Areafun(&c1);V olumefun(&c1);Areafun(&cc2);V olumefun(&cc2);}6.程序运行结果四、实验总结通过实验进一步熟练的使用VC。

一、摘要随着Java编程语言的广泛应用，类与类之间的关系成为程序设计中一个重要的概念。

本实验旨在通过实际操作，探究Java中类与类之间的各种关系，包括继承、组合和聚合等。

通过实验，加深对面向对象编程思想的理解，提高编程能力。

二、实验目的1. 掌握Java中类与类之间关系的概念。

2. 了解继承、组合和聚合等类关系的特点。

3. 学会使用类关系实现实际编程问题。

三、实验原理在Java中，类与类之间的关系主要有以下几种：1. 继承：子类继承父类的属性和方法，使得子类具有父类的功能，并在此基础上进行扩展。

2. 组合：一个类包含另一个类的对象，组合关系体现为“整体与部分”的关系。

3. 聚合：与组合类似，但部分类可以独立存在，聚合关系体现为“整体与部分”的松散关系。

四、实验步骤1. 创建父类：定义一个名为“Animal”的父类，包含属性“name”和“age”，以及方法“eat()”和“sleep()”。

```javapublic class Animal {private String name;private int age;public Animal(String name, int age) { = name;this.age = age;}public void eat() {System.out.println(name + " is eating.");}public void sleep() {System.out.println(name + " is sleeping.");}}```2. 创建子类：定义一个名为“Dog”的子类，继承自“Animal”类，并添加一个方法“wang()”。

```javapublic class Dog extends Animal {public Dog(String name, int age) {super(name, age);}public void wang() {System.out.println(name + " is barking.");}}```3. 创建组合关系：定义一个名为“Person”的类，包含一个“Dog”类型的对象。

实验五类的关系
一、实验目的
1．理解类间关系的基本概念；
2. 掌握描绘类间关系的方法；
3. 掌握在Rational Rose中绘制类关系的操作方法。

二、实验器材
1. 计算机一台；
2. Rational Rose 工具软件；
三、实验内容
通过对前面内容的学习，使我们完成了学院图书馆的管理系统的需求分析，并从业务对象中抽象出了类。

我们知道类通常是不会单独存在，而是由关联、泛化、依赖等关系相互协作来静态描述业务系的。

因此，我们在找出系统中所存在的类的前提下，需要进一步对业务对象间如何联系进行建模。

现指派你运用本节所学的相关知识，完成如下任务：
1.对书籍管理功能中的类的关系建模。

四、实验步骤
1.分析：由前面章节对图书馆管理系统中的书籍管理业务分析和对该业务的抽象出来的类可知，图书馆的主要静态模型类图是由书籍管理类、书类、书目类、管理员类、用户类和各种界面操作类组成。

其中用户类与管理员类是泛化的关系，而其它类之间均是关联关系。

2.请在Rational Rose中绘制类间的关系。

（以下为参考内容。

）
父类
泛化
子类
五、实验报告要求1．整理实验结果。

2．小结实验心得体会。

实验六类与对象类是面向对彖程序设计中最棊木并H最重要的概念，也是面向对彖方法的第一个难点。

类是对逻辑上相关的函数与数据的封装，是对问题的抽象描述。

对象是类的实例化，是抽象的具体实现，类和对象的关系，是抽象与具体的关系，类概括出事物的木质特点，对象是对这些特点的具体体现。

实验目的和要求：1.掌握类和对象的使用。

2.掌握类的构造函数少析构函数。

3.掌握构造函数的重载。

4.了解拷贝构造两数的方法。

5.熟悉静态成员的使用和意义。

6.掌握友元的含义(友元函数、友元成员、友元类)。

7.掌握new和delete的使用。

实验内容：一、程序分析题1、写出以下程序的执行结果。

#include <iostream>using namespace std;class Tdcite{public:Tdate(){ Init(4,15,1995); }Tdate(int d){ lnit(4,d,1996); }Tdate(int m,int d){ Init(m,d,1997); }Tdate(int m,int d,int y){ Init(m,d,y); }protected:int month;int day;int year;void Init(int m,int djnt y){month=m; day=d; year=y;cout «month «H/M «day «,7M «year «endl;}};int main(){Tdate aday;Tdate bday(10);Tdate cday(2,12);Tdate dday( 1,2,1998);return 0;2、写出以下程序的执行结果。

#include <iostrcam> using namespace std;class MyClassf public:MyClass();MyClass(int);〜MyClass();void DisplayO;protected:int number;};MyClass::MyClass(){number =0;cout «n Constructing normallyAn*'; } MyClass::MyClass(int m):number(m){cout «n Constructing with a number: 4 5 6 7 8 9 10 11 «number «endl;}void MyClass::Display(){ cout «H Display a number: M «number «endl; } MyClass::〜MyClass(){ cout «H Destructing.\n n; }int main(){MyClass obj 1;MyClass obj2(20);objl.Display();obj2.Display();return 0;}3、写出以下程序的执行结果。

实验5 类和对象实验报告实验目的：1.进一步理解类和对象的概念；2.进一步理解类的成员的访问控制的含义，公有和私有成员的区别；3.掌握构造函数和析构函数的含义与作用、定义方式和实现；4.能够根据给定的要求定义类并实现类的成员函数；5.了解C++面向对象程序设计的基本思想、基本方法和基本步骤；6.掌握MS Visual C++6.0调试C++程序的基本方法、基本步骤。

实验内容：一、输入下列程序，按要求进行实验，并记录实验的结果#include <iostream>using namespace std;class Coordinate{public:Coordinate(int x1, int y1){x=x1; y=y1;}Coordinate(Coordinate &p);~Coordinate(){cout<<"Destructor is called."<<endl;}int getx(){return x;}int gety(){return y;}private:int x, y;};Coordinate::Coordinate(Coordinate &p){x=p.x; y=p.y;cout<<"Copy initianization constructor is called."<<endl;}int main(){Coordinate p1(3,4);Coordinate p2(p1);Coordinate p3=p2;cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")"<<endl;return 0;}1）运行结果2）将Coordinate类中带有两个参数的构造函数进行修改，在函数体内增加如下语句：cout<<”Constructor is called.”<<endl;运行结果：3）error C2512: 'Coordinate' : no appropriate default constructor available error C2664: '__thiscall Coordinate::Coordinate(class Coordinate &)' : cannot convert parameter 1 from 'const int' to 'class Coordinate &'A reference that is not to 'const' cannot be bound to a non-lvalue修改：#include <iostream>using namespace std;class Coordinate{public:Coordinate(int x1, int y1){x=x1; y=y1;}Coordinate(Coordinate &p);Coordinate（）；Coordinate（int i）；~Coordinate(){cout<<"Destructor is called."<<endl;}int getx(){return x;}int gety(){return y;}private:int x, y;};Coordinate::Coordinate(Coordinate &p){x=p.x; y=p.y;cout<<"Copy initianization constructor is called."<<endl;}int main(){Coordinate p1(3,4);Coordinate p2(p1);Coordinate p5（2）；Coordinate p3=p2;cout<<"p3=("<<p3.getx()<<","<<p3.gety()<<")"<<endl;return 0;}4）创建不同对象并调用的时候，必须满足构造函数的参数要求，如果构造函数是需要传递值，对象就该传递值。

一、实验目的1. 理解面向对象编程的基本概念，包括类、对象、继承、封装和多态。

2. 掌握类的设计方法，能够根据需求设计出合适的类结构。

3. 通过实验加深对面向对象编程的理解，提高编程能力。

二、实验环境1. 开发工具：Java开发环境（如Eclipse、IntelliJ IDEA等）2. 操作系统：Windows 10、macOS、Linux等3. 编程语言：Java三、实验内容1. 类的基本概念2. 类的设计方法3. 类的继承与多态4. 类的封装5. 实验案例分析四、实验步骤1. 类的基本概念（1）定义一个名为“Person”的类，包含属性：姓名、年龄、性别。

（2）为“Person”类添加构造方法，用于初始化对象的属性。

（3）为“Person”类添加一个方法，用于输出对象的属性。

2. 类的设计方法（1）定义一个名为“Student”的类，继承自“Person”类。

（2）在“Student”类中添加属性：学号、班级。

（3）为“Student”类添加构造方法，用于初始化对象的属性。

（4）为“Student”类添加一个方法，用于输出对象的属性。

3. 类的继承与多态（1）定义一个名为“Teacher”的类，继承自“Person”类。

（2）在“Teacher”类中添加属性：职称、教学经验。

（3）为“Teacher”类添加构造方法，用于初始化对象的属性。

（4）为“Teacher”类添加一个方法，用于输出对象的属性。

（5）定义一个方法，用于接收一个“Person”类型的参数，并调用其输出属性的方法。

4. 类的封装（1）将“Person”类的属性设置为私有（private）。

（2）为“Person”类的每个属性添加对应的getter和setter方法。

5. 实验案例分析（1）定义一个名为“School”的类，包含以下属性：校长、教师列表、学生列表。

（2）为“School”类添加方法，用于添加教师和学生。

（3）为“School”类添加方法，用于输出所有教师和学生的信息。