最新多态练习题
1、生成表示学生的类XS，提供成员函数dispXM（）、dispXB（）和dispNL（）分别用来显示姓名、性别和年龄，并将他们全部定义为纯虚函数；生成CZS类表示初中生，包含数据成员xm、xb和nl表示学生的姓名、性别和年龄，提供成员函数dispXM（）、dispXB（）和dispNL()分别用来显示姓名、性别和年龄；再生成类GZS表示高中生和类DXS表示大学生，同样包含相同含义的数据成员xm、xb和nl，也包括成员函数dispXM（）、dispXB（）和dispNL（）。要求：
（1）设计和实现基本类XS
（2）设计和实现派生类CZS,GZS和DXS
（3）分别生成CZS、GZS、DXS类对象
（4）将CZS、GZS、DXS类对象的指针赋给指针赋给XS类的指针变量。
（5）分别用XS类的指针和引用访问dispXM（）、dispXB（）和dispNL（）函数。
（6）观察程序结果。
#include
#include
using namespace std;
class XS{
public:
virtual void dispXM()=0;
virtual void dispXB()=0;
virtual void dispNL()=0;
};
class CZS:public XS{
public:
CZS(char * m="张三",int b=1,int n=14);
void dispXM();
void dispXB();
void dispNL();
protected:
char xm[9];
int xb,nl;
};
CZS::CZS(char *m,int b,int n)
{
strcpy(xm,m);
xb=b,nl=n;
}
void CZS::dispXM()
{
cout<<"name:"< } void CZS::dispXB() { if(xb==1) cout<<"Man"< if(xb==0) cout<<"Woman"< } void CZS::dispNL() { cout<<"age:"< } class GZS:public XS{ public: GZS(char * m="张三",int b=1,int n=17); void dispXM(); void dispXB(); void dispNL(); protected: char xm[9]; int xb,nl; }; GZS::GZS(char *m,int b,int n) { strcpy(xm,m); xb=b,nl=n; } void GZS::dispXM() { cout<<"name:"< } void GZS::dispXB() { if(xb==1) cout<<"Man"< if(xb==0) cout<<"Woman"< } void GZS::dispNL() { cout<<"age:"< } class DXS:public XS{ public: DXS(char * m="张三",int b=1,int n=20); void dispXM(); void dispXB(); void dispNL(); protected: char xm[9]; int xb,nl; }; DXS::DXS(char *m,int b,int n) { strcpy(xm,m); xb=b,nl=n; } void DXS::dispXM() { cout<<"name:"< } void DXS::dispXB() { if(xb==1) cout<<"Man"< if(xb==0) cout<<"Woman"< void DXS::dispNL() { cout<<"age:"< } void displayP(XS *p) { p->dispXM(); p->dispXB(); p->dispNL(); } void displayR( XS &p) { p.dispXM(); p.dispXB(); p.dispNL(); } void main() { CZS czs("赵一",1,12); GZS gzs("钱二",0,15); DXS dxs("孙三",1,18); XS *p;//定义抽象基类的指针变量p p=&czs;//将初中生对象czs的地址赋给p displayP(p); p=&gzs;//将高中生对象czs的地址赋给p displayP(p); p=&dxs;//将大学生对象czs的地址赋给p displayP(p); cout<<"\n----------------------------------------\n"; XS &r1=czs;//定义抽象基类的引用变量r1为czs的别名 displayR(r1); XS &r2=gzs;//定义抽象基类的引用变量r2为czs的别名 displayR(r2); XS &r3=dxs;//定义抽象基类的引用变量r3为czs的别名 displayR(r3); cout<<"\n----------------------------------------\n"; } 2、某小型公司主要有3类人员：经理、兼职技术人员、兼职销售员。这些人员分别具有以下属性。 经理：姓名、编号、固定工资、当月薪水、计算月薪、显示信息 兼职技术人员：姓名、编号、工作小时、每小时工资额、当月薪水、计算月薪、显示信息； 兼职销售员：姓名、编号、销售额、销售额提成、当月薪水、计算月薪、显示信息 要求： 人员编号基数为1000，每输入一个人员信息编号顺序加1 月薪计算办法是经理固定月薪8000元；兼职技术人员按100元/小时领取月薪；兼职推销员按当月销售额的4%提成。根绝题目要求，设计一个基类employee，然后派生出technician （兼职技术人员）类、manager（经理）类和salesman（兼职销售员）类。 部分成员函数设置为虚函数 将“<<”和“>>”运算符 #include #include #include #include using namespace std; const int Maxr=100; class Employee //职工类 { int tag;//删除标记 int no;//职工编号 char name[20]; char zw[20];//职工姓名 int salary;//职工工资 public: Employee(){} char *getname() {return name;}//获取名字 int gettag() {return tag;}//获取标记 int getno() {return no;}//获取编号 int getsalary(){return salary;} void setzw(char q[])//设置名字 { strcpy(zw,q); } void setname(char na[])//设置名字 { strcpy(name,na); } void getsalary(int sa){salary=sa;} void delna(){tag=1;}//删除 void addemp(int n,int sa,char *na,char *q)//增加{ tag=0; no=n; salary=sa; strcpy(name,na); strcpy(zw,q); } void disp()//显示职工信息 { cout < <"│" < cout < <"├—————┼—————┼—————┼—————┤" < } }; class Database//职工数据类 { int top; Employee read[Maxr]; public: Database()//将职工信息从employee.txt读取到read[]中 { Employee s; top=-1; fstream file("employee.txt",ios::in); while (1) { file.read((char *)&s,sizeof(s)); if (!file) break; top++; read[top]=s; } file.close(); } void clear()//删除所有 { top=-1; } int addemp (int n, int sa,char *na,char*q) //增加职工 { Employee *p=query(n); if (p==NULL) { top++; read[top].addemp(n,sa,na,q); return 1; } return 0; } Employee *query(int empid) { for (int i=0;i <=top;i++) if (read[i].getno()==empid && read[i].gettag()==0) return &read[i]; return NULL; } Employee *query1(char empna[20]) { for (int i=0;i <=top;i++) if ((read[i].getname()==empna) && read[i].gettag()==0) return &read[i]; return NULL; } void disp() //职工信息显示 { for (int i=0;i <=top;i++) read[i].disp(); } void empdata(); ~Database() //将read[]中的信息读如到employee.txt中 { fstream file("employee.txt",ios::out); for (int i=0;i <=top;i++) if (read[i].gettag()==0) file.write((char *)&read[i],sizeof(read[i])); file.close(); } }; void Database::empdata()//职工维护 { int choice=1; int m=1;int b=1; char rname[20]; int empid; int empsa;char q[20]; Employee *r; while (choice!=0) { cout < <"职工维护1：新增2：更改3：删除4：查找5：显示6：全删0：退出=>"; cin>>choice; switch (choice) { case 1: cout < cout < cout < cout < cout < cout < while(m!=0){ switch(m) { case 1: cout < <"输入经理编号："; cin>>empid; cout < <"输入奖金: "; cin>>empsa; cout < <"输入经理姓名："; cin>>rname; addemp(empid,8000+empsa,rname,"经理"); break; case 2: cout < <"输入业务经理编号："; cin>>empid; cout < <"输入月提成: "; cin>>empsa; cout < <"输入业务经理姓名："; cin>>rname; addemp(empid,4000+empsa,rname,"业务经理"); break; case 3: cout < <"输入职工编号："; cin>>empid; cout < <"输入工资: "; cin>>empsa; cout < <"输入职工姓名："; cin>>rname; addemp(empid,empsa,rname,"普通职工"); break; } break; } break; case 2: cout < <"输入职工编号："; cin>>empid; r=query(empid); if (r==NULL) { cout < <"该职工不存在" < break; } cout < <"输入新的工资：" < cin>>empsa; r->getsalary(empsa); cout < <"请输入新的职务" < cin>>q; r->setzw(q); addemp(empid,empsa,rname,q); break; case 3: cout < <"输入职工编号："; cin>>empid; r=query(empid); if (r==NULL) { cout < <"该读者不存在" < break; } r->delna(); break; case 4: cout < cout < cout < cout < cout < cin>>b; while(b!=0){ switch(b) { case 1: cout < <"输入职工编号："; cin>>empid; r=query(empid); if (r==NULL) { cout < <"该职工不存在" < break; } cout < <"├—————┼—————┼—————┼—————┤" < cout < <"│" < cout < <"├—————┼—————┼—————┼—————┤" < r->disp(); break; case 2: break; } break; } break; case 5: cout < <"├—————┼—————┼—————┼—————┤" < cout < <"│" < cout < <"├—————┼—————┼—————┼—————┤" < disp(); break; case 6: clear(); break; } } } void main() { int choice=1;Database EmpDB; while(choice!=0) { cout < <"***************************************************************************** ***" < cout < cout < cout < cout < cout < cout < cout < cout < cout < cout < cout < cout < cin>>choice; switch(choice) { case 1: while(1){ cout < EmpDB.empdata(); break; break;} } } } 3、堆栈的特点是：先进先出 定义了一个堆栈类stack，包括初始化，压栈（就是将元素放在栈顶）、弹栈（取栈顶的一个元素），释放堆栈等操作 要求运用模版实现，堆栈中可以根据需求放入double、int、char*等数据对象。 4、上课教材的课后习题 实验四类的继承与多态 一、实验目的 1.掌握构造方法和成员方法重载的应用。 2.理解类的继承性的作用 3.领会面向对象编程的多态性。 二、实验内容与要求 基本概念 1．进一步理解继承的含义 新类可从现有的类中产生，并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时，不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的，就可以引用被继承类的全部成员。被继承的类称为父类或超类（superclass），这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的，因此，很少 有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类，如果你设计的这个类仅仅实现了继承，则和父类毫无两样。所以，通常要对子类进行扩展，即添加新的属性和方法。这使得子类要比父类大，但更具特殊性，代表着一组更具体的对象。继承的意义就在于此。 2．了解成员变量的隐藏方式 所谓隐藏是指子类重新定义了父类中的同名变量，在子类L ine 中重新定义了x为x1，y 为y1，隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时，操作的是子类的变量，子类执行父类的方法时，操作的是父类的变量。在子类中要特别注意成员变量的命名，防止无意中隐藏了父类的关键成员变量，这有可能给程序带来麻烦。 3．了解成员方法的覆盖方式 （1）方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法，但如果子类的方法与父类方法同名，则不能继承，此时称子类的方法覆盖了父类的方法，简称为方法覆盖（override）。方法覆盖为子类提供了修改父类成员方法的能力。 4．理解类的多态性类的继承发生在多个类之间，而类的多态只发生在同一个类上。在一个类中，可以定义多个同名的方法，只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁，为程序员带来很大便利。在O OP 中，当程序要实现多个相近的功能时，就给相应的方法起一个共同的名字，用不同的参数代表不同的功能。这样，在使用方法时不论传递什么参数，只要能被程序识别就可以得到确定的结果。 类的多态性体现在方法的重载（overload）上，包括成员方法和构造方法的重载。 实践应用 人类短串联重复序列(STR)的研究进展 短串联重复序列( Short tandem repeat ,STR)又称微卫星DNA， STR 是一种可遗传的不稳定的并且具有高度多态性的短的核苷酸重复序列. STR 多态性具有种类多,分布广,高度多态性等特点,并按孟德尔遗传规律[ 1 ]在人群中世代相传. 通过对STR 多态性的认识,极大地推动了人类基因组的研究. 这种多态性标志已广泛用于构建人类遗传连锁图谱、基因定位、遗传病诊断、肿瘤细胞染色体分离与重组以及亲子鉴定等法医学检查. DNA遗传标记的多态性研究发展按时间顺序可分为三代[4 ]。第1代遗传标记:限制性片段长度多态性( restriction fragment length polymorphism, RFLP)是Wyman 和White 于1980年偶然发现的,人类14号染色体上存在DNA片段长度有变化的区域,这些区域的结构特点是DNA由一段序列串联重复、首尾相接而成。重复次数可在几次至数百上千次之间变化。DNA重复单位长度在数bp至数十bp之间,组成串联重复的DNA是小卫星DNA。第2代遗传标记:短串联重复序列是由Holly等发现的重复单位的长度只有2～6 bp、重复次数一般在数次至几十次之间的串联重复DNA 序列,即微卫星DNA。微卫星DNA的等位基因片段的长度一般在400 bp 以下,故又称为短串联重复序列( STR)。第3代遗传标记:单核甘酸多态性( single nucleotide polymorphism, SNP)是单个碱基的置换、插入或缺失而形成的,是美国MIT提出的新一代多态性标记系统[5],近年来成为多种研究的焦点。虽然SNP的多态性位点是最多的,能比STR提供更全面的基因信息,但是STR还是以其独特的优点保存下来,仍被广泛的研究。 1.1 STR 的构成 STR 的核心序列为2～7bp ,呈串联重复排列.重复次数10～60 次左右,其总长度常小于400 bp.常见的有一、二、三、四核苷酸重复序列,约占真核生物基因组的5 %. 人类基因组的STR 单核苷酸重复以polyA ,polyT 多见,双核苷酸重复以(CA) n ,( GT) n , (AA) n , ( GG) n 常见, ( GC/ CG) 少见,其原因是由于3′端为G的C(即CPG) 易于甲基化. 三核苷酸重复以(CXG) n 类型常见,由于三核苷酸具有高度多态性,常用作DNA 的标记物. 每个特定位点的STR 均由两部分构成:中间的核心区和外围的侧翼区. 核心区含有一个以上称为“重复”的短序列,一般该重复单位的碱基对数目不变,而串联在一起的重复单位数目是随机改变的,如果用一种不切重复单位的限制性内切酶把DNA 分子切割成限制性片段,该限制性片段中位于核心区的外围即是侧翼区. 人群中不同个体可表现为侧翼区相同而串联重复单位的数目不同;也可为相同数目的重复单位,但侧翼区大小不同,或 C++的多态性实现机制剖析 ――即VC++视频第三课this指针详细说明 作者：孙鑫时间：2006年1月12日星期四 1.多态性和虚函数 我们先看一个例子： 例1- 1 #include 1、 编译的角度 C++编译器在编译的时候，要确定每个对象调用的函数的地址，这称为早期绑定（early binding ），当我们将fish 类的对象fh 的地址赋给pAn 时，C++编译器进行了类型转换，此时C++编译器认为变量pAn 保存的就是animal 对象的地址。当在main()函数中执行pAn->breathe()时，调用的当然就是animal 对象的breathe 函数。 2、 内存模型的角度 我们给出了fish 对象内存模型，如下图所示： 图1- 1 fish 类对象的内存模型 我们构造fish 类的对象时，首先要调用animal 类的构造函数去构造animal 类的对象，然后才调用fish 类的构造函数完成自身部分的构造，从而拼接出一个完整的fish 对象。当我们将fish 类的对象转换为animal 类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图1-1中的“animal 的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，输出animal breathe ，也就顺理成章了。 正如很多学员所想，在例1-1的程序中，我们知道pAn 实际指向的是fish 类的对象，我们希望输出的结果是鱼的呼吸方法，即调用fish 类的breathe 方法。这个时候，就该轮到虚函数登场了。 前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用迟绑定（late binding ）技术。当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用virtual 关键字（注意，这是必须的，很多学员就是因为没有使用虚函数而写出很多错误的例子），这样的函数我们称为虚函数。一旦某个函数在基类中声明为virtual ，那么在所有的派生类中该函数都是virtual ，而不需要再显式地声明为virtual 。 下面修改例1-1的代码，将animal 类中的breathe()函数声明为virtual ，如下： 例1- 2 #include 湖北工业大学工程技术学院实验报告 课程名称：面向对象程序设计实验内容：实验六继承性与多态性 学院：工程技术学院专业班级： 姓名：学号：指导教师： 实验日期：实验地点： 一、实验目的 1、1、了解多态性的概念。 2、2、了解虚函数的作用及使用方法。 3、3、了解纯虚函数和抽象类的概念和用法。 二、实验步骤 1.设计一个类层次，其中的基类为Date，它拥有一个相关数据成员及一个虚函 数print，从Date类派生ShortE、MediumDate和LongDate类，Date的print 函数使用日期格式：11-26-2015， ShortE的print函数使用日期格式：26-11-2015 MediumDate的print函数使用日期格式：Nov.26,2015 LongDate的print函数使用日期格式：November 26, 2015 编写一个程序来测试各个类的print函数。 #include day=d; } virtual void print() { cout< 醛糖还原酶5’端（AC）n二核苷酸重复序列多态性与2型糖尿 病合并冠心病的相关性 [摘要] 目的本研究旨在调查山东地区汉族人群醛糖还原酶（ar）5’端（ac）n二核苷酸重复序列多态性，探讨ar5’端（ac）n重复序列多态性与2型糖尿病（dm）、2型糖尿病合并冠心病（chd）之间的关系。方法随机选取新诊断2型糖尿病患者74例，2型糖尿病合并冠心病者68例，正常对照组116例。应用聚合酶链式反应（pcr）、琼脂糖凝胶电泳技术、聚丙烯酰胺凝胶电泳技术及dna 测序检测ar等位基因，比较各组等位基因分布频率。结果 3组均发现7种等位基因（z-6～z+6），各组间等位基因分布频率差异无统计学意义。结论 ar基因5’端（ac）n二核苷酸重复序列多态性等位基因不是糖尿病、糖尿病合并冠心病发病的独立危险因素。[关键词] 2型糖尿病；醛糖还原酶；基因；多态性；冠心病 [中图分类号] r587 [文献标识码] a [文章编号] 2095-0616（2013）15-21-03 relationship between an （ac）-n dinucleotide repeat polymorphic marker at 5’ end of the aldose reductase gene and type 2 diabetes mellitus with coronary heart disease xue yamei1 liu changshan2 wang xiujun2 lei peipei1 1.graduate faculty， weifang medical university， weifang 261053， china； 2.department of endocrinology， weifang people’s hospital of shandong province， weifang 261041， 多态性是面向对象编程三个重要特性之一。Java中的多态性是通过综合应用继承、覆 盖，以及向上转型实现的。本章首先综合阐述面向对象编程的这些重要特征，引申到代码中的多态概念、多态带来的好处，以及多态能够解决的问题。然后通过实例详细讨论多态技术 在编程中的应用。 3：如何在程序中最有效地计算众多不同几何体的表面积comArea ()? 计算表面积的方法，如comArea，包括其 他类似方法，如comArea，print()，等等，都可应用多态来解决。因为这 些方法都可以针对不同的几何体，进行运算和操作。即：形态不一、方法相同、内容多样。 public abstract class shape { public double area(){ return 0; } public void print(){ } } public class sphere extends shape{ private double r; public sphere(double r){ this.r=r; } public void print(){ System.out.println("球的半径："+r); } public double area(){ return Math.PI*r*r*r*4/3; } } public class comArea { public static void main(String[] args) { shape h[]; h=new shape[2]; h[0]=new sphere(10); h[1]=new square(10,10,10); Operator.areaMax(h); } } public class Operator { //将长方形和圆看做Shape类型 public static void areaMax(shape h[]){ shape max; for(int i=1;i 继承与多态习题 一.基本概念与基础知识自测题 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 关键字只对紧随其后的基类名起作用。 1 重复序列分析 重复序列广泛存在于真核生物基因组中，这些重复序列或集中成簇，或分散在基因之间，根据分布把重复序列分为分散重复序列和串联重复序列。 分散重复序列分为四种：LTR、LINE、SINE、和DNA转座子、 LTR，长末端重复转座子（long terminal repeat），是由RNA反转录而成的元件，它在两端有长大数百碱基对的LTR。Length： 1.5-10kbp Encode reverse transcriptase Flanked by 300-1000bps terminal repeats LINE，长散在重复序列（long interspersed nuclear elements），意为散在分布的长细胞核因子，是散在分布在哺乳动物基因组中的一类重复，这种重复序列比较长，平均长度大于1000bp，平均间隔3500-5000bp，如：rRNA，tRNA基因，形成基因家族。 SINE 为短散在重复序列（short interspersed nuclear elements）。SINE是非自主转座的反转录转座子，来源于RNA聚合酶III的转录物，它的平均长度约为300bp，平均间隔1000bp，如：Alu家族，Hinf家族序列。 DNA 转座子: single intron-less open reading frame Encode transposase Two short inverted repeat sequences flanking the reading frame。 串联重复序列根据重复序列的重复单位的长度可分为卫星DNA、小卫星DNA 和微卫星DNA。微卫星DNA又称为串联重复序列（short Tandem Repeat. STR） ●Simple Sequence Repeats (SSR)+Satellites GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG (G) ATATATATATATATATATATATATATATATATATATAT (AT)n 【实验目的】 1.深入理解多态的含义； 2.掌握使用抽象类实现多态的方法； 3.掌握使用接口实现多态的方法。 【实验准备】 复习配套教材相关章节的内容； 思考多态的意义和实现方法。 【实验内容】 项目一：使用抽象类实现多态。 1、在俄罗斯方块程序中，有L形，T形，田形等多种形状，它们是图形的多种形态，可以创建一个名为Shape的基类，而后派生L形，T形等，之后可以在运行时动态绘制各种形状。 1）创建一个名位Teris的控制台应用程序、 2）各个类之间的关系如下图所示： 3）创建名为Shape的抽象类，包括ShapeType属性和显示信息方法，以及抽象方法绘制： public abstract class Shape { private string shapeType; public string ShapeType { get { return shapeType; } set { shapeType = value; } } public void DisplayInfo() { Console.WriteLine("当前图形类型" + shapeType); } public abstract void Draw(); } 4）创建名为ShapeL的派生类，实现基类的绘制public class ShapeL : Shape { public ShapeL() { ShapeType = "L形"; } public override void Draw() { Console.WriteLine("|"); Console.WriteLine("|"); Console.Write("|"); Console.WriteLine("__"); } } 5）创建名为ShapeT的派生类，实现基类的绘制public class ShapeT : Shape { public ShapeT() { ShapeType = "T形"; } public override void Draw() { Console.WriteLine("_______"); Console.WriteLine(" |"); Console.WriteLine(" |"); } } 6）创建名为ShapeZ的派生类，实现基类的绘制public class ShapeZ : Shape { public ShapeZ() { ShapeType = "Z形"; } public override void Draw() { Console.WriteLine("----"); Console.WriteLine(" |"); Console.WriteLine(" |"); Console.WriteLine(" ----"); } } 7）创建名为ShapeBlock(田字形)的派生类，实现基类的绘制 class ShapeBlock : Shape C++的封装性、继承性和多态性概念 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。例如，在抽象的基础上，我们可以将时钟的数据和功能封装起来，构成一个时钟类。按c++的语法，时钟类的声明如下：class Clock { public: //共有成员，外部借口void SetTime(int NewH,int NewM,int NewS); void ShowTime(); private: //私有成员，外部无法访问int Hour,Minute,Second; } 可以看到通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强数据的安全性和简化程序的编写工作。什么是多态（Polymorphisn）？按字面的意思就是“多种形状”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等 的技术，赋值之后，>>>父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作<<<（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function）实现的。好，接着是“虚函数”（或者是“虚方法”）。虚函数就是允许被其子类重新定 义的成员函数。而子类重新定义父类虚函数的做法，称为“覆盖”（override），或者称为“重写”。“继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。 ... 继承是指一个对象直接使用另一对象的属性和方法。事实上，我们遇到的很多实体都有继承的含义。例如，若把汽车看成一个实体，它可以分成多个子实体，如：卡车、公共汽车等。这些子实体都具有汽车的特性，因此，汽车是它们的"父亲"，而这些子实体则是汽车的"孩子"。19. 多态的作用？主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用； 2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。 生物的基因组中，特别是高等生物的基因组中含有大量的重复序列，根据重复序列在基因组中的分布形式可将其分为串联重复序列（Tandem Repeats Sequence，TRS）和散布重复序列（Dispersed Repeats Sequence，DRS）。其中，串联重复序列是由相关的重复单位首位相连、成串排列而成的。目前发现的串联重复序列主要有两类：一类是由功能基因组成的（如rRNA和组蛋白基因）；另一类是由无功能的序列组成的。根据重复序列的重复单位的长度，可将串联重复序列分为卫星DNA、微卫星DNA、小卫星DNA等。 微卫星DNA又叫简单重复序列（Simple Sequence Repeat，SSR），指的是基因组中由1-6个核苷酸组成的基本单位重复多次构成的一段DNA，广泛分布于基因组的不同位置，长度一般在200 bp以下。研究表明，微卫星在真核生物的基因组中的含量非常丰富，而且常常是随机分布于核DNA中。在植物中通过对拟南芥、玉米、水稻、小麦等的研究表明微卫星在植物中也很丰富，均匀分布于整个植物基因组中，但不同植物中微卫星出现的频率变化是非常大的，如在主要的农作物中两种最普遍的二核苷酸重复单位（AC）n和（GA）n在水稻、小麦、玉米、烟草中的数量分布频率是不同的。在小麦中估计有3000个（AC）n序列重复和约6000个（G A）n序列重复，两个重复之间的距离平均分别为704 kb、440 kb，而在水稻中，（AC）n 序列重复约有1000个左右，（GA）n 重复约有2000个，重复之间的平均距离分别为450 kb、225 kb。另外在植物中也发现一些三核苷酸和四核苷酸的重复，其中最常见的是（AAG）n、（AAT）n。在单子叶和双子叶植物中SSR数量和分布也有差异，平均分别为64.6 kb和21.2 kb中有一个SSR。研究还发现，单核苷酸及二核苷酸重复类型的SSR主要位于非编码区，而有部分三核苷酸类型位于编码区。另外在叶绿体基因组中，目前也报道了一些微卫星，以A/T序列重复为主。 研究发现，微卫星中重复单位的数目存在高度变异，这些变异表现为微卫星数目的整倍性变异或重复单位序列中的序列有可能不完全相同，因而造成多个位点的多态性。如果能够将这些变异揭示出来，就能发现不同的SSR在不同的种甚至不同个体间的多态性，基于这一想法，人们发展了SSR标记。SSR标记又称为序列标签微卫星位点（sequence tagged mic rosatell ite site），简写为STMS，是目前最常用的微卫星标记之一。由于基因组中某一特定的微卫星的侧翼序列通常都是保守性较强的单一序列，因而可以将微卫星侧翼的DNA片段克隆、测序，然后根据微卫星的侧翼序列就可以人工合成引物进行PCR扩增，从而将单个微卫星位点扩增出来。由于单个微卫星位点重复单元在数量上的变异，个体的扩增产物在长度上的变化就产生长度的多态性，这一多态性称为简单序列重复长度多态性（Simple Sequence length polymorp 如何体现封装、继承、 编程人员看看！ 如何体现封装、继承、多态 编程人员看看！！ ！ 什么事封装？ 1. 保护数据成员， 不让类以外的程序直接访问或 修改，只能通过提供的公共的接口访问==>数据封 装。 2. 方法的细节对用户是隐藏的，只要接口不变， 内容的修改不会影响到外部的调用者==>方法封装。 3. 当对象含有完整的属性和与之对应的方法时称为 封装。 4. 从对象外面不能直接访问对象的属性， 只能通 过和该属性对应的方法访问。 5. 对象的方法可以接收对象外面的消息。 比如： Class A { private int prop; puplic int getProp() { return prop; } public void setProp(int prop) { this.prop = prop; } } 属性 prop 是 private 的，外界不能直接访问， 但是外界可以通过调用 getProp()和 setProp()的方 法， 给对象发消息，从而完成某种功能。 什么事多态？ 多态性的概念经常被说成事“一个接口，多种方 法”。这意味着可以为一组相关的动作作设计一个通 用 的接口。多态允许同一个接口被必于同一个类的多个 动作使用，这样就降低了程序的复杂性。再拿狗作比 喻， 一条狗的嗅觉是多态的。如果狗闻到猫的气味，它会 在吠叫并且追着它跑。如果狗闻到食物的气味，它将 分 泌唾液并向盛着食物的碗跑去。两种状况下同一种嗅 觉器官在工作，差别在于问到了什么气味，也就是有 两 种不同类型的数据作用于狗的鼻子!在 java 中，同一 个类中的 2 个或 2 个以上的方法可以有同一个名字， 只要 参数声明不同即可。在这种情况下，该方法就被称为 重载(Overload)，这个过程称为方法重载(Method overloading)。方法重载是 java 实现多态的一种方 式。 有两种方式可以实现多态：* 1. 继承(子类继承父类(包括 abstract class,interf ace ect)) 2. 重载(同一个类中) 如果是面向对象程序设计的话，面向对象程序设 计中的另外一个重要概念是多态性。在运行时，通过 指向 基类的指针，来调用实现派生类中的方法。可以把一 组对象放到一个数组中，然后调用它们的方法，在这 种场 合下，多态性作用就体现出来了，这些对象不必是相 同类型的对象。当然它们都继承自某个类，你可以把 这些 派生类都放到一个数组中。如果这些对象都有同名方 Java中的多态用法实例分析 多态分两种： (1)编译时多态（设计时多态）：方法重载。 (2)运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态） 运行时多态存在的三个必要条件： 一、要有继承（包括接口的实现）； 二、要有重写； 三、父类引用指向子类对象。 详细解释： 运行时多态的解释：a.运行时多态是指程序中定义的引用变量所指向的具体类型和b.通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定. 1.程序序中定义的引用变量所指向的具体类型不确定(即一个引用变量倒底会指向哪个类的实例对象)。 例子： driver类中drive方法（Vehicle类vehicle）{} oneDriver.drive(newcar()) oneDriver.drive(newbus()) 其中vehicle变量无法确定具体使用哪个子类实例。 1.通过该引用变量发出的方法调用在编程时并不确定(该引用 变量发出的方法调用到底是哪个类中实现的方法)。 例子:厨师，园丁，理发师的Cut方法调用.persion.cut(). 多态的好处： 1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。 2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。 3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法，puteArea()以及puteVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。 4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。 5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。 南京信息工程大学实验（实习）报告 实验（实习）名称类的继承性和多态性实验（实习）日期得分指导教师陈遥 系计算机专业网络工程年级 2014 班次 2 姓名刘信言学号 20142346074 一、实验目的 1.掌握Java语言的类的继承的概念。 2.掌握Java语言中抽象类的使用。 3.掌握Java语言中接口的使用 二、实验内容及步骤 1.类的继承，具体要求如下： (1)定义一Person类，该类具有属性人名、年龄、身份证号等信息以及将属性信息作为字符串返回的 方法； (2)定义一Student类，让该类继承Person类，该类除了具有属性人名、年龄、身份证号等信息以外还有学号，所在学校等信息；该类也具有将属性信息作为字符串返回的一方法； (3)编写测试类，测试这两个类 【源程序】 【运行效果图】 2.定义一个动物抽象类Animal,该类有一个抽象的方法cry()；定义一个小猫类Cat,该类继承了Animal 类并实现了cry()方法，当调用cry()方法时打印“小猫喵喵叫”，定义一个小狗类Dog,该类也继承了Animal类并实现了cry()方法，当调用cry()方法时打印“小狗汪汪叫”。 【源程序】 【运行效果图】 3. 接口的运用。 定义一接口接口名叫Usb,该接口声明了两个方法分别为start()和stop()方法，定义一U盘类UsbDiskWriter，一照相机类Camera、一手机类Mobile，让它们都实现该接口。 【源程序】 【运行效果图】 五、结果分析 1. 子类若想调用父类的构造函数必须要用super关键字。 2.接口体中只能运用抽象类。 3.在同一个java文件中只能在入口函数的类中用public。 第七章继承多态 一、选择题： 1、分析: class A { A() { } } class B extends A { //系统自动生成的构造方法和类的访问权限一样 } 哪两种说法是正确的? ( ) A:类B的构造方法是public的. B:类B的构造方法包含对this()的调用. C:类B的构造方法没有参数. D:类B的构造方法包含对super()的调用. 2、运行结果是:（） class Base { Base() { System.out.print("Base"); } } public class Alpha extends Base { public static void main( String[] args ) { new Alpha(); new Base(); } } A: Base B: BaseBase C: 编译失败. D: 没有输出. E: 运行时异常. 3. 程序的运行结果是?（） A: 编译失败. B: hello from a C: hello from b D: hello from b E: hello from a hello from a hello from b 4. 运行结果是:（） class TestSuper { TestSuper(int i) { } } class TestSub extends TestSuper{ } class TestAll { public static void main (String [] args) { new TestSub(); } } A: 编译失败. B: 程序运行没有异常. C: 第7行抛出异常. D: 第2行抛出异常. 5. 程序的运行结果是?（） A: 0 B: 1 C: 2 D: 编译失败. 6. 对于语句"B is a D" 和"B has a C"，一下哪两种说法是正确的? ( ) A:D是B. B:B是D. C:D是C. D:B是C. E:D继承B. F:B 继承D. 7. 运行结果是?（） C++多态的实现原理 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 3. 多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。 4. 多态用虚函数来实现，结合动态绑定。 5. 纯虚函数是虚函数再加上= 0。 6. 抽象类是指包括至少一个纯虚函数的类。 纯虚函数：virtual void breathe() = 0；即抽象类！必须在子类实现这个函数!即先有名称，没内容，在派生类实现内容! 我们先看一个例子： [cpp] view plaincopy 1. #include 18. { 19. public: 20. void breathe() 21. { 22. cout<<"fish bubble"< 西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科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.360docs.net/doc/6c1402803.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实验04 类的继承与多态
人类短串联重复序列
多态性实现机制
实验六继承性与多态性
醛糖还原酶5’端(AC)n二核苷酸重复序列多态性与2型糖尿病合并冠心病相关性
java多态的实际应用
继承与多态习题
重复序列分析文档
实验十五 C#多态实现(正确的)
C 的封装性、继承性和多态性概念
什么是简单重复序列(SSR)
如何体现封装、继承、多态 编程人员看看
Java中的多态用法实例分析
类的继承性和多态性
第七章继承多态练习题
C++多态的实现原理
Java继承与多态实验报告