重写与重载的区别
实验组员：2014022124 陈剑明
2014022138 李欢欢
2014022129 张青
2014021033 周超艳
1.方法重写(Overriding)
在 java 语言中,利用 extends 关键字来表示一个类继承了另一个类。在 Java 中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写又称方法覆盖。若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表, 则新方法将覆盖原有的方法。如需父类中原有的方法,可使用super 关键字,该关键字引用了当前类的父类。重写方法只能存在于具有继承关系中 , 重写方法只能重写父类非私有的方法。
方法重写是指在子类中定义的一个方法,其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配,那么可以说,子类的方法重写了父类的方法。
图1.1 方法重写图
重写方法的规则：
1.1 参数列表必须完全与被重写的方法的相同 , 否则不能称其为重写而是重载。
1.2 返回类型必须与被重写的方法的返回类型相同,否则不是重写而是重载。访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)
图1.2 方法重写访问修饰符错误图
1.3 重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如,父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛
出 Exception,只能抛出IOException 的子类异常,可以抛出非检查异常。
图1.3 方法重写异常等级错误图
只允许多层继承，而不能多重继承:在JAVA中只允许单继承，不能使用多重继承，既一个子类只能继承一个父类，如图1.4与图1.5所示。但是允许进行多层继承，即一个子类可
以有一个父类，一个父类还可以有一个父类。如图1.6与图1.7所示：
图1.4多重继承图
图1.5 多重继承程序图
图1.6 多层继承图
图1.7 多层继承程序图
2.方法重载(Overloading)
方法重载是让类以统一的方式处理不同类型数据的一种手段。Java 的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。调用方法时
通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法, 这就是多态性。
图2.1 方法重载图
方法重载的规则:
2.1不能通过访问权限、返回类型重载。但实际上虽然会提示输入有误,但强制程序时程
序仍会执行。如图2.2所示：
图2.2 方法重载错误图
2.2方法的异常类型和数目不会对重载造成影响；
2.3必须具有不同的参数列表；
2.4可以有不同的返回类型,只要参数列表不同就可以了；
2.5可以有不同的访问修饰符；
2.6可以抛出不同的异常；
3.方法的重载与重写的区别
概要： C++中经常出现函数名字一样，但参数列表或返回值不同的函数，要搞清楚函数的正确调用关系，需理清三个概念：重写（override）、重载（overload）、重定义（redefine）。 一、三个基本概念 1、重定义（redefine）：派生类对基类的成员函数重新定义，即派生类定义了某个函数，该函数的名字与基类中的函数名字一样。 特点：（1）不在同一个作用域（分别位于基类、派生类）（2）函数的名字必须相同（3）对函数的返回值、形参列表无要求 特殊情况：若派生类定义的该函数与基类的成员函数完全一样（返回值、形参列表均相同），且基类的该函数为virtual，则属于派生类重写基类的虚函数。 作用效果：若重新定义了基类中的一个重载函数，则在派生类中，https://www.doczj.com/doc/ba14623127.html,基类中该名字的函数（即其他所有重载版本）都被自动隐藏，包括同名的虚函数。 2、重载（overload）：函数名字相同，但它的形参个数或者顺序，或者类型不同，但是不能靠返回类型来判断。 特点：（1）位于同一个类中（2）函数的名字必须相同（3）形参列表不同（可能是参数个数 or 类型 or 顺序不同），返回值无要求 特殊情况：若某一个重载版本的函数前面有virtual修饰，则表示它是虚函数。但它也是属于重载的一个版本 不同的构造函数（无参构造、有参构造、拷贝构造）是重载的应用 作用效果和原理：编译器根据函数不同的参数表，将函数体与函数调用进行早绑定。重载与多态无关，只是一种语言特性，与面向对象无关。 3、重写（override）：派生类重定义基类的虚函数，即会覆盖基类的虚函 数（多态性） 特点：（1）不在同一个作用域（分别位于基类、派生类）（2）函数名、形参列表、返回值相同（3）基类的函数是virtual 特殊情况：若派生类重写的虚函数属于一个重载版本，则该重写的函数会隐藏基类中与虚函数同名的其他函数。
重写是指重写基类的方法，在基类中的方法必须有修饰符virtual，而在子类的方法中必须指明override。 格式： 基类中： public virtual void myMethod() { } 子类中： public override void myMethod() { } 重写以后，用基类对象和子类对象访问myMethod()方法，结果都是访问在子类中重新定义的方法，基类的方法相当于被覆盖掉了。 重载 用于在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。 public void test(int x,int y){} public void test(int x,ref int y){} public void test(int x,int y,string a){} 重载特征： I.方法名必须相同 II.参数列表必须不相同，与参数列表的顺序无关 III.返回值类型可以不相同 ========================= 但如果有泛型，就要注意了！ 多态 c#的多态性主要体现在类的继承上: 子类继承父类的时候,可能出现同名但方法定义不同的情况, 所以在子类中会将原方法覆盖,实现自身的要求. using System; class Employee { virtual public void CalculatePlay() { Console.WriteLine("Employee");
} }; class SalariedEmployee: Employee { override public void CalculatePlay() { Console.WriteLine("Salary"); } }; class PolyApp { public static void Main() { Employee baseE1 = new Employee(); baseE1.CalculatePlay(); Employee baseE2 = new SalariedEmployee(); baseE2.CalculatePlay(); SalariedEmployee s = new SalariedEmployee(); s.CalculatePlay();
Java中布尔类型的常量有两种，它们是（true）和（false）。 Java中用于定义小数的关键字有两个：（float）和（double），后者精度高于前者。 在Java中定义一个字符串类型的变量str的语句是：（String str），定义一个具有10个元素的整型数组a的语句是：（int[] arr=new int[10]; 。 当声明一个数组int arr[] = new int[5]; 时，这代表这个数组所保存的变量类型是（int），数组名是（arr），数组的大小为（5），数组元素下标的使用范围是（0-4）. 异常处理是由（try）、（catch）和finally块三个关键所组成的程序块。 假设x=13，y=4，则表达式x%y != 0的值是（true），其数据类型是（boolean）。 下面程序段的执行结果是（6 5 4 3 2） int a[] = { 2, 3, 4, 5, 6 }; for (int i = a.length - 1; i >= 0; i--) System.out.print(a[i] + ""); 导入mypackage包中的所类的命令是（import mypackage.*;）。 如果将类MyClass声明为public，它的文件名称必须是（MyClass.java）才能正常编译。 Java中用于两个数相等比较的运算符是：（==），用于不相等比较的运算符是（< >）。 下列哪一个import命令可以使我们在程序中创建输入/输出流对象（import java.io.*;）. 定义一个接口必须使用的关键字是（interface ）. 分析选项中关于Java中this关键字的说法正确的是（this关键字是在对象内部指代自身的引用）. Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（C不仅继承了B中的成员，同样也继承了A中的成员). 在Java语言中，下列关于类的继承的描述，正确的是（一个类可以具有多个子类）。 在JA V A中，以下（java.util.HashMap）类的对象以键-值的方式存储对象. 在Java中,关于构造方法，下列说法错误的是(构造方法不可以重载).
package basetest; /** * * @author Administrator *案例分析：对于main最后一行代码有两个坑 *1.调用的是Test类的哪一个方法？ *这一步看重载 *2.对于传递的参数（son），方法体重调用的是谁的方法 *这一步看重写调用的是子类的方法 * * */ public class OverrideDemo { public static void main(String[] args) { Father father = new Son(); father.show();//运行期绑定：重写看对象（new的是谁调谁的方法） Test test = new Test(); test.test(father);//编译器绑定：重载看引用（等号前的类型是谁调谁的方法）} } class Test {
void test(Father father){ System.out.println("父型参数"); father.show(); } void test(Son son){ System.out.println("子型参数"); son.show(); } } class Father { protected void show(){ System.out.println("我是老子！"); } } class Son extends Father{ /** * Cannot reduce the visibility of the inherited method from Father 不能减少来自继承方法的可见性 子类访问权限要大于父类 */ /* void show(){ }*/ public void show(){ System.out.println("我是儿子!"); } public void show(String name){ System.out.println("我是儿子：名字是"+name); } }
C++ 重写重载重定义区别 1 Overload:是函数名相同，参数列表不同.重载只是在类的内部存在。但是不能靠返回类型来判断。 成员函数重载特征： a 相同的范围（在同一个类中） b 函数名字相同 c 参数类型、个数不同 d virtual关键字可有可无 2 Override：也叫做覆盖。重写（覆盖)是指派生类函数覆盖基类函数。子类重新定义了父类中有相同名称和参数的虚函数。函数特征相同。但是具体实现不同，主要是在继承关系中出现的。 特征是： a 不同的范围，函数分别位于基类和派生类中 b 函数的名字相同 c 参数相同 d 基类函数必须有virtual关键字（多态） 重写需要注意： 1 被重写的函数不能是static的。必须是virtual的 2 重写函数必须有相同的类型，名称和参数列表 3 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重 写改写为public,protected也是可以的 3重定义(redefining)也叫做隐藏: 子类重新定义父类中有相同名称的非虚函数( 参数列表可以不同) 。 如果一个类，存在和父类相同的函数，那么，这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型，否则试图对子类和父类做类似重载的调用是不能成功的。 重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下： a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。 b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。 综上所述，总结如下： 1 成员函数重载特征： a 相同的范围（在同一个类中） b 函数名字相同 c 参数不同 d virtual关键字可有可无 2 重写（覆盖)是指派生类函数覆盖基类函数，特征是： a 不同的范围，分别位于基类和派生类中 b 函数的名字相同 c 参数相同 d 基类函数必须有virtual关键字
实验4 类的继承和多态机制 一、实验目的 1、掌握类的继承机制； 2、掌握子类对父类构造方法的调用； 3、掌握方法覆盖和方法重载的区别。 二、实验内容 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 2、定义交通工具类Vehicle，一个小车类Car。实现Car对Vehicle的继承。 三、实验步骤 1、定义点类Point、圆类Circle、圆柱体类Cylinder。实现继承关系。 设计一个表示二维平面上点的类Point，包括表示坐标位置的成员变量x和y，获取和设置x和y值的方法。 设计一个表示二维平面上圆的类Circle，它继承自类Point，还包括表示圆半径的成员变量r、获取和设置r值的方法、计算圆面积的方法。 设计一个表示圆柱体的类Cylinder,它继承自类Circle，还包括表示圆柱体高的成员h、获取和设置h的方法、计算圆柱体表面积的方法、计算圆柱体体积的方法。 建立若干个Cylinder对象，输出其轴心位置坐标、半径、高、表面积及其体积的值。 class Point{ int x; int y; ;public Point(int x,int y){ 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){ super(x,y); r=m; } public double getR(){ return r; } public double circlearea(){ return PI*r*r;
继承、多态,重载、重写的区别与总结 李氏原则： （1）父类的引用指向子类对象。 -多态 （2）接口的引用指向实现类的实例。-接口 Polo咯， 什么是多态？它的实现机制是什么呢？重载和重写的区别在那里？这就是这一次我们要回顾的四个十分重要的概念：继承、多态、重载和重写 继承(inheritance) 简单的说，继承就是在一个现有类型的基础上，通过增加新的方法或者重定义已有方法（下面会讲到，这种方式叫重写）的方式，产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一，我们在使用JAVA 时编写的每一个类都是在继承，因为在JAVA语言中，https://www.doczj.com/doc/ba14623127.html,ng.Object类是所有类最根本的基类（或者叫父类、超类），如果我们新定义的一个类没有明确地指定继承自哪个基类，那么JAVA就会默认为它是继承自Object类的。 我们可以把JAVA中的类分为以下三种： 类：使用class定义且不含有抽象方法的类。 抽象类：使用abstract class定义的类，它可以含有，也可以不含有抽象方法。接口：使用interface定义的类。 在这三种类型之间存在下面的继承规律： 类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。 抽象类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。 接口只能继承（extends）接口。 请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements，它们是不可以随意替换的。大家知道，一个普通类继承一个接口后，必须实现这个接口中定义的所有方法，否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系，而且对于抽象类implements接口的情况下，它并不是一定要实现这个接口定义的任何方法，因此使用继承的说法更为合理一些。 以上三条规律同时遵守下面这些约束： 类和抽象类都只能最多继承一个类，或者最多继承一个抽象类，并且这两种情况是互斥的，也就是说它们要么继承一个类，要么继承一个抽象类。 类、抽象类和接口在继承接口时，不受数量的约束，理论上可以继承无限多个接
【转】C#中继承实现父类方法、重写、重载 继承是派生类（）去实现（重写
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。 初次见到这两个单词并没有什么特别的感觉，但是时间长了，却发现书上一会儿用overri de，一会儿又用overload，搞得我的迷迷糊。于是就做了个总结，希望能对和我一样对这两个概念模糊不清的网友有一个帮助。 override为覆盖又叫重写，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点： 1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载. 2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>d efault>private）。 3、重写的方法的返回值必须和被重写的方法的返回一致； 4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类； 5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。 6、静态方法不能被重写为非静态的方法（会编译出错）。（也就是说重载后的方法要是static方法） overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点： 1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, fl oat)，但是不能为fun(int, int)）； 2、不能通过访问权限、返回类型、抛出的异常进行重载； 3、方法的异常类型和数目不会对重载造成影响； 下面是对override和overload的测试程序，其中注释中的内容都是会产生编译错误的代码，我们将注释去掉，看看在编译时会产生什么效果。 // 对overload测试的文件：OverloadTest.java public class OverloadTest { // 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。 public void fun(){ System.out.println("method fun in OverloadTest, no parameter");
1. 父类：public virtual string ToString(){return "a";} 子类：public override string ToString(){return "b";} 2. 同一类中或父子关系类中皆可： public string ToString(){return "a";} public string ToString(int id){return id.ToString();} override是用于重写基类的虚方法,这样在派生类中提供一个新的方法 重载是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制 很本质的区别就是看函数特征：覆写（Override）的两个函数的函数特征相同，重载（Overload）的两个函数的函数名虽然相同，但函数特征不同。 函数特征包括函数名，参数的类型和个数。 Override 是在继承的时候，如果你写的函数与要继承的函数函数特征相同，那么，加上这个关键字，在使用这个子类的这个函数的时候就看不见父类（或超类）的函数了，它被覆盖掉了。 比如：Derived继承了Base，Base里面有void A(int a) 那么如果你Derived里面觉得A写得不好或不适合这个类，你想重新再写一遍A里的代码，那么就写override void A(int a)这样，原来的那个函数就被你新写的这个覆盖掉了。Overload 是重载，就是说函数名相同，函数特征不同，系统会根据你提供的参数来调相应的函数。 比如：void A(int a)和void A(int a,int b) 如果你用的是A(1)那么调的是第一个，如果是A(1,1)那么调的是第二个。 ================================================= 1. override ----------- 使用override 修饰符来修改方法、属性、索引器或事件。重写方法提供从基类继承的成员的新实现。由重写声明重写的方法称为重写基方法。重写基方法必须与重写方法具有相同的签名。 不能重写非虚方法或静态方法。重写基方法必须是虚拟的、抽象的或重写的。 也就是说，用override 修饰符重写的基类中的方法必须是virtual, abstract 或override 方法。 2. 重载 ------- 当类包含两个名称相同但签名不同的方法时发生方法重载。 使用重载方法的指南: a. 用方法重载来提供在语义上完成相同功能的不同方法。
一、单项选择题 1、如下哪个是Java中的标识符（） A、public B、super C、3number D、width 2、如下哪个是Java中的标识符( ) A、fieldname B、super C、3number D、#number 3、已知如下定义：String s = "story"; 下面哪个语句不是合法的( ) A、s += "books"; B、s = s + 100; C、int len = s.length; D、String t = s + “abc”; 4、如下哪个是Java中有效的关键字() A、name B、hello C、false D、good 5、下面的代码段执行之后count的值是什么( ) int count = 1; for (int i = 1; i <= 5; i++) { count += i; } System.out.println(count); A、5 B、1 C、15 D、16 6、定义一个类，必须使用的关键字是( ) A、public B、class C、interface D、static 7、定义一个接口必须使用的关键字是（） A、public B、class C、interface D、static 8、如果容器组件p的布局是BorderLayout，则在p的下边中添加一个按钮b，应该使用的语句是（） A、p.add(b); B、p.add(b,"North"); C、p.add(b,"South"); D、b.add(p,"North"); 9、声明并创建一个按钮对象b，应该使用的语句是（） A、Button b=new Button(); B、button b=new button();
复习重点 ●java 语言基本组成 ●标识符、关键字 ●java 基本数据类型 ●面向对象基本思想与方法 ●类、对象与封装的基本概念 ●类与对象/ 类的继承/ 抽象类与接口 ●异常概述/ 异常捕获与处理 ●线程概述/ 线程的生命周期 面向对象程序设计复习题 一、单选 1．对象是构成现实世界的一个独立单位，它具有自己的静态特征和（）特征。 A. 颜色 B. 动态 C. 状态 D. 重量 3．Java语言的主要特点不包括（）。 A. 面向对象 B. 自动垃圾回收 C. 处理文件 D. 可移植性 4. 具有相同属性和服务的一组对象的模板称为（）。 A. 程序 B. 类 C. 代码 D. 概念 5．组成Java程序的最小单位是（）。 A. 类 B. 方法 C. 变量 D. 常量
6．在Java程序中包含主方法的类被称为主类，主方法的访问控制修饰符为（）。 A. private B. protected C. public D. static 7．先执行循环体，后进行循环条件判断的语句是（）。 A. for B. while C. if D. do…while 8．在类的定义中，若需要把一个标识符定义为常量，则使用的修饰符为（）。 A. const B. final C. static D. class 9．在程序中引入包的语句关键字为（）。 A. volatile B. pack C. import D. package 10．在派生类的定义中，继承父类子句所使用的关键字为（）。 A. extends B. implements C. public D. abstract 11．在一个方法的方法头（声明）中向调用它的上一层方法抛出异常的子句关键字为（）。 A. catch B. throw C. throws D. finally 12．具有（）访问权限的成员能够被本类和同一包中的其他任何类中的成员所访问。 A. 公有 B. 保护 C. 私有 D. 缺省 13．具有（）访问权限的成员能够被本类和任何其他类中的成员所访问。 A. public B. protectd C. private D. 缺省 14．在类定义首部的语法格式中，（）不能作为其中的修饰符。 A. abstract B. implements C. private D. final
有时候，类的同一种功能有多种实现方式，到底采用那种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。public void train (Dog dog){ //训练小狗站立，排队，做算数 } public void train(Monkey monkey){ //训练猴子骑自行车等 } 再如某个类的一个功能是比较两个城市是否相同，一种方式是比较两个城市的名字，一种是除了比较两个城市的名字外，还要比较所在国家的名字。 publi boolean isSameCity (String city1,String city2){ return city1.equals(city2); } public boolean isSameCity(String city1,String city2,Stirng Country1,String Country2){ return isSameCity(city1,city2)&&Country1.equals(Country2); } 在例如 https://www.doczj.com/doc/ba14623127.html,ng.Math 类的 max （）方法能够从两个数字中取出最大值，它有多种实现方式。 public static int max(int a,int b) public static int max(long a, long b) public static int max(float a,float b) 以下程序多次调用Math 类的max() 方法，运行时，Java 虚拟机先判断给定参数的类型，然后决定到底执行哪个 max()方法。 // 参数为 int 类型，因此执行max（int a, int b）方法 Math.max(1,2); //参数为 flloat 类型，因此执行 max(float a, float b) 方法 Math.max(1.0F,2.9F); 对于类的方法（包括从父类中继承的方法）如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。 重载方法满足以下条件 方法名相同 方法的参数类型，个数，顺序至少有一项不相同 方法的返回类型可以不相同 方法的修饰符可以不相同 在一个类中不允许定义另个方法名相同，并且参数签名也完全相同的方法。假如存在这样的两个方法，Java 虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型，个数和顺序。 例如：public class Sample { public void amethod(int i,String s){} } 下面哪个方法可以加入到 Sample 类中去？ public void amethod(String s,int i) //OK public int amethod(int i,String s){return 0} //NO
C++中重载与重写函数区别及虚函数 C++中的虚函数(virtual function) 1.简介 虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。假设我们有下面的类层次： class A { public: virtual void foo() { cout << "A::foo() is called" << endl;} }; class B: public A { public: virtual void foo() { cout << "B::foo() is called" << endl;} }; 那么，在使用的时候，我们可以： A * a = new B(); a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的! 这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。
虚函数只能借助于指针或者引用来达到多态的效果，如果是下面这样的代码，则虽然是虚函数，但它不是多态的： class A { public: virtual void foo(); }; class B: public A { virtual void foo(); }; void bar() { A a; a.foo(); // A::foo()被调用 } 1.1 多态 在了解了虚函数的意思之后，再考虑什么是多态就很容易了。仍然针对上面的类层次，但是使用的方法变的复杂了一些： void bar(A * a) { a->foo(); // 被调用的是A::foo() 还是B::foo()？ } 因为foo()是个虚函数，所以在bar这个函数中，只根据这段代码，无从确定这里被调用的是A::foo()还是B::foo()，但是可以肯定的说：如果a
一．选择题： 1. 下面哪些为构造函数的特性定义（选 一项） d a. 在类中声明构造函数时，名称应该与类名相同 b. 具有重载特性，可以建立多个相同 的名称 c. 使用类建立新对象时，会自动执行 构造函数，因此在构造函数内设定变 量的初值或进行内存分配 d. 以上都是 2. 关于异常处理机制的叙述哪些正确 （选择两项）bc a. catch部分捕捉到异常情况时，才会 执行finally部分（无论是否有毛病，都执行） b. 当try区段的程序发生异常时，才会 执行catch区段的程序 c. 不论程序是否发生错误及捕捉到异 常情况，都会执行finally部分 d. 以上都是 3. 下列关于接口的叙述中哪些是正确的 （选择两项）b a a. 接口中的数据必须设定初值（就是 接口中的常量） b. 接口中的方法都是抽象方法 c. 接口可以声明引用Area d. 以上都正确 4. Java语言中，方法的重写（Overriding） 和重载（Overloading）是多态性的不同表 现。下边哪些说法是对的？（选择两项） C、A A．重写是父类与子类之间多态性的一种表现。 B．重写是一个类中多态性的一种表现。 C．重载是一个类中多态性的一种表现。 D．重载是父类与子类之间多态性的一种表现。 5、下列对Java中的继承描述错误的说法是（A）。 A.子类至少有一个基类(至多有一个父 类) B.子类可作为另一个子类的基类 C.子类除了包含它直接定义的属性外，还 包含其父类的私有属性 D.子类继承父类的方法访问权限保持不 变 6．try {}里有一个return语句，那么紧跟在这个try后的finally {}里的代码会不会被执行，什么时候被执行？c A.不会执行 B.会执行，在return前执行 C.会执行，在return后执行 D.会执行，可能在return前执行，也可能 在return后执行 7. 构造方法是否可被重写和重载（b）。 A.不能重写，可以重载 B.可以重写，不能重载 C.不能重写，不能重载 D.可以重写，可以重载 8. 下列属于方法重载好处的是（B,D）。（两项） A.实现多态 B.方法名的复用 C.提高程序运行速度 D.使用方便，提高可读性 9. 面向对象方法的多态性是指（C）。 A.一个类可以派生出多个特殊类 B.一个对象在不同的运行环境中可以有 不同的变体 C.拥有相同父类或接口的不同对象可以 以适合自身的方式处理同一件事 D.一个对象可以是由多个其他对象组合 而成的 10. Dog是Animal的子类，下面代码错误的是（C）。 A.Animal a = new Dog(); B.Animal a = (Animal )new Dog(); C.Dog d = (Dog)new Animal();
18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？ 常考的题目。从定义上来说： 重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。 重写：是指子类重新定义复类虚函数的方法。 从实现原理上来说： 重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！ 重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。 19. 多态的作用？ 主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。 20. Ado与https://www.doczj.com/doc/ba14623127.html,的相同与不同？ 除了“能够让应用程序处理存储于DBMS 中的数据“这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而https://www.doczj.com/doc/ba14623127.html, 拥有自己的https://www.doczj.com/doc/ba14623127.html, 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，https://www.doczj.com/doc/ba14623127.html, 接口也就完全不同于ADO和OLE DB 接口，这也就是说https://www.doczj.com/doc/ba14623127.html, 和ADO是两种数据访问方式。https://www.doczj.com/doc/ba14623127.html, 提供对XML 的支持。 21.New delete 与malloc free 的联系与区别? 答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor. 22.#define DOUBLE(x) x+x ，i = 5*DOUBLE(5)； i 是多少？ 答案：i 为30。 23. 有哪几种情况只能用intialization list 而不能用assignment?
1．Java中，main方法的声明格式包括 public void main( args[])。 2．面向对象的程序设计具有三大基本原则：_ 3．Java中数组的下标（索引号）从开始。 4．在一个类的内部嵌套定义的类称为。 10．java.awt包中提供了3种常用的容器：Frame、Panel和Applet。 11．布尔型常量有两个值，它们分别是_ _和_ __。 12．定义类用的关键字是；继承类用的关键子是；实现接口用的关键字是 13．类的成员只能被该类的成员访问，不能被非该类的成员访问。 9．能够运行的Java应用程序必须包含一个方法是_ _____。 11．定义文件对象，要用到类。 12．关键字用来调用父类的构造方法。 四、简答题 1．Java语言的特点有哪些？简要说明。 答：Java是一种简单的、面向对象的、分布式的、健壮的、安全的、体系结构中立的、可移植的、高性能的、多线程的和动态的语言。 2．Java中，能够存储字符串的类哪两个？这两个类有什么区别？ 答：JA V A平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。 3．Java应用程序分为几类？各有什么特点？ 答：Java应用程序分为Application和Applet两类。Application经编译后由JVM直接解释执行；Applet经编译生成．class代码后，嵌入到某个HTML文件中，由浏览器解释执行。一个java应用程序必须且只有一个类含有main方法,这个类称为应用程序的主类，其main方法必须被说明为public static void 一个Java Applet小应用程序不再需要main方法，但必须有一个类扩展了Applet类，即它是Applet类的主类。 4．构造方法与一般成员方法有何区别？ 答：构造方法与一般方法的区别体现在：构造方法的方法名与类名相同；构造方法一定没有返回值类型；构造方法不能像一般方法那样用形如“对象．方法名”显式地直接调用，而应该使用new运算符调用构造方法为新对象进行初始化。 1．简要说明对象和类的定义，并说出两者的关系。 答：对象:存在的具体实体,具有明确定义的状态和行为. 类:具有相同属性和共同行为的一组对象的集合. 关系:类是用来描述实体的”模板”或”原型”,对象是实际的实体.每一个对象都是类的一个实例. 类是对象的原型,它为特定类型的对象指定了允许的操作和必需的特性 2．什么是Java Applet生命周期？一个Java Applet的生命周期包括哪些函数？这些函数的执行顺序是什么？ 答：一个Java Applet的执行过程称为这个Java Applet的生命周期 一个完整的Java Applet所包含4个方法init( ) 、start( ) 、stop( )、destroy( ) 3．什么是方法重载和方法重写？二者有什么区别？ 答：方法重载是一个类中的两个方法，具有相同的方法名，但方法参数不同。包括参数个数或者参数类型不同。 方法重写是具有继承关系的两个类中的两个方法，具有相同的方法名、相同的参数和相同的返回值，但是方法体实现不同。 4．java中如何定义和使用接口？ 使用关键字interface来定义一个接口，接口的定义和类的定义很相似，分为接口的声明和接口体。 一个类通过关键字implements声明自己使用一个或多个接口，如果使用多个接口，则用逗号隔开接口。 如果一个类使用某个接口，那么这个类必须实现该接口的所有方法 简述软件生命周期开发方法的基本过程及每个阶段的任务。 1．简单列举Java语言的特点 答：Java是一种简单的．面向对象的．分布式的．健壮的．安全的．体系结构中立的．可移植的．高性能的．多线程的和动态的语言。 2．子类如何去调用父类的构造方法，使用什么关键字，并注意什么？ 答：使用super关键字调用父类构造方法．super应写于子类构造方法的第一句．创建对象时总是先调用父类构造方法再调用子类构造方法．并且调用的是该类的直接父类。 3．什么是包，用途是什么？如何导入包？ 答：包是将类组合在一起形成代码模块的一种机制,是一个文件夹。 用途:（1）包允许将类组合成较小的单元,使其易于找到和使用相应的类文件; （2）有助于避免冲突; （3）包允许在更广的范围内保护类,数据和方法,可以在包内定义类,根据规则包外的代码有可能不能访问该类.
对比于C语言的函数，C++增加了重载（overloaded）、内联（inline）、const和virtual四 种新机制。其中重载和内联机制既可用于全局函数也可用于类的成员函数，const与virtual 机制仅用于类的成员函数。重载和内联肯定有其好处才会被C++语言采纳，但是不可以当成 免费的午餐而滥用。本章将探究重载和内联的优点与局限性，说明什么情况下应该采用、不 该采用以及要警惕错用。 8.1 函数重载的概念 8.1.1 重载的起源 自然语言中，一个词可以有许多不同的含义，即该词被重载了。人们可以通过上下文来 判断该词到底是哪种含义。“词的重载”可以使语言更加简练。例如“吃饭”的含义十分广泛， 人们没有必要每次非得说清楚具体吃什么不可。别迂腐得象孔已己，说茴香豆的茴字有四种 写法。在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，即函数载。这 样便于记忆，提高了函数的易用性，这是C++语言采用重载机制的一个理由。例如示例8-1-1 中的函数EatBeef,EatFish,EatChicken可以用同一个函数名Eat表示，用不同类型的参数加 以区别。 void EatBeef(…); // 可以改为void Eat(Beef …); void EatFish(…); // 可以改为 void Eat（Fish …); void EatChicken(…); // 可以改为 void Eat(Chicken …); 示例8-1-1 重载函数Eat C++语言采用重载机制的另一个理由是：类的构造函数需要重载机制。因为C++规定构造函数 与类同名（请参见第9章），构造函数只能有一个名字。如果想用几种不同的方法创建对象该 怎么办？别无选择，只能用重载机制来实现。所以类可以有多个同名的构造函数。 8.1.2 重载是如何实现的？ 几个同名的重载函数仍然是不同的函数，它们是如何区分的呢？我们自然想到函数接口 的两个要素：参数与返回值。如果同名函数的参数不同（包括类型、顺序不同），那么容易区 别出它们是不同的函数。 如果同名函数仅仅是返回值类型不同，有时可以区分，有时却不能。例如： void Function(void); int Function (void);上述两个函数，第一个没有返回值，第二个的返回值是int类型。如 果这样调用函数： int x = Function (); 则可以判断出Function是第二个函数。问题是在C++/C程序中，我们可以忽略函数的返回值。 在这种情况下，编译器和程序员都不知道哪个Function函数被调用。 所以只能靠参数而不能靠返回值类型的不同来区分重载函数。编译器根据参数为每个重载函 数产生不同的内部标识符。例如编译器为示例8-1-1中的三个Eat函数产生象_eat_beef、 _eat_fish、_eat_chicken之类的内部标识符（不同的编译器可能产生不同风格的内部标识符）。 如果C++程序要调用已经被编译后的C函数，该怎么办？ 假设某个C函数的声明如下：