实验报告5 继承与多态
实验名称：继承与多态
一．实验目的：
（（1）理解继承的含义，掌握派生类的定义方法和实现；
（2）理解虚函数在类的继承层次中的作用，虚函数的引入对程序运行时的影响，能够对使用虚函数的简单程序写出程序结果。
（3）编写体现类的继承性（成员变量，成员方法，成员变量隐藏）的程序；
（4）编写体现类多态性（成员方法重载，构造方法重载）的程序。
（5）理解接口和抽象类、抽象方法的定义和实现方法；
（5）理解接口和抽象类的差别。
二．上机内容：
（1）进行类的继承和基类构造方法的应用的练习；
（2）进行类的多态性练习
（3）进行抽象类和接口的练习
（4）整理上机步骤，总结经验和体会。
（5）完成实验报告。
三．上机步骤：
类的继承和基类构造方法的应用
（1）编写一个学生和教师数据输入和显示程序，学生数据有编号、姓名、班级和成绩，教师数据有编号、姓名、职称和部门。要求将编号、姓名输入和显示设计成一个类person，并作为学生数据操作类student和教师类数据操作类teacher的基类。using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication2
{
class person
{
public string bh;//编号
public string xm;//姓名
public person(string bh, string xm)
{
this.bh = bh;
this.xm = xm;
}
public void show()
{
Console.WriteLine("姓名：{0}", xm);
Console.WriteLine("编号：{0}", bh);
}
}
class student : person
{
public string bj;//班级
public int cj;//成绩
public student(string sbh, string sxm, string sbj, int scj)
: base(sbh, sxm)
{
bh = sbh;
xm = sxm;
bj = sbj;
cj = scj;
}
public new void show()
{
Console.WriteLine("***student***");
Console.WriteLine("姓名：{0}", xm);
Console.WriteLine("编号：{0}", bh);
Console.WriteLine("班级：{0}", bj);
Console.WriteLine("成绩：{0}", cj);
}
}
class teacher : person
{
public string zc;//职称
public string bm;//部门
public teacher(string tbh, string txm, string tzc, string tbm) : base(tbh, txm)
{
bh = tbh;
xm = txm;
zc = tzc;
bm = tbm;
}
public new void show()
{
Console.WriteLine("***teacher***");
Console.WriteLine("姓名：{0}", xm);
Console.WriteLine("编号：{0}", bh);
Console.WriteLine("职称：{0}", zc);
Console.WriteLine("部门：{0}", bm);
}
}
class program
{
static void Main(string[] args)
{
student st = new student("050013", "张三", "信管091", 91);
st.show();
teacher te = new teacher("046950", "范仲淹", "特级教师", "教务处"); te.show();
Console.ReadLine();
}
}
}
运行结果：
（2）将以上程序尝试改成通过调用基类构造方法的方式
来初始化编号和姓名，并总结调用基类构造方法的应用要
点。
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication2
{
class person
{
public string bh;//编号
public string xm;//姓名
public person(string bh, string xm)
{
this.bh = bh;
this.xm = xm;
}
public void show()
{
Console.WriteLine("姓名：{0}", xm);
Console.WriteLine("编号：{0}", bh);
}
}
class student : person
{
public string bj;//班级
public int cj;//成绩
public student(string sbh, string sxm, string sbj, int scj)
: base(sbh, sxm)
{
bj = sbj;
cj = scj;
}
public new void show()
{
Console.WriteLine("***student***");
Console.WriteLine("姓名：{0}", xm);
Console.WriteLine("编号：{0}", bh);
Console.WriteLine("班级：{0}", bj);
Console.WriteLine("成绩：{0}", cj);
}
}
class teacher : person
{
public string zc;//职称
public string bm;//部门
public teacher(string tbh, string txm, string tzc, string tbm) : base(tbh, txm)
{
zc = tzc;
bm = tbm;
}
public new void show()
{
Console.WriteLine("***teacher***");
Console.WriteLine("姓名：{0}", xm);
Console.WriteLine("编号：{0}", bh);
Console.WriteLine("职称：{0}", zc);
Console.WriteLine("部门：{0}", bm);
}
}
class program
{
static void Main(string[] args)
{
student st = new student("050013", "张三", "信管091", 91); st.show();
teacher te = new teacher( "046950", "范仲淹","特级教师", "教务处"); te.show();
Console.ReadLine();
}
}
}
运行结果：
类的多态性练习
创建一个Person类，要求如下：
（1）包含公共字段：string name，私有字段：int age；
（2）公共属性：int Age对应私有字段age，注意在设置Age的时候要验证年龄的合法性；（3）构造函数：Person()、Person(string name,int Age)
（4）析构函数：~Person()；
（5）方法：virtual void ShowMe()、void ForNew()、void ForOverload()、void ForOverload(Person p)；
创建一个Student类，继承Person类：
（1）公共字段：number；
（2）构造函数：Student()、Student(string name,int age,string number)该构造函数要调用父类的构造函数Person(string name,int Age)；
（3）方法：重写父类的ShowMe方法、重载父类的ForOverload方法、隐藏父类的ForNew方法。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication32
{
class Person
{
public string name;
private int age;
public int Age
{
set {
if (value > 0 && value < 150)
{
age = value;
}
}
get { return age; }
}
public Person (string name,int age)
{
this.Age=age;
https://www.wendangku.net/doc/c4736217.html,=name;
}
public Person()
{
Console.WriteLine("hello,you are welcom!,your name is{0},your age is{1}",name,age);
}
~Person(){ }
public virtual void ShowMe()
{
Console.WriteLine("name:{0} age:{1}", name, age);
}
public void ForNew()
{
Console.WriteLine("name:{0} age:{1}", name, age);
}
public void ForOverLoad()
{
Console.WriteLine("name:{0} age:{1}", name, age);
}
public void ForOverLoad(Person p)
{
Console.WriteLine("name={0} age={1}", https://www.wendangku.net/doc/c4736217.html,, p.age);
}
}
class Student:Person
{
public string number;
public Student() { }
public Student(string name, int age, string number) : base(name, age) {
this.number = number;
}
public override void ShowMe()
{
Console.WriteLine("name:{0} age:{1} number:{2}",name,Age,number);
}
public void ForOverLoad(Student s)
{
Console.WriteLine("name={0} age={1} number:{2}", https://www.wendangku.net/doc/c4736217.html,,
s.Age,s.number);
}
public new void ForNew()
{
Console.WriteLine("name:{0} age:{1} number:{2}",name,Age,number); }
}
class Program
{
static void Main(string[] args)
{
Student s = new Student("罗瑞",20,"090202563");
s.ShowMe();
s.ForNew();
s.ForOverLoad(s);
Console.ReadLine();
}
}
}
运行结果：
抽象类
（1）创建一个shape抽象类，要求如下：
属性：公共属性double length和抽象属性double width；
方法：虚方法double Perimeter()用于计算形状的周长；抽象方法double Area()，用于计算形状的面积。
（2）创建一个Rectangle类继承shape类，要求如下：
属性：实现父类的抽象属性；
方法：实现父类的抽象方法，并重写虚方法。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication33
{
abstract class shape
{
public double length;
public abstract double width{set;get;}
public virtual double Perimeter()
{
return 2 * (width + length);
}
public abstract double Area();
}
class Rectangle : shape
{
private double Width;
public override double width
{
set { Width = value; }
get { return Width; }
}
public Rectangle(double width, double length)
{
this.width = width;
this.length = length;
}
public override double Perimeter()
{
return 2 * (width + length);
}
public override double Area()
{
return width * length;
}
}
class Program
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(9, 8);
Console.WriteLine("***长方形***");
Console.WriteLine("周长:{0}" ,r.Perimeter());
Console.WriteLine("面积:{0}", r.Area());
Console.ReadLine();
}
}
}
接口
1）定义一个IPerson接口，要求如下：
属性：string Name表示姓名、DateTime Birthday表示出生日期；
方法：ushort Age()用于返回年龄、void ShowMessage()；
（2）定义一个IAddress接口，要求如下：
属性：string Street用于表示街道、string City表示所在城市；
（3）定义一个IAddress2接口实现对IAddress接口的扩展，增加string Province，string State 属性，分别表示所在省份和国家；增加string ShowAddress()方法，用来按照“国家+省份+城市+街道”的形式显示地址；
（4）定义一个Employee类实现IPerson和IAddress2接口；
（5）定义一个ITest接口，包含一个void ShowMessage()方法；
（5）定义一个Student类继承Employee类并实现ITest接口。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication35
{
public interface IPerson//（1）定义一个IPerson接口，要求如下：
//属性：string Name表示姓名、DateTime Birthday表示出生日期；
//方法：ushort Age()用于返回年龄、void ShowMessage()；
{
string Name { set; get; }
DateTime Birthday { set; get; }
ushort Age();
void ShowMessage();
}
public interface IAddress//（2）定义一个IAddress接口，要求如下：
//属性：string Street用于表示街道、string City表示所在城市；
{
string Street { set; get; }
string City { set; get; }
}
public interface IAddress2 : IAddress//定义一个IAddress2接口实现对IAddress 接口的扩展，
//增加string Province，string State属性，分别表示所在省份和国家；
//增加string ShowAddress()方法，用来按照“国家+省份+城市+街道”的形式显示地址；
{
string Province { set; get; }
string State { set; get; }
void ShowAddress();
}
public interface ITest//定义一个ITest接口，包含一个void ShowMessage()方法；
{
void ShowMessage();
}
public class Employee : IPerson, IAddress2//定义一个Employee类实现IPerson和IAddress2接口；
{
private string state;
public string State
{
set { state = value; }
get { return state; }
}
private string province;
public string Province
{
set { province = value; }
get { return province; }
}
private string city;
public string City
{
set { city = value; }
get { return city; }
}
private string street;
public string Street
{
set { street = value;}
get { return street; }
}
private string name;
public string Name
{
set { name = value; }
get { return name; }
}
private DateTime birthday;
public DateTime Birthday
{
set{birthday=value;}
get{return birthday;}
}
public ushort Age()
{
return (ushort)(2011 - int.Parse(Birthday.Year.ToString()));
}
public void ShowMessage()
{
Console.WriteLine("name：{0} birthday：{1} age：
{2}",Name,Birthday,this.Age());
}
public void ShowAddress()
{
Console.WriteLine(State+Province+City+Street);
}
}//定义一个Student类继承Employee类并实现ITest接口
public class Student : Employee, ITest
{
public Student(string Name, string Birthday, string State, string Street, string City, string Province)
{
https://www.wendangku.net/doc/c4736217.html, = Name;
this.Birthday = DateTime.Parse(Birthday);
this.State = State;
this.Street = Street;
this.City = City;
this.Province = Province;
}
public new void ShowMessage()
{
Console.WriteLine("名字：{0} 出生日期：{1} 年龄：{2} ", Name, Birthday, this.Age());
Console.WriteLine("地址：" + State + Province + City + Street);
}
}
class Program
{
static void Main(string[] args)
{
Student st = new Student("罗德彬", "1989/10/01", "中国", "成龙路", "成都", "四川省");
st.ShowMessage();
Console.ReadLine();
}
}
}
继承与多态习题
继承与多态习题 一.基本概念与基础知识自测题 8.1填空题 8.1.1 如果类α继承了类β，则类α称为（1）类，而类β称为（2）类。（3）类 的对象可作为（4）类的对象处理，反过来不行，因为（5）。如果强制转换则要注意（6）。 答案：（1）基类 （2）派生类 （3）派生类 （4）基类 （5）派生类有一些新成员 （6）只能派生类强制转换为基类 8.1.2 当用public继承从基类派生一个类时，基类的public成员成为派生类的（1）成员， protected成员成为派生类的（2）成员，对private成员是（3）。公有派生可以使其类的（4），所以公有派生是主流。 答案：（1）public成员 （2）protected成员 （3）不可访问 （4）接口不变 8.1.3 利用继承能够实现（1）。这种实现缩短了程序开发的时间，VC++中的（2）很 好地体现了这一点。 答案：（1）代码的复用 （2）MFC编程 8.1.4 一个派生类只有一个直接基类的情况称为（1），而有多个直接基类的情况称为 （2）。继承体现了类的（3）概念，这在MFC中得到了很好表现，MFC中只采用了（4）。 答案：（1）单继承 （2）多重继承 （3）层次 （4）单继承 8.1.5 C++中多态性包括两种多态性：（1）和（2）。前者是通过（3）实现的， 而后者是通过（4）和（5）来实现的。 答案：（1）编译时的 （2）运行时的 （3）函数和运算符的重载 （4）类继承关系 （5）虚函数 8.1.6 在基类中将一个成员函数说明成虚函数后，在其派生类中只要（1）、（2）和
（3）完全一样就认为是虚函数，而不必再加关键字（4）。如有任何不同，则认为是（5）而不是虚函数。除了非成员函数不能作为虚函数外，（6）、（7）和（8）也不能作为虚函数。 答案：（1）同虚函数名 （2）同参数表 （3）同返回类型。如基类中返回基类指针，而派生类中返回派生类指针是允许的 （4）virtual （5）重载 （6）静态成员函数 （7）内联函数 （8）构造函数 8.1.7 纯虚函数定义时在函数参数表后加（1），它表明程序员对函数（2），其本质 是将指向函数体的指针定为（3）。 答案：（1）=0 （2）不定义 （3）NULL 8.2简答题 8.2.1构造函数和析构函数可以继承吗？派生类构造函数各部分的执行次序是怎样的？答：构造函数和析构函数不可以继承。派生类构造函数各部分的执行次序是： 1.调用基类构造函数，按它们在派生类声明的先后顺序，依次调用。 2.调用新增成员对象的构造函数，按它们在类定义中声明的先后顺序，依次调用。 3.派生类的构造函数体中的操作。 8.2.2什么叫派生类的同名覆盖（override）? 答：如果派生类声明了一个和某个基类成员同名的新成员（当然如是成员函数，参数表也必须一样，否则是重载），派生类中的新成员就屏蔽了基类同名成员，类似函数中的局部变量屏蔽全局变量。称为同名覆盖（override）。 8.2.3派生类的析构函数中需完成什么任务？是否要编写对基数和成员对象的析构函数的 调用？为什么？ 答：析构函数的功能是作善后工作，析构函数无返回类型也没有参数，情况比较简单。派生类析构函数定义格式与非派生类无任何差异，不要编写对基数和成员对象的析构函数的调用，只要在函数体内把派生类新增一般成员处理好就可以了，因为对新增的成员对象和基类的善后工作，系统会自己调用成员对象和基类的析构函数来完成。 8.2.4为什么要使用虚基类？怎样定义虚基类？用一个实例来解释虚基类在其派生类中的 存储方式。 答：在多重继承是有可能出现同一基类的两个拷贝，为避免这种情况，可使用虚基类。虚基类（virtual base class）定义方式如下： class派生类名:virtual 访问限定符基类类名{...}; class派生类名:访问限定符virtual基类类名{...}; virtual 关键字只对紧随其后的基类名起作用。
实验三多态性实验报告
浙江理工大学信息学院 实验指导书 实验名称：类的多态性的实现学时安排：3 实验类别：设计性实验实验要求：1人1组 学号：姓名： ￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣ 一、实验目的 1.理解重载运算符的意义。 2.掌握使用成员函数、友员函数重载运算符的特点。 3.掌握重载运算符函数的调用方法。 4.掌握动态联编的概念。 5.掌握虚函数和纯虚函数的使用方法。 二、实验原理介绍 设计性实验 具体原理请见实验内容和步骤 实现对抽象类的继承，通过operator函数调用的形式,实现运算符的重载 三、实验设备介绍 软件需求: windows或linux下的c++编译器 硬件需求: 对于硬件方面的要求，建议配置是Pentium III 450以上的CPU处理器，64MB以上的内存，200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。 四、实验内容 某公司的员工有经理Manager、技术人员Technicist和营销人员SalsePerson，他们的薪金计算方法如下： 经理按月计酬，方法是：基本工资+奖金；技术人员按月计酬，方法是：基本工资；营销人员按月计酬，方法是：基本工资+销售利润*5%。 每类人员都有职工编号、姓名、性别、入职时间、职位、基本工资等数据；各类人员
使用统一接口get_pay()计算各类人员的月薪，重载<<运算符实现员工信息的输出。其次，设计一个统计并输出该公司员工当月薪金情况的报表类Report，该类提供insert接口向Report类的容器中添加员工信息，并提供print接口用于展示以职位为单位的每个员工的职工编号、姓名、性别、入职时间以及当月该员工的薪酬，并统计出该职位员工薪酬的最高值和最低值。为了提供更方便的查找功能，请为Report类重载[]运算符，下标值为职位，能根据职位信息查找出所有符合该职位的员工。在主函数中对实现的类进行测试，首先，创建各类人员对象，通过Report类的insert接口向报表中添加这些人员信息，然后通过Report类的print接口输出当月员工薪酬情况报表。存储员工对象的容器请选用合适的STL容器。 五程序清单 ormat("ddd")<<"\t"; cout<<(*it)->getbasicmoney()<<"\t"<<"\t"; cout<<(*it)->getpay(month) << endl; } } void Report::insert(Employee* p) { (p); } Report::~Report(){ list
第五章 类与继承作业一
第五章类与继承作业一 一、填空选择题 1、（在同一包中）子类不能继承父类中的私有成员，除此之外，其它所有的成员都可以通过继承变为子类的成员。 2、给出如下的程序，A-E选项中与构造方法ConstOver重载的两个构造方法是：AC。 .public class ConstOver { publicConstOver (int x, int y, int z) { } } A.ConstOver ( ) { } B.ProtectedintConstOver ( ) { } C.PrivateConstOver (int z, int y, byte x) { } D.public Object ConstOver (int x, int y, int z) { } E.public void ConstOver (byte x, byte y, byte z) { } 3、已知类关系如下： class Employee; class Manager extends Employeer; class Director extends Employee; 则以下关于数据的语句正确的是：（A）。 A. Employee e=new Manager(); B. Director d=new Manager(); C. Director d=new Employee(); D. Manager m=new Director(); 4、（A）下面对类的申明哪个是正确的？ A）public class Fred { publicint x = 0; public Fred (int x) { this.x = x; } } B）public class fred publicint x = 0; publicfred (int x) { this.x = x; } } C）public class Fred extends MyBaseClass, MyOtherBaseClass { publicint x = 0; public Fred (intxval) { x = xval; } } D）protected class Fred { privateint x = 0;
JAVA继承和多态实验报告
实验项目名称：继承和多态 （所属课程：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(){
实验五 继承与多态
实验五继承与多态 专业班级学号姓名 实验学时 2 实验类型验证性实验地点数计学院实验中心实验时间指导老师 实验成绩 年月日一、实验目的： 理解继承与多态的概念，掌握三种访问控制的区别，掌握抽象类、接口与包的应用。 二、实验内容： 1. 参考教材P124，示例程序C5_17，掌握抽象类的应用。 2. 参考教材P128，示例程序C5_18，掌握接口的使用方法。 3. 参考教材P133，示例程序C5_20，掌握包的使用方法。 三、实验要求： 1.完成示例程序的验证。 2.写出实验报告。 四、实验步骤与结果：（由学生按照实验内容完成） 程序一 package ch01; import java.applet.Applet; import java.awt.Graphics; abstract class Shapes //定义一个抽象类Shapes { public int x,y; //x、y为画图的坐标 public int width,height; public Shapes(int x,int y,int width,int height) { this.x=x; this.y=y; this.width=width; this.height=height; } abstract double getArea( ); //求图形面积的抽象方法 abstract double getPerimeter( ); //求图形周长的抽象方法 } class Square extends Shapes //由抽象类Shapes派生的子类——矩形类 { @Override public double getArea( ){return(width*height);} @Override public double getPerimeter( ){return(2*width+2*height);} public Square(int x,int y,int width,int height) { super(x,y,width,height); } }
Java继承与多态实验报告
西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13
一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate
（1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.wendangku.net/doc/c4736217.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a 自考Java语言程序设计（一）第五张课后习题及答案 自考Java语言程序设计（一）第五章类的继承课后习题 五、类的继承 l．什么是继承?什么是父类?什么是子类?继承的特性可给面向对象编程带来什么好处?什么是单重继承?什么是多重继承? 2．观察下面的程序片断，指出其中的父类和子类，以及父类和子类的各个域和方法。 class SuperClass { int data; voidsetData(intnewData) { data=newData~ } intgetData() { return data~ } } class SubClass extends SuperClass { int suhData; void setSubData(intnewData) { suhData=new Data; } intgetData() { return subData; } } 3．“子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否正确?为什么? 4. 在Java程序中，通过类的定义只能实现单重继承() 5.下列哪些说法是正确的？ A、Java 语言只允许单一继承 B、Java 语言只允许实现一个接口 C、Java 语言不允许同时继承一个类并实现一个接口 D、Java 语言的单一继承使得代码更加可靠 6.Java中所有类都是类________的子类。 7.请写出下面程序的运行结果。 public class Test extends TT{ public void main(String args[]){ Test t = new Test("Tom"); } public Test(String s){ super(s); System.out.println("How do you do?"); } public Test(){ this("I am Tom"); } } www.Ｅhttps://www.wendangku.net/doc/c4736217.html, class TT{ public TT(){ System.out.println("What a pleasure!"); } public TT(String s){ this(); System.out.println("I am "+s); } } 结果：________ 8.父类的成员在子类中的访问权限由决定。 9.对象的使用包括引用对象的成员变量和方法。通过运算符就能实现对对象成员变量的访问和对象 10.Java是面向对象语言，对象是客观事物的，对象与之是一一对应的，它是很具体的概念。 参考答案： l．答：继承是面向对象程序设计中两个类之间的一种关系。当一个类获取另一个类中所有非私有的数据和操作的定义作为它自己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类称为父类或超类，继承了父类或超类的所有数据和操作的类称为子类。 面向对象程序设计中的继承，可使得程序结构更加清晰，降低了编码和维护的工作量。如果一个类只能有一个父类，则这种继承关系称为单重继承；如果一个类可以有多个父类，则这种继承关系称为多重继承。 2．答： 父类SuperClass 父类的域data来源：考试大的美女编辑们 父类的方法setData()，getData() 子类SubClass 子类的域data，subData 子类的方法setSubData()，setData()，getData()采集者退散 3．答：这种说法是错误的，因为子类不一定能继承父类的所有域和方法，它只能 《高级Java编程技术》课程实验报告 院（系）名称：计算机学院专业班级：09计科 3 班 学号：姓名： 实验题目：实验10继承与多态 实验日期：2011/11/29实验（上机）学时：2 一、实验内容、要求 1.实验内容：计算课程成绩 2.要求： 编写应用程序，读入以下风格的文本文件，并显示最后的课程成绩，根据列出的公式，对于本科生和研究生，课程成绩的计算方法不同。输入的文本格式如下： （1）用单独的一行表示一个学生的信息。 （2）每行使用下面的格式： （2）计算课程成绩。 （3）输出结果。 我们将用五个增量步骤开发此程序： （1）以程序结构开始，定义ComputeGrades类的框架。 （2）实现printResult方法，定义实现printResult所必需的任何其他方法。 （3）实现computerGrades方法，定义实现computerGrades所必需的任何其他方法。 （4）实现readDate方法，定义实现readDate所必需的任何其他方 法。 （5）最后完成并改进。 二、所采用的数据结构 如：线性表，二叉树，树，图等。你在此用到了啥样的数据结构就写啥。无数据结构。 三、实验的主要模块（或函数）及其功能 函数分块及各块主要功能的文字描述 ComputGrades类:这是本程序的主类，且是MainWindow的子类。MainWindows本身是Jframe的子类，并且又将其自身放在屏幕中间的功能。ComputGrades类包含的方法如下： 1、构造方法。生成任意大小的数组，让程序员在构造方法中传递数组的 大小，不在构造方法中生成数组。 2、printResult方法。将学生信息机计算出来的成绩输出到OutputBox 第4章继承与多态一．选择题 1、编译与运行以下两文件结果就是( D )。 //文件P1、java package MyPackage; class P1{ void afancymethod(){ System、out、println("What a fancy method"); } } //文件P2、java package YourPackage; import MyPackage、*; public class P2 extends P1{ public static void main(String argv[]){ P2 p2 = new P2(); p2、afancymethod(); } } A.两个均通过编译,P2运行时输出What a fancy method B.没一个通过编译 C.两个均通过编译,但P2运行时出错 D.P1 通过编译,但P2出现编译错误 2.下列程序运行的结果就是( A )。 package a; package b; public class D{ public static void main(String args[]) { System、out、println("^_^,今天心情不错！"); } } A.出现编译错误 B.^_^,今天心情不错！ C.通过编译,运行时出错 D.以上都不对 3.Java的核心类库中哪个包,Java系统能自动引入( B )。 A.java、io B.java、lang C.java、net D.java、util 4.下列程序运行结果就是( A )。 private class Base{ Base(){ int i = 100; System、out、println(i); } 贵州大学实验报告 学院：电子信息学院专业：通信工程班级： 姓名学号实验组5实验时间指导教师成绩 实验项目名称多态性 实 验通过让学生进行实验，使其对于动态多态性有一个较为深入的了解和熟悉。最终可以目熟练使用。 的 实 1．编写 4 个重载函数 Double（ x），返回值为输入参数的两倍；参数类型分别为int 、验long 、float 、 double ，返回值类型与参数类型一样。 2．请编写一个抽象类Shape，在此基础上派生出类Rectangle和Circle，二者都有 要 计算对象面积的函数GetArea （）和计算周长函数GetPerim （）。 求3．对类 Point 重载 ++（自增）、 -- （自减）运算符。 实 验Visual C++的编译环境下，独立完成实验要求的内容，独立完成编写、编译以及运行 原的过程 理 实 验 安装了 Visual C++ 的 PC机器 仪 器 实 验 按照实验要求的内容逐一完成实验的要求。顺序是编写、编译、运行。 步 骤 实 1. 编写 4 个重载函数 Double（x），返回值为输入参数的两倍；参数类型分别为int、 验 long 、 float 、 double ，返回值类型与参数类型一样。 2. 请编写一个抽象类Shape，在此基础上派生出类Rectangle 和 Circle，二者都有计 内算对象面积的函数GetArea （）和计算周长函数GetPerim （）。容 3. 对类 Point 重载 ++（自增）、 -- （自减）运算符。 1、代码如下： #include 继承与多态性习题参考答案 ————————————————————————————————作者：————————————————————————————————日期： C++程序设计语言习题及实验指导 第8章继承与多态性习题参考答案 8.3 习题 8.3.1 选择题 题号 1 2 3 4 5 6 7 8 9 10 答案 C D A D A B C B D D 题号11 12 13 14 15 16 17 18 19 20 答案 D D A C B C C C A C 8.3.2 填空题 1．(1) a、b、c、x、y、z (2) b、y (3) c、z (4) a、x (5) b、c、x、y、z (6) b、y (7) y (8) b、c、z (9) a、x (10) b、c、x、y、z (11) y (12) y (13) z (14) a、b、c、x (15) b、c、x、y、z (16) y 2．私有 3．抽象 4．虚基 5．(1) 基类(2) 对象 6．(1) 静态(2) 编译(3) 虚函数 7．(1) 2 1 (2) 0 5 8．(1) 100 200 300 30 (2) 10 100 (3) 20 200 9．(1) 5 10 (2) end. (3) 20 10 10．(1) classA classB (2) end. (3) ~classB ~classA 11．(1) 10 (2) build B (3) build C (4) release A 12．(1) class B (2) class C (3) class D (4) 5 13．(1) 5 5 (2) 20 20 14．(1) 10 (2) 10 20 15．(1) 1 (2) 3 (3) 5 (4) 100 10 16．(1) B::f() (2) B::fun() (3) A::f() (4) B::fun() 17．(1) 姓名陈涛年薪6.8万元。(2) 姓名李原(3) 姓名李原月工资4000元18．(1) 110 (2) 2220 19．(1) protected 或public (2) Base1(s1),Base2(s2) 或Base2(s2),Base1(s1) (3) Base1::str (4) test.print() 20．(1) virtual void show()=0 (2) C(int,int,int) （注：参数可有任一名称） (3) b1(y) (4) &t 8.3.3 编程题 1．求长方形的面积和长方体的表面积、体积 #include Java语言程序设计 第五章课后习题答案 1.什么是接口？接口起什么作用？接口与抽象类有何区别？ 答：Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。 作用：接口是面向对象的一个重要机制，使用接口可以实现多态继承；接口中的所有方法都是抽象的，这些抽象方法由实现这一接口的不同类型来具体；接口还可以用来实现不同类之间的常量共享。 与抽象类不同的是：接口允许在看起来不相干的类之间定义共同行为。 2.试编程证明接口中的属性都隐含为static及final，所有的方法都为public。 //定义接口Shape2D interface Shape2D{ double Pi=3.14; double area(); } //Circle类继承接口Shape2D public class Circle implements Shape2D{ double radius; public Circle(double r){radius=r;} public double area(){return Pi*radius*radius;} } //A类（测试接口中隐含final的area()方法） public class A extends Shape2D{ public double area(); } //test5_2 public class test5_2{ public static void main(String args[]){ Circle c=new Circle(10); System.out.println("Pi=3.14圆的面积："+c.area()); SetPi b=new SetPi(3.00); System.out.println("改变Pi=3.00圆的面积："+c.area()); } } 运行结果： 福建农林大学计算机与信息学院实验报告 实验（四）继承和多态 一、实验目的和要求 1.掌握面向对象的继承关系 2.理解面向对象的多态 3.掌握方法的重写 4.掌握接口的实现 二、实验内容和原理 设计一个抽象类Shape，包括2个抽象方法，分别是计算形状的周长和面积。设计具体类Rectangle和Circle，分别表示矩形和圆，它们都是Shapes的子类。使Rectangle和Circle都实现Comparable接口（根据面积比较大小），编写一个通用的排序程序和一个通用的二分查找程序（自己写代码实现），能对这二种类型的数组进行排序并查找指定的对象。 三、实验环境 1.硬件环境： 2.软件环境：JDK1.5 四、算法描述及实验步骤 1.算法描述（可以用类图、流程图、伪代码或源程序描述） package test; import javax.swing.JOptionPane; import java.util.Scanner; public class Test { public static void main(String[] args) { System.out.println("要创建几个圆？："); Scanner a1 = new Scanner(System.in); int a = a1.nextInt(); System.out.println("总共创建了" + a + "个圆\n请输入各个圆的半径："); Shape[] circle = new Shape[a]; Scanner input2 = new Scanner(System.in); for (int i = 0; i < a; i++) { circle[i] = new Circle(input2.nextDouble()); } System.out.println("要创建几个矩形？："); Scanner b2 = new Scanner(System.in); int b = b2.nextInt(); Shape[] rectangle = new Shape[b]; System.out.println("总共创建了" + b + "个矩形\n请依次输入各个矩形的长和宽："); Scanner c3 = new Scanner(System.in); for (int i = 0; i < b; i++) { rectangle[i] = new Rectangle(c3.nextDouble(), c3.nextDouble()); } Shape.sort(circle); String str1 = ""; for (int i = 0; i < circle.length; i++) { str1 += String.valueOf(i + 1) + circle[i] + "\n"; } System.out.println("您所创建的圆按半径由小到大排序如下：\n" + str1); Shape.sort(rectangle); String str2 = ""; for (int i = 0; i < rectangle.length; i++) { str2 += String.valueOf(i + 1) + rectangle[i] + "\n"; } System.out.println("您所创建的矩形按面积由小到大排序如下：\n" + str2); 答案： 一、单项选择题 1．C 2．D 3．A 4．D 5．C 6．B 7．A 8．B 9．A 10．D 二、简答题 1． 面向对象编程的三大特征：封装、继承和多态。封装：通过设置访问权限等方式封装了内部实现细节，使用者只需要知道外部接口。继承：子类可以继承父类的成员，又可以新增自己独有的成员，还可以覆盖父类的成员。多态：同名方法可以具有不同的行为，Java中有两种意义的多态：重载和重写。 2． 万物皆是对象，对象都有属性和行为。属性是对象所拥有的状态、数据，是静态的特征；行为是对象所拥有的功能、对数据的操作，是动态的特征，可能会影响到属性。 类封装了一类对象共有的属性和行为，是对具有相同属性和行为的对象的抽象。类是创建对象的模板，对象是类的具体实例。 3． （1）定义在类体内、方法外的变量称为成员变量。定义在方法体内部的变量，以及方法的形式参数，是方法所临时使用的变量，称为局部变量。 （2）成员变量在整个类体中都有效。而局部变量的有效范围仅限于定义它的方法体内，具体说明如下：①方法的形式参数：在整个方法体内有效；②方法体内独立定义的变量：在方法体中该变量定义之后的语句中有效；③选择、循环等语句块内定义的变量：只在语句块的{ }内有效。 （3）如果定义的成员变量没赋值，则系统为其提供缺省的初始值。所以成员变量定义后就有了确定的值，就可以使用。而方法的局部变量必须自行定义而且赋值后才能使用。（4）类成员变量在程序加载进内存时即开辟空间，实例成员变量在创建对象时开辟空间。局部变量只在方法调用时开辟空间，方法执行完毕后空间随即释放。 4． 多个方法名字相同，但参数个数或者类型不同，称为方法重载。方法返回值的类型和参数的名字不参与比较，方法重载是多态的一种体现。当调用方法时，根据传入的实参个数和类型，可以区分出调用的是哪一个方法。 5． 构造方法与所在类的类名完全相同，构造方法没有返回值类型，也不用void修饰。构造方法可以重载，一个类中可以定义多个构造方法。每个类中至少都有一个构造方法，如果未定义构造方法，系统会自动为该类生成一个缺省的没有参数的构造方法，如果类中定义了构造方法，就不再提供其他构造方法。 构造方法用new调用来创建对象，一般在构造方法中初始化成员变量。构造方法不能用static修饰。 三.编程题 1. classVecter3: def__init__(self,x=0,y=0,z=0): self.X=x self.Y=y 第4章继承与多态一．选择题 1. 编译和运行以下两文件结果是（ D ）。 //文件P1.java package MyPackage; class P1{ void afancymethod(){ System.out.println("What a fancy method"); } } //文件P2.java package YourPackage; import MyPackage.*; public class P2 extends P1{ public static void main(String argv[]){ P2 p2 = new P2(); p2.afancymethod(); } } A．两个均通过编译，P2运行时输出What a fancy method B．没一个通过编译 C．两个均通过编译，但P2运行时出错 D．P1 通过编译，但P2出现编译错误 2．下列程序运行的结果是（A ）。 package a; package b; public class D{ public static void main(String args[]) { System.out.println("^_^，今天心情不错！"); } } A．出现编译错误 B．^_^，今天心情不错！ C．通过编译，运行时出错 D．以上都不对 3．Java的核心类库中哪个包，Java系统能自动引入（B ）。 A．java.io B．https://www.wendangku.net/doc/c4736217.html,ng C．https://www.wendangku.net/doc/c4736217.html, D．java.util 4．下列程序运行结果是（ A ）。 private class Base{ Base(){ int i = 100; System.out.println(i); } 第5章继承与多态 本章讨论面向对象程序设计另外两个最重要的特点：继承和多态。 继承是面向对象程序设计方法中实现软件重用的一种重要手段，通过继承可以更有效地组织程序结构，明确类之间的关系，并充分利用已有的类来创建新类，通过继承可以实现代码的重用，以完成更复杂的设计、开发。 多态则可以统一多个相关类的对外接口，并在运行时根据不同的情况执行不同的操作，提高类的抽象度和灵活性。 5.1 子类、父类与继承机制 5.1.1 继承的概念 在类的定义过程中，继承是一种由已有的类创建新类的机制。继承而得到的类为子类，被继承的类为父类，父类包括所有直接或间接被继承的类。 在类的声明中加入extends子句就可以创建一个类的子类： class SubClass extends SuperClass {……} Java中不通过extends关键字支持多重继承，即extends之后只能有唯一的父类。如果缺省extends子句，则该类为https://www.wendangku.net/doc/c4736217.html,ng.Object的子类。子类可以继承父类中访问权限设定为public、protected和包可访问的成员变量和方法，但是不能继承访问权限为private的成员变量和方法。 一个父类可以同时拥有多个子类，而每一个子类则只能有唯一的父类。子类是对公共域和方法在功能、内涵方面的扩展和延伸。 父类、子类间的关系具有： 共享性即子类可以共享父类的公共域和方法。 差异性即子类和父类一定会存在某些差异，否则就应该是同一个类。 层次性即由Java规定的单继承性，每个类都处于继承关系中的某一个层面。 5.1.2 类的层次 Java语言中类的是有严格的层次结构的。 除Object类之外，每个类都继承惟一的父类。这种继承性性质使得类的层次结构形成了如图所示的一种树状结构。 Object类定义和实现了Java系统所需要的众多类的共同行为，它是所有类的父类，也即这个树状结构中的根类，所有的类都是由这个类继承、扩充而来的，这个Object类定义在https://www.wendangku.net/doc/c4736217.html,ng包中。 5.2 继承的实现 5.2.1 子类的定义 定义一个子类，即在定义一个类的时候加上extends关键字，并在之后带上其父类名，其一般格式为：[类的修饰符] class <子类名> extends <父类名>{ <域定义>; <方法定义>; } 这和前面定义类的格式并没有什么区别，只是在定义子类时“extends <父类名>”不再是可选项。自考Java语言程序设计(一)第五章以后课后习题及答案
继承与多态实验报告
JAVA基础 第4章继承与多态_练习题_200910
C++实验多态性实验报告
继承与多态性习题参考答案
java答案第五章
实验报告(四)继承和多态 (完整代码)
第五章 习题答案
JAVA基础第章继承与多态练习题
第5章继承与多态