实验04 类的继承与多态
第4章类的继承和多态
掌握supBiblioteka r、final关键字的使用4.1类的继承
类的继承是面向对象编程的三大特征之一，是一种由已有 的类创建新类的机制，也是实现软件复用的重要手段， 它允许创建分等级层次的类。 在Java术语中，被继承的类叫父类（parent class）或超类 （super class），继承父类的类叫子类（subclass）或 派生类（derived class）。 Java语言只支持单继承，不支持多继承。
实例4-2继承关系中子类构造方法的定义（以Person类和 Student类为例）。 实例4-3继承关系中构造方法的调用次序。
4．super关键字 在Java中，“super”关键字代表父类对象。在子类中通过使用super关 键字可以在子类构造方法中调用父类的构造方法，以便初始化从父 类继承过来的属性；也可以使用super做前缀来访问父类的属性或 方法。 （1）使用super调用父类的构造方法。 （2）使用super调用父类中的属性或方法 在子类中可以隐藏父类的成员变量。只要子类中定义的成员变量和父 类中的成员变量同名时，子类就隐藏了父类的同名成员变量，即当 子类对象或方法操作该同名成员变量时操作的是子类中定义的成员 变量。这时如果想访问父类的同名成员变量，就要通过“super” 关键字来访问。访问格式为：super.父类中的属性名; 子类能继承父类的非私有方法，也可以隐藏已继承的方法。子类通过 方法重写来隐藏父类的同名方法。
2.继承原则 （1）子类继承父类的所有成员变量和成员方法（构造方 法除外），但子类不能直接使用父类的私有变量和私有方 法。 （2）子类不能删除父类的成员，但是可以增加新成员或 者重定义父类的成员。
3．子类对象的实例化 构造方法用于初始化实例的内存空间。但由于Java规定： 父类的构造方法不能被子类继承，所以子类不能直接调用 父类的构造方法。那么如何构造子类实例呢？ 在Java中，父类和子类属性的初始化过程是各自完成的。 虽然子类不能继承父类的构造方法，但可以在子类的构造 方法中通过使用super关键字调用父类的构造方法，以便 初始化从父类继承的属性。
实验四 、类的继承与多态
实验四类的继承与多态一、实验目的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. 编译运行程序，查看运行结果。
实验4 类的继承和多态机制
3、覆盖表现为父类与子类之间方法的多态性；重载表现为同一个类中方法的多态性。
4、与实例方法一样，静态方法能够被继承，但是静态方法不能被重写。
5、如果父类和子类都定义了相同的静态方法，那么父类中的方法将会被隐藏。
已有一个交通工具类Vehicle，其中属性包括：速度speed、类别kind、颜色color；方法包括设置速度、设置类别、设置颜色、取得速度、取得类别、取得颜色。
设计一个小车类Car、一个公共汽车类Bus，继承自Vehicle，Car、Bus中增加了属性：座位数passenger，增加了设置和获取座位数的方法。
}
void setKind(String kind){
this.kind=kind;
}
void setColor(String color){
this.color=color;
}
public double getSpeed(){
return speed;
}
public String getKind(){
this.x =x;
this.y=y;
}
public int getX(){
return x;
}
public int getY(){
return y;
}
}
class Circle extends Point{
double r;
final double PI=3.1416;
public Circle(int x,int y,double m){
return kind;
}
public String getColor(){
实验04类的继承与多态
实验04类的继承与多态实验四类的继承与多态一、实验目的1.掌握构造方法和成员方法重载的应用。
2.理解类的继承性的作用3.领会面向对象编程的多态性。
二、实验内容与要求基本概念1．进一步理解继承的含义新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。
所以，通常要对子类进行扩展，即添加新的属性和方法。
这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。
继承的意义就在于此。
2．了解成员变量的隐藏方式所谓隐藏是指子类重新定义了父类中的同名变量，在子类L ine 中重新定义了x为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。
子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。
在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。
3．了解成员方法的覆盖方式（1）方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。
方法覆盖为子类提供了修改父类成员方法的能力。
4．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。
在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。
这种现象称为类的多态。
类的继承与多态性实验报告
类的继承与多态性实验报告类的继承与多态性实验报告目录1.介绍2.什么是多态3.多态在Java中的技术基础4.示例5.多态的好处6.总结介绍之前的文章介绍过类的封装性和继承性，现在是时候聊聊面向对象编程的三大特性之一的最后一个类的多态性了。
多态的基础是继承（包括了接口的实现）和方法的覆盖。
什么是多态多态对应的英文单词是polymorphism ，百度翻译给出的翻译是：n.多型现象，多态性；多机组合形式;按字面意思就是多种状态、形态、姿态等等，潜台词就是某个东西具有多种状态、形态、姿态等等。
那是什么东西呢？在面向对象的编程语言里面（当然就包括Java 了）就是某个方法或函数。
那方法的多种状态、形态、姿态有是个什么意思呢？这其实是指同一个方法具有多个方法体，就是方法的实现。
而方法的相同与否是由方法签名决定的。
所以，多态其实本质上是指同一个类的同一个方法却具有不同的行为特征。
状态、形态、姿态指的就是行为特征。
多态在Java中的技术基础然而，在Java中，同一个类里面是不可能存在两个签名相同而实现不同的方法的，否则的话会导致无法判断该执行哪个方法，因此在编译时就会报错。
所以，肯定是在两个类中才有可能存在两个签名相同而实现不同的方法，一个实现在这个类，另一个实现在另一个类。
而如果这两个类毫无瓜葛，那么肯定就与多态的本质（同一个类的同一个方法却具有不同的行为特征）自相矛盾了。
所以，这两个类肯定是有某种联系的。
我们再想想，什么概念是能够让两个不同的类却又能称为同一个类的? 答案就是类的继承/扩展，就是现实中的“某东西是某类东西”的概念，就是“具体和抽象”的思想。
比如，男人是人，女人也是人，男人类和女人类就借助于人类建立了某种联系，而人类具有的某个行为在男人类和女人类中是有着不同体现的，比如人类的吃饭这个行为，男人类的体现是狼吞虎咽，女人类的体现是细嚼慢咽。
例子不是很恰当，但意思就是这么个意思。
所以说，Java里面多态的技术基础就是方法的覆盖，当然，在Java中覆盖不仅仅发生在类的继承/扩展上，还可能发生在接口的实现上。
实验4 继承性和多态
实验四继承性和多态一、实验目的：熟悉JA V A中的继承性和多态性。
掌握子类的定义及用法，继承机制中的隐藏与覆盖。
子类的构造方法的用法，对象的上转型对象，抽象类与抽象方法等。
二、实验要求：1．根据下面的要求，编写Java应用程序实现：编写程序模拟中国人、美国人是人、北京人是中国人。
除主类外，程序中还有4个类：People、ChinaPeople、AmericanPeople和BeijingPeople类。
要求如下：●People类有权限是protected的double型成员变量height和weight，以及public voidspeakHello()、public void averageHeight()和public void averageWeight()方法。
●ChinaPeople类是People的子类，新增了public void chinaGongfu()方法。
要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
●AmericanPeople类是People的子类，新增public void americanBoxing()方法。
要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
●BeijingPeople类是ChinaPeople的子类，新增public void beijingOpera()方法。
要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()和public void averageWeight()方法。
C++实验四继承多态
{
public:
Circle(double r):radius(r){} //结构函数
virtual double area() const
{return 3.14159*radius*radius;}; //定义虚函数
protected:
double radius; //半径
（4）在类体中声明成员函数，在类外定义成员函数。
（5）在派生类Teacher_Cadre的成员函数show中调用Teacher类中的display函数，输出姓名、年龄、性别、职称、地址、电话，然后再用cout语句输出职务与工资。
5.实验任务五
事先编写好程序，上机调试和运行程序，分析结果。
（1）声明Point（点）类，由Point类派生出Circle（圆）类，再由Circle类派生出Cylinder（圆柱体）类。将类的定义部分分别作为3个头文件，对它们的成员函数的声明部分分别作为3个源文件（.cpp文件），在主函数中用#include命令把它们包含进来，形成一个完整的程序，并上机运行；
#define PI 3.1415926
using namespace std;
class Point //定义坐标点类
{public:
Point(){x=0;y=0;}
~Point();
Point(double x0,double y0) {x=x0; y=y0;}
double setxy(double x0,double y0){x=x0; y=y0;}
void Student::display()
{cout<<"num:"<<num<<endl;
JAVA程序设计模块四---类的继承和多态
stu.setSchool("清华大学") ;//自己定义的方法
System.out.println("姓名：" + stu.getName()) ;
System.out.println("年龄：" + stu.getAge()) ;
System.out.println("学校：" + stu.getSchool()) ;
int sno;
String department;
}
public class TestStudent {
public static void main(String[] args) {
Student st=new Student();
="张三";
st.age=18;
st.sex='男';
StudentA obj2 =new StudentA("张三",18,1); //调用有参构造方法创建对象
obj1.pprint(); //调用父类的成员方法
obj1.sprint(); //调用子类的成员方法
obj2.pprint(); //调用父类的成员方法
obj2.sprint(); //调用子类的成员方法
class Student{
System.out.println("class:Person:"+" Name:"++" age:"+this.age);
}
}
class StudentA extends PersonA {
实验四 类的继承性和多态性
实验四类的继承性和多态性【开发语言及实现平台或实验环境】Windows2000 或XP，JDK1.6与Eclipse【实验目的】1.理解和掌握类的继承和多态2.理解父类和子类的转化。
【实验要求】1. 掌握类的继承法和多态。
2. 掌握父类和子类的转化。
【实验内容】一类的继承面向对象的中最为强大的功能是类的继承，继承允许你在一个已经存在的类之上编写新的程序。
比如想建立一个FillRect类，该类可以使用Rectangle类中所有已定义的数据和成员方法，如：width、height等数据和getArea等方法，就可以通过继承来实现。
为了继承Rectangle类，你必须引用旧的Rectangle类(使用extends关键字)，并且在新类的说明中引用它。
如：class FillRect extends Rectangle{…}1. VehicleDemo.java//类的继承class Vehicle{//车辆类int VehicleID; //性质：车辆的ID号void setID(int ID){VehicleID=ID;}void displayID( ) { //方法：显示ID号System.out.println("车辆的号码是："+ VehicleID);}}class Car extends Vehicle{ //轿车类int mph; //时速void setMph(int mph){this.mph=mph;}void displayMph( ) { //显示轿车的时速System.out.println("轿车的时速是："+ mph);}}public class VehicleDemo{public static void main(String[] args){//产生一个车辆对象Car benz = new Car();benz.setID(9527);benz.setMph(10);benz.displayID();benz.displayMph();}}2. 成员变量的隐藏和方法的重写子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为，例如：class A{int x;void setX(){x=0;}}class B extends A{int x; //隐藏了父类的变量xvoid setX(){ //重写了父类的方法 setX()x=5;}}3. 关键字super、Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。
JAVA实验四1
通过类的继承， 祖先类的所有成员均将成为子类拥有的“财富”。 但是能否通过子类对 象直接访问这些成员则取决于访问权限设置。Object 类是所有类的祖先。
4.2.2 构造方法与继承关系
构造方法不存在继承关系，子类中是如何给父类继承的属性赋初值呢？ 子类通过调用父类的构造方法给父类的属性赋值， 在子类的构造方法的第 1 行可以通过 super 去调用父类的构造方法，如果没有 super 调用，则默认调用父类的无参构造方法。所 以，在父类中编写构造方法通常均要提供无参构造方法。
实验 4 继承与多态 4.1 实验目的
(1) 理解类的继承，掌握变量隐藏、方法覆盖的概念。 (2）理解引用类型的变量的赋值转换原则。 (3）理解多态概念，掌握方法的匹配调用原则； (4）理解抽象类与接口的使用； (5）理解 this 和 super 的含义及使用。 (6）理解访问控制符的使用
4.2 知识要点
提高题
a=new
methodMatch ();
1） 分别下面程序中 x 的访问权限进行修改，测试访问许可。修改包括：private， protected，public 以及无访问控制符 4 种情形。 程序1：同一类情形（文件accessTest.java） package test class accessTest{
4.2.6 抽象类
定义形式： abstract class 类名称 { 成员变量； 方法（）{……} //定义一般方法
abstract 方法（）；//定义抽象方法 } 在抽象类中可以包含一般方法和抽象方法。 抽象类表示的是一个抽象概念，不能被实例化为对象。 继承抽象类的具体类必须将抽象类中抽象方法覆盖实现。
(2) 使用抽象类的引用变量可引用子类的对象； (3) 通过父类引用子类对象，通过该引用访问对象方法时实际用的是子类的方法。可 将所有对象存入到父类定义的数组中。 样例2：定义接口 Shape， 其中包括一个方法 size （） ,设计“直线”、 “圆”、 “会议”、 “圆柱体”等类实现 Shape 接口。分别创建一个“直线”、“圆”、“会议”、“圆柱体” 存入一个数组中，将数组中各类图形的大小输出。 注：圆柱体可考虑由底边圆和高度两个部分组成。 【参考程序】 interface Shape { double size(); } class Line implements Shape { private double x1,y1,x2,y2; public Line(double x1, double y1, double x2, double y2) { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; } public double size() {
Java实验报告(四)继承和多态
int index=BinarySearch(shape1,shape3);
System.out.println("\n【二分法查找】：");
if(index==0){
System.out.println("【对象】"+shape3.toString()+"不存在【圆形】数组中。");
}
else{
Shape[] shape2={new Rectangle(1.0,4.0),new Rectangle(7.0,3.0),new Rectangle(3.0,5.0),
new Rectangle(9.0,5.0),new Rectangle(5.0,4.0)};
Shape shape3=new Circle(2.0);
}
public double getRadius(){
return radius;
}
public void setRadius(double val){
this.radius=val;
}
public double getArea(){
return Math.PI*radius*radius;
}
public double getPerimeter(){
}
else{
return -1;
}
}
public int compareTo(Object o) {
if(this.getArea()>((Circle)o).getArea())
return 1;
else if(this.getArea()==((Circle)o).getArea())
实践四 类的继承和多态
实验四类的继承和多态一、实验目的1、深入了解面向对象的程序分析；2、熟悉掌握类的继承和多态；3、熟悉Java的编程规范；二、上机实验的问题和要求根据学过的面向对象的三大特性，封装、继承、多态。
设计一个测试类Test4：用于展示定义类的方法，需要定义带有main方法的测试类。
题目具体要求如下：设计题目：动物园（Test4 Class）一个动物园，里面有多种动物，各种动物在园中有相同的行为方法，也有各自独有的行为习惯。
至少设计三种动物类继承自Animal 类：猫：Cat。
独有行为：CatchMouse。
狗：Dog。
独有行为：WatchDoor。
老鼠：Mice。
独有行为：Stolen。
设计所有动物的父类Animal。
要求至少具有：重量：weight，速度：speed两种属性。
可以在初始化过程中对属性赋值。
至少两种行为：run()奔跑，eat()吃东西。
测试类要求：测试类中建立静态方法Create。
该方法可以创建任意一种动物，并将该种动物添加到静态动物列表animalList中。
测试类中main函数创建至少三种7只动物。
创建动物之后，要调用动物的共有行为eat()。
并调用各自动物的独有行为。
要求：请你根据上述系统需求，用Java语言设计这个动物园，发挥你的想象力吧！三、程序设计的基本思想，原理和算法描述四、源程序的编制过程：package neu.li.test41;import java.util.ArrayList;public class myTest41 {public static ArrayList<Animal> animalList= newArrayList<Animal>();public static void main(String[] args){addAnimal (new Cat());addAnimal (new Dog());addAnimal (new Mice());alleat();allplay();alleat();}public static void addAnimal(Animal a){ animalList.add(a);}public static void removeAnimal(int i){animalList.remove(i);}public static void alleat(){for(int i=0; i<animalList.size();i++){ animalList.get(i).eat();}System.out.println(" ");}public static void allplay(){ for(int i=0; i<animalList.size();i++){Animal tmpAnimal= animalList.get(i);if(tmpAnimal instanceof Cat){((Cat) tmpAnimal).catchMouse();killMice();}//animalList.get(i).eat();if(tmpAnimal instanceof Dog){((Dog) tmpAnimal).watchdoor();}if(tmpAnimal instanceof Mice){((Mice) tmpAnimal).stolencake();}}System.out.println(" ");}public static void killMice(){for(int i=0; i<animalList.size();i++){Animal tmpAnimal=animalList.get(i);if(tmpAnimal instanceof Mice){ removeAnimal(i);break;}}}}。
(4) 实验四 继承与多态
Java语言使用extends关键字在两个类之间建立这种类似与父子血缘关系的“继承”关系：在定义类时，使用extends来指明它的父类。
值得注意的是，Java中的继承只能是单继承即单根继承。
语法格式：
class SubClass extens SuperClass{//只能有一个父类
……
System.out.pri!~”);
}
public void fB(){
System.out.println(“method fB() from class B!”);
fA();
System.out.println(“x is”+ x);
}
}
public class Test{
2）什么时候需要使用super语句来显式调用父类构造？
（二）多态
多态是面向对象编程的重要技巧，它也是面向对象的重要特征之一。多态的本意是“同一个操作，不同的行为”，也就是使用同一个方法名，运行的实际是不同的方法。在Java语言中，多态主要通过方法的重载（Overloading）和重写（Overriding）实现。
public static void main(String[] args){
B b;
System.out.println(“====类已加载完毕=====”);
b = new B(10);
b.fB();
}
}
问题：
1）请结合运行结果分析Java中创建对象过程。(分析类的不同区域的运行前后次序，提示：类加载时或创建对象时，父类静态成员、实例成员、构造方法和子类静态成员、实例成员、构造方法的执行先后次序)
当程序运行并通过向上转型后的对象来调用方法时，Java会根据实际的对象类型来调用实际类型所对应的方法。这种运行时的多态，我们也成为动态绑定。
第四章.类的继承和多态
using System ; class Vehicle //定义交通工具(汽车)类 { public int wheels ; //公有成员：轮子个数 protected float weight ; //保护成员：重量 public Vehicle( ){;} Vehicle 作为基类，体 public Vehicle(int w,float g){ 现了"汽车"这个实体具有的 wheels = w ; 公共性质：汽车都有轮子和 weight = g ;} 重量。 public void Speak( ){ Console.WriteLine( “交通工具的轮子个数是可以 变化的! ” ) ;} } class Car:Vehicle //定义轿车类：从汽车类中继承 { int passengers ; //私有成员：乘客数 public Car(int w , float g , int p) : base(w, g) { wheels = w ;weight = g ; passengers=p ; Car 类继承了Vehicle 的 } 全部性质，并且添加了自 } 身的特性：可以搭载乘客
基类继承的成员，因此可以将派生类的值赋给基类对象。
4.2 抽象类和封闭类
4.2.1 抽象类 用关键字abstract修饰的抽象类是一种没有被 完整定义的类，因而它不能用来实例化，或者说，不 能产生对象，设计abstract类的目的是为了被继承， 其意义在于： 1、包含派生类的公有成员，这些成员在抽象类 中定义一次，就可以被反复使用，提高了软件开发的 效率和可维护性 2、规范行为，抽象方法等具体行为特征的成员 实际上是一种建模过程，规定了输入口和输出口，而 将实现的细节留给派生类根据实际情况编程。 同一个抽象类的派生类有许多共性，这使得它 们有了交互的基础。
实验四 类的继承性与多态性
《Java语言程序设计》实验报告实验内容（2）设计两个Graphics类的子类：Rectangle类(矩形)和Circle类(圆)，编译并运行使程序运行结果如下所示：矩形的面积为：100.0圆的面积为：314.1592653589793代码：package exp4;//矩形类public class Rectangle extends Graphics{protected double a;protected double b;public Rectangle(double a,double b){super("矩形");this.a=a;this.b=b;}public double area(){return this.a*this.b;}}package exp4;//圆形类public class Circle extends Graphics {protected double r;public Circle(double r){super("圆形");this.r=r;}public double area(){return Math.PI*this.r*this.r;}}package exp4;//调用上述类public class Graphics_ex {public static void main(String args[]){Graphics g = new Rectangle(4,25);g.print();g = new Circle(10);g.print();}}运行结果：实验分析本次试验运行情况良好。
通过本次试验我掌握类的继承原则、重载和覆盖等多态概念设计的正确使用方法、声明抽象类的方法，还理解了抽象类的作用。
继承与多态实验报告
继承与多态实验报告继承与多态实验报告在面向对象编程中，继承和多态是两个重要的概念。
通过继承，我们可以创建新的类，并从现有的类中继承属性和方法。
而多态则允许我们使用父类的引用来指向子类的对象，实现同一操作具有不同的行为。
本实验旨在通过实际的编程实践，加深对继承和多态的理解。
实验一：继承在这个实验中，我们创建了一个动物类（Animal），并从它派生出了两个子类：狗类（Dog）和猫类（Cat）。
动物类具有一些共同的属性和方法，如名字（name）和发出声音（makeSound）。
子类继承了父类的属性和方法，并可以添加自己的特定属性和方法。
在编写代码时，我们首先定义了动物类，并在其中实现了共同的属性和方法。
然后，我们创建了狗类和猫类，并分别在这两个类中添加了自己的特定属性和方法。
通过继承，我们可以在子类中直接使用父类的方法，并且可以根据需要进行重写。
实验二：多态在这个实验中，我们使用多态的概念来实现一个动物园的场景。
我们定义了一个动物园类（Zoo），并在其中创建了一个动物数组。
这个数组可以存储不同类型的动物对象，包括狗、猫等。
通过多态，我们可以使用动物类的引用来指向不同类型的动物对象。
例如，我们可以使用动物类的引用来指向狗对象，并调用狗类特有的方法。
这样，我们可以统一处理不同类型的动物对象，而不需要为每种类型编写特定的处理代码。
实验三：继承与多态的结合应用在这个实验中，我们进一步探索了继承和多态的结合应用。
我们定义了一个图形类（Shape），并从它派生出了三个子类：圆形类（Circle）、矩形类（Rectangle）和三角形类（Triangle）。
每个子类都实现了自己的特定属性和方法。
通过继承和多态，我们可以在图形类中定义一些通用的方法，如计算面积和周长。
然后，我们可以使用图形类的引用来指向不同类型的图形对象，并调用相应的方法。
这样，我们可以轻松地对不同类型的图形进行统一的处理。
结论：通过本次实验，我们进一步理解了继承和多态的概念，并学会了如何在编程中应用它们。
实验四 类的继承与多态实验
实验四类的继承与多态实验实验四类的继承与多态实验实验四类的继承与多态实验【实验目的】1．理解软件重用性的一种形式――继承。
2．能够通过继承已有的类创建新类。
3．理解基类和派生类的概念。
4．能在派生类中采用构造函数和析构函数5．自学虚基类在化解二义性问题中的促进作用。
6．熟悉多态分类，理解静态联编和动态联编概念。
7．掌握运算符重载方法。
8．认知虚函数、tcsh函数和抽象类概念。
9．掌控用抽象类和多态性同时实现编程的方法。
【实验内容】1．分析程序，写出下列程序的运行结果：(1)#includeclassbase{private:intbase_priv_dat;protected:intbase_prot_dat;public:voidbase_show();};classderived:publicbase{private:intderived_priv_dat;public:voidderived_show();};voidbase::base_show(){base_priv_dat=1;//基类函数可以压低私有和维护型基类数据base_prot_dat=2;cout<voidderived::derived_show(){derived_priv_dat=3;base_prot_dat=4;//派生函数可以处理保护型基类数据，但不能处理私有基类数据cout<}intmain(){derivedd_obj;d_obj.base_show();//可用派生对象调用基类函数d_obj.derived_show();return(0);}(2)#include#includeclassperson{public:person(constchar*s)//拎参数的构造函数{name=newchar[strlen(s)+1];strcpy(name,s);}~person(){delete[]name;}//析二重函数搞清扫工作char*getname(){returnname;}protected:char*name;};classstudent:publicperson{char*major;public:student(constchar*s,constchar*m):p erson(s)//派生类构造函数{major=newchar[strlen(m)+1];strcpy(major,m);}~student(){delete[]major;}//派生类析构函数char*getmajor(){returnmajor;}};intmain(){studentstu(\cout<2．编译运行下列程序，分析出现编译错误的原因，并给出解决办法。
实验四类的继承和多态
import java.util.Scanner; public class Main {
public static void main(String[] args) { Scanner myScan = new Scanner(System.in); String strColor = myScan.next(); String strName = myScan.next(); Shape shape1 = new Circle(strColor,strName); shape1.printType(); shape1.printName();
实验四பைடு நூலகம்类的继承和多态
苏明明 16 电信二班 160705226
一、实验目的 1、掌握类的继承以及访问控制。 2、掌握类的多态性。 3、掌握内部类和匿名类的定义和使用。 二、实验过程 1、知识点归纳： 编程实践类的继承以及访问控制； 编程实践类的多态性； 编程实践内部类和匿名类的定义和使用。 2、实验题目 请构建两个类： class Shape {.....}和 class Circle extends Shape {......} 再写一个测试，表现类继承时构造器的调用顺序和初始化顺序。 输入要求：子类 Circle 的颜色和名字。 输出要求：按照类继承时构造器的调用顺序输出相应信息。 输入：red c1 输出：shape constructor red circle be constructed. this is circle my name is c1 输入：blue c2 输出：shape constructor blue circle be constructed. this is circle my name is c2 3、需求分析 本题需要写两个类，一个父类 Shape 和一个子类 Circle，能够在输入子类的 颜色和名字时，输出相应的信息。 4、程序结构 一个父类 Shape 和一个子类 Circle 5、编写代码
类的继承和多态
利用“类”一章中编写的people类，编写如下的程序1．编写一个student类继承自people，添加一个私有整形成员变量knowledge，和一个公有方法study，调用这个函数时令knowledge加一。
并在主函数中测试。
2．编写一个worker类继承自people，添加一个私有整形成员变量salary，和一个公有方法work，调用这个函数时令salary加一。
并在主函数中测试。
3．编写一个parttime类继承自student和worker，在主函数中调用grow()，看看有什么现象并加以解释（多重继承中的二义性）。
4．使用虚基类方式该写parttime，再在主函数中调用grow()，体会虚基类对于消除二义性的作用。
回顾“类”一章所编写的有理数类，并做以下的改进：1．编写一个类Number作为基类，具有一个display虚函数，Number类的display函数不实现任何功能。
另外它有一个保护型的成员变量int N;2．将原有的Ratio类改写为Number类的子类，有理数的分子直接使用基类的成员变量N。
它的display成员函数实现的功能不变。
3．继承Number类再实现一个复数类Comlex，具有一个构造函数Comlex(int real, int vtl)，两个参数分别是表示其实部和虚部（不考虑实部虚部是小数的情况），其中实部使用基类的成员变量N。
其display函数将该复数显示为“a+bi”的形式。
4．为Number类添加另一个公有成员函数display2()（普通的成员函数，非虚），其中Number 类的display2函数在屏幕上打印”Number!!”。
然后定义Ratio和Complex类的display2成员函数，其中Ratio类调用display2时在屏幕上显示”分子是X，分母是X”，Complex 在屏幕上显示”实部是X，虚部是X”。
（X是相应的值）。
5．定义两个变量：Number n1 (x1,x2)和Number n2 (x1,x2)，然后分别调用n1.display(), n2.display(),以及n1.display2(), n2.display2()，观察并分析结果。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四类的继承与多态
一、实验目的
1.掌握构造方法和成员方法重载的应用。
2.理解类的继承性的作用
3.领会面向对象编程的多态性。
二、实验内容与要求
基本概念
1．进一步理解继承的含义
新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。
新类还可添加新的变量和方法。
这种现象就称为类的继承。
当建立一个新类时，不必写出全部成员变量和成员方法。
只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。
被继承的类称为父类或超类（superclass），这个新类称为子类。
Java 提供了一个庞大的类库让开发人员继承和使用。
设计这些类是出于公用的目的，因此，很少
有某个类恰恰满足你的需要。
你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。
所以，通常要对子类进行扩展，即添加新的属性和方法。
这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。
继承的意义就在于此。
2．了解成员变量的隐藏方式
所谓隐藏是指子类重新定义了父类中的同名变量，在子类L ine 中重新定义了x为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。
子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。
在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。
3．了解成员方法的覆盖方式
（1）方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。
方法覆盖为子类提供了修改父类成员方法的能力。
4．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。
在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。
这种现象称为类的多态。
多态使程序简洁，为程序员带来很大便利。
在O OP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。
这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。
类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。
实践应用
1、定义一个圆类Circle，成员变量：半径radius；
成员方法：构造方法、get和set半径的方法、计算面积和周长的方法。
定义圆柱和圆锥类，定义相应的变量成员和成员方法。
使用以上类编程，输出圆柱和圆锥面积和体积。
2、声明一个类MyClass，包含一个整型变量data和封装这个变量的两个方法getData()和setData()。
声明一个该类的子类SubClass，包含一个整型变量Mydata和封装这个变量的两个方法getMydata()和setMydata()，编写主程序检查SubClass类中的所有变量与方法（包括继承自父类的变量和方法。
3、下面给出一个根据雇员类型利用多态性完成工资单计算的程序。
定义一个类Employee 作为超类，Employee的子类有Boss（每星期发给他固定工资，而不计工作时间）、PieceWorker （按其生产的产品数发放工资）、HourlyWorker（根据工作时间长短发放工资）。
对所有雇员类型都使用earnings()方法完成其工资单的计算，但每个人挣的工资按他所属的雇员类计算，所有雇员类都是从超类Employee派出生的。
所以在超类中声明earnings()方法，该方法没有实质性工作，而是在每个子类都提供恰当的earnings()方法的重写。
为了计算雇员的工资，程序仅使用雇员对象的一个超类引导并调用earnings()方法。
三、思考题
1、如何继承一个类？
2、同名的不同方法共存的情况称为什么？如何区分这些同名方法？
3．子类重新定义与父类方法的方法头完全相同的方法，这种情况称为什么？。