下载文档原格式
实验四类的继承与多态一、实验目的1.理解类的继承概念和类的继承规则。
根据实际需要正确的运用类的继承。
2.理解类的多态概念，掌握子类对父类方法的重新定义，理解方法的匹配调用原则。
二、实验内容1.模拟编写程序，理解类的继承、多态、继承和多态规则。
2. 独立编程，实现类的继承和多态。
三、实验过程（一）继承（1）模拟编写程序，理解类的继承，继承规则。
请编码实现动物世界的继承关系：（1）动物（Animal）具有行为：吃（eat）、睡觉（sleep）。
（2）动物包括：兔子（Rabbit），老虎（Tiger）。
（3）这些动物吃的行为各不相同（兔子吃草，老虎吃肉）；但睡觉的行为是一致的。
请通过继承实现以上需求，并编写测试类AnimalTest进行测试。
1. 定义Animal类，代码如下：public class Animal {public void sleep(){System.out.println("我正睡觉呢！");}public void eat(){}}2. 定义Tiger类，代码如下：public class Tiger extends Animal {public void eat(){System.out.println("我喜欢吃肉！");}}3. 定义Rabbit类，代码如下：public class Rabbit extends Animal {public void eat(){System.out.println("我喜欢吃草和青菜！"); }}4、定义AnimalTest类，代码如下：public class AnimalTest {public static void main(String[] args) {Tiger tiger = new Tiger();tiger.sleep();tiger.eat();System.out.println();Rabbit rabbit = new Rabbit();rabbit.sleep();rabbit.eat();}}5. 编译运行程序，查看运行结果。
类的继承与多态性实验报告类的继承与多态性实验报告目录1.介绍2.什么是多态3.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性，现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。
多态的基础是继承（包括了接口的实现）和方法的覆盖。
什么是多态多态对应的英文单词是polymorphism ，百度翻译给出的翻译是：n.多型现象，多态性；多机组合形式;按字面意思就是多种状态、形态、姿态等等，潜台词就是某个东西具有多种状态、形态、姿态等等。
那是什么东西呢？在面向对象的编程语言里面（当然就包括Java 了）就是某个方法或函数。
那方法的多种状态、形态、姿态有是个什么意思呢？这其实是指同一个方法具有多个方法体，就是方法的实现。
而方法的相同与否是由方法签名决定的。
所以，多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。
状态、形态、姿态指的就是行为特征。
多态在Java中的技术基础然而，在Java中，同一个类里面是不可能存在两个签名相同而实现不同的方法的，否则的话会导致无法判断该执行哪个方法，因此在编译时就会报错。
所以，肯定是在两个类中才有可能存在两个签名相同而实现不同的方法，一个实现在这个类，另一个实现在另一个类。
而如果这两个类毫无瓜葛，那么肯定就与多态的本质（同一个类的同一个方法却具有不同的行为特征）自相矛盾了。
所以，这两个类肯定是有某种联系的。
我们再想想，什么概念是能够让两个不同的类却又能称为同一个类的? 答案就是类的继承/扩展，就是现实中的“某东西是某类东西”的概念，就是“具体和抽象”的思想。
比如，男人是人，女人也是人，男人类和女人类就借助于人类建立了某种联系，而人类具有的某个行为在男人类和女人类中是有着不同体现的，比如人类的吃饭这个行为，男人类的体现是狼吞虎咽，女人类的体现是细嚼慢咽。
例子不是很恰当，但意思就是这么个意思。
所以说，Java里面多态的技术基础就是方法的覆盖，当然，在Java中覆盖不仅仅发生在类的继承/扩展上，还可能发生在接口的实现上。
Python继承和多态的概念和实现继承和多态是面向对象编程中的两个重要概念，在Python中也得到了充分的支持和应用。
本文将介绍Python中继承和多态的概念，并通过相应的代码示例来展示其实现方法。
一、继承的概念和实现继承是指一个类（称为子类或派生类）从另一个类（称为父类或基类）中继承属性和方法的过程。
子类可以继承父类的属性和方法，并可以添加自己特有的属性和方法。
在Python中，继承可以通过在定义一个类时，在类名后使用圆括号指定父类的名称来实现。
具体的语法如下：```pythonclass 父类名:# 父类的属性和方法的定义class 子类名(父类名):# 子类的属性和方法的定义```在一个类继承自父类后，它就拥有了父类的所有属性和方法。
子类可以直接访问父类的属性和方法，并且可以在子类中调用父类的方法。
下面是一个简单的示例，演示了继承的概念和实现方法：```pythonclass Animal:def __init__(self, name): = namedef speak(self):print("动物发出声音")class Dog(Animal):def speak(self):print("汪汪汪")animal = Animal("动物")animal.speak() # 输出：动物发出声音dog = Dog("狗")dog.speak() # 输出：汪汪汪```在上面的示例中，Animal类是一个父类，它有一个speak方法，输出"动物发出声音"。
Dog类是Animal类的子类，它复写了speak方法，并输出"汪汪汪"。
最后通过实例化Dog类的对象dog，并调用speak方法，输出"汪汪汪"。
二、多态的概念和实现多态是指一个对象可以根据当前所处的环境采取不同的行为。
实验五类的继承与多态一、实验题目类的继承与多态二、实验目的与要求1．掌握类的继承2．掌握成员变量的隐藏和方法的覆盖3．掌握方法的重载三、实验内容与步骤1．定义一个Person类，它包括的属性有“姓名”和“性别”，为Person类派生出一个字类Student类，为Student子类添加两个属性年龄和成绩等级（用A, B, C, D, E表示），在子类中打印出学生的姓名、性别、年龄及成绩等级。
class Person{。
// 定义两个受保护字符串变量name, sexPerson(String pname, String psex){.。
// 对成员变量进行赋值初始化}public String toString(){String s=new String();s=name+””+sex;return s;}}。
{ // 类Student 继承Person类protected int age;protected char grade;Student(String sname, String ssex, int sage, char sgrade){。
// 调用父类的构造方法，并将name, sex的值传递给构造方法。
// 对age, grade两个成员变量初始化}void print(){ // 通过调用父类的toString方法，打印出String s;。
// 调用父类的方法toStirng()，并将返回值赋给变量ss=s+”“+age+”“+grade;。
// 打印出s变量}}public class TestP{public static void main(String args[ ]){。
//分别创建两个类Student的实例对象，对两个对象的成员变量通过调用构造方法进行初始化。
// 打印出”姓名性别年龄成绩等级”。
// 使用两个对象调用方法print，打印出运行结果的后两行}}运行结果姓名性别年龄成绩等级张飞男23 E刘杨男25 A思考题：1、将父类Person中的成员变量name声明为private，编译时观察有哪几处错误？2、在程序一中的子类Student中添加语句：String name,sex;（对父类中的同名变量name,sex 进行了重新定义）观察运行结果有什么不同？为什么？这种现象称为什么？3、在程序一中在子类Student中添加成员方法：public String toString(){return "子类"+name+sex+age+grade;}（对父类中的同名方法进行重新定义）观察运行结果有什么不同？为什么？这种现象称为什么？2．定义一个Rectangle类代表矩形，其中包含计算面积的方法。
实验五Java语言面向对象基础-继承与多态实验目的通过编程和上机实验理解Java语言是如何体现面向对象编程基本思想，了解类的封装方法，以及如何创建类和对象，了解成员变量和成员方法的特性，掌握面向对象程序设计的方法，了解类的继承性和多态性的作用，了解接口的作用。
实验要求1、编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序；2、编写体现类的多态性（成员方法重载、构造方法重载）的程序；3、编写体现接口功能的程序。
实验内容1、类的继承性练习新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。
所以，通常要对子类进行扩展，即添加新的属性和方法。
这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。
继承的意义就在于此。
6.1、创建将被继承的类(1) 程序源代码如下。
public class EXP3_7{protected String xm; //具有保护修饰符的成员变量protected int xh;void setdata(String m,int h) //设置数据的方法{xm =m;xh = h;}public void print() //输出数据的方法{System.out.println(xm+", "+xh);}}(2) 编译源程序。
6.2、创建将被继承的类(1) 程序功能：通过EXP3_7类产生子类EXP3_8，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、xi（系）。
在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。
(2) 程序源代码如下。
class EXP3_8 extends EXP3_7{protected String xy;protected String xi;public static void main(String args[]){EXP3_7 p1 = new EXP3_7();p1.setdata("李四",12321) ;p1.print();EXP3_8 s1 = new EXP3_8() ;s1.setdata("张三",12345); //调用父类的成员方法s1.xy="成都信息工程学院"; //访问本类的成员变量s1.xi="计算机系"; //访问本类的成员变量s1.print();System.out.print(s1.xm+", "+s1.xy+", "+s1.xi);}}(1)编译并运行，结果如图3.7所示。
图 3.76.3、了解成员方法的覆盖方式通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。
方法覆盖为子类提供了修改父类成员方法的能力。
例如，子类可以修改层层继承下来的Object 根类的toString 方法，让它输出一些更有用的信息。
下面的程序显示了在子类Circle 中添加toString 方法，用来返回圆半径和圆面积信息。
(1)编写覆盖Object 类toString方法的程序文件EXP3_9.java，源代码如下。
class Circle {private int radius;Circle(int r) {setRadius(r);}public void setRadius(int r) {radius=r;}public int getRadius() {return radius;}public double area() {return 3.14159*radius*radius;}public String toString() {return "圆半径："+getRadius()+" 圆面积："+area();}}public class EXP3_9{public static void main(String args[]) {Circle c=new Circle(10);System.out.println("\n"+c.toString());}}(2)编译并运行，结果如图3.8所示。
图 3.86.1、this、super和super()的使用(1)程序功能：程序功能：说明this、super 和super()的用法。
程序首先定义Point（点）类，然后创建点的子类Line（线）。
最后通过LX3_10 类输出线段的长度。
程序中通过super(a,b)调用父类Point 的构造方法为父类的x 和y 赋值。
在子类Line 的setLine方法中，因为参数名和成员变量名相同，为给成员变量赋值，使用this 引用，告诉编译器是为当前类的成员变量赋值。
在length 和toString 方法中使用父类成员变量时，使用super 引用，告诉编译器使用的是父类的成员变量。
(2)程序源代码如下。
class Point {protected int x, y;Point(int a, int b) {setPoint(a, b);}public void setPoint(int a, int b) {x=a;y=b;}}class Line extends Point {protected int x, y;Line(int a, int b) {super(a, b);setLine(a, b);}public void setLine(int x, int y) {this.x=x+x;this.y=y+y;}public double length() {int x1=super.x, y1=super.y, x2=this.x, y2=this.y;return Math.sqrt((x2-x1) * (x2-x1) + (y2-y1) * (y2-y1));}public String toString() {return "直线端点：[" + super.x + "," + super.y + "] [" +x + "," + y + "] 直线长度：" + this.length();}}public class EXP3_10{public static void main(String args[]) {Line line=new Line(50, 50);System.out.println("\n"+line.toString());}}(3)编译并运行，结果如图3.9。
图 3.92、类的多态性练习类的继承发生在多个类之间，而类的多态只发生在同一个类上。
在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。
这种现象称为类的多态。
多态使程序简洁，为程序员带来很大便利。
在OOP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。
这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。
类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。
7.1、方法的重载(1) 程序功能：使用同名方法对两个、三个或用数组容纳的一组数进行排序(2) 程序源代码如下。
class IntSort {public String sort(int a, int b) {if (a>b)return a+" "+b;elsereturn b+" "+a;}public String sort(int a, int b, int c) {int swap;if (a<b) {swap=a;a=b;b=swap;}if (a<c) {swap=a;a=c;c=swap;}if (b<c) {swap=b;b=c;c=swap;}return a+" "+b+" "+c;}public String sort(int arr[]) {String s=" ";int swap;for (int i=0; i<arr.length; i++)for (int j=0; j<arr.length-1; j++)if (arr[j]>arr[j+1]) {swap=arr[j];arr[j]=arr[j+1];arr[j+1]=swap;}for (int i=0; i<arr.length; i++)s=s+arr[i]+" ";return s;}}public class EXP3_11 {public static void main(String[] args){IntSort s=new IntSort();int a=30, b=12, c=40;int arr[]={34,8,12,67,44,98,52,23,16,16};System.out.println("两个数的排序结果："+s.sort(a,b));System.out.println ("三个数的排序结果："+s.sort(a,b,c));System.out.println ("数组的排序结果："+s.sort(arr));}}(3) 编译并运行，结果如图3.10所示。
图 3.107.2、构造函数的重载构造方法的名称和类同名，没有返回类型。
尽管构造方法看起来和一般的成员方法没有差别，但它不是方法，也不是类的成员。
因此，构造方法不能直接调用，只能由new 操作符调用。
构造方法对于类是十分重要的，对象的初始化任务要靠构造方法来完成。
