程序： class MyDate{ private int year； private int month； private int day； public MyDate（ int year， int month，int day）{ this.year=year； this.month=month； this.day=day； } //Override Method } 为了让new MyDate（1980，11，9）==（判断是否相等）new MyDate（

题目

程序： class MyDate{ private int year； private int month； private int day； public MyDate（ int year， int month，int day）{ this.year=year； this.month=month； this.day=day； } //Override Method } 为了让new MyDate（1980，11，9）==（判断是否相等）new MyDate（1980，11，9）返回true，必须在Override Method处覆盖哪个方法？（）

A、 hashCode
B、 equals
C、 toString
D、 notify

相似考题

1.对于模板定义关键字class和typename说法不正确的是( )。A．程序中的class并不能都替换为typenameB．class和typename都可互相替换C．程序中的typename都能替换为ClassD．程序中的部分class可以替换为typename

2.使用VC6打开考生文件夹下的工程test10_1，此工程包含一个源程序文件test10_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果为；class Baseclass D1class D2class D3fin Base源程序文件test10_1.cpp清单如下：include＜iostream.h＞class Base{public:Base(){cout＜＜"class Base"＜＜endl;}void f(){cout＜＜"f in Base"＜＜endl;}};class D1:virtual public Base{public:D1(){cout＜＜"class D1"＜＜endl;}void f(){cout＜＜"f in D1"＜＜endl;}};／*********found**********／class D2:public Base{public:D2(){cout＜＜"class D2"＜＜endl;}／**********found**********／class D3::public D1，public D2{public:D3(){cout＜＜"class D3"＜＜endl;}};void main(){D3 d;／**********found************／d.f();}

3.有下列程序:include using namespace std; class TestClass1 { public: TestClass1(){有下列程序：include＜iostream＞using namespace std;class TestClass1{public:TestClass1(){cout＜＜"A";}};class TestClass2＜public:TestClass2(){cout＜＜"B";}};class TestClass3:public TestClass1{TestClass2 b;

4.有如下程序: include using namespace std; class A { public: virtual void f(){cout有如下程序：include＜iostream＞using namespace std;class A{public:virtual void f(){cout＜＜"1";}};class B:public A{public:B (){cout＜＜"2";}};class C:public B{public:virtual void f(){B::f();cout＜＜"3";}};int main(){A aa,*p;B bb;C cc;p=&cc;p-＞f();return 0;}执行上面程序的输出是______。

参考答案和解析

正确答案:B

更多“程序： class MyDa”相关问题

第1题：

以下程序的执行结果为______。include using namespace std; class base { public: vir

以下程序的执行结果为______。
include＜iostream＞
using namespace std;
class base
｛
public：
virtual void who()
｛
cout＜＜"base class"＜＜endl;
｝
｝;
class derivel：public base
｛
public：
void who()
｛
cout＜＜"d

正确答案：base class derivel class derive2 class
base class derivel class derive2 class
第2题：

有如下程序: include using namespace std; class A { public:

有如下程序： #include＜iostream＞ using namespace std; class A { public: A(){cout＜＜"A";} }; class B＜public:B(){cout＜＜"B";)); class C:public A { B b; public: C(){cout＜＜"C";} }; int main(){Cobj;retum 0;} 执行后的输出结果是
A．CBA
B．BAC
C．ACB
D．ABC

正确答案：D
解析：本题考查基类构造函数，数据成员构造函数的调用次序。系统首先要通过派生类的构造函数调用基类的构造函数，对基类成员初始化：然后对派生类中新增的成员初始化。
第3题：

有以下程序:include using namespace std; class Base { public: Base() { K=0; } int

有以下程序：
include＜iostream＞
using namespace std；
class Base
{
public：
Base()
{
K＝0；
}
int x；
}；
class Derivedl：virtual public Base
{
public：
Derivedl()
{
x＝10；
}
}；
class Derived2：virtua1 public Base

正确答案：20。
20。解析：本题中，虽然Derived1和Derived2由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1中修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obi；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x＝20。最后输出x的值为20。
第4题：

下面程序输出的结果为 #include"iostream．h" class A { public： A(){cout＜＜"CLASSA"＜＜endl；} ～A() {} }; class B：public A { public： B(){cout＜＜"CLASSB"＜＜endl；} ～B() {} }； void main() { A * p； p=new B； B *q； q=new B； }
A．CLASS A CLASS B
B．CLASS A CLASS B CLASS B
C．CLASS A CLASS B CLASS A CLASS B
D．CLASS A CLASS B CLASS B CLASS B

正确答案：C
解析：每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。注意：类的实例化和构造函数、析函数的调用方式和何时调用。
第5题：

下面程序输出的结果为
#include"iostream.h"
class A
{
public：
A( ){cout＜＜"CLASS A"＜＜endl；}
～A( ){}
}；
class B：public A
{
public：
B( ){cout＜＜"CLASS B"＜＜endl；}
～B( ){}
}；
void main( )
{
A*p；
p=new B；
B *q；
q=new B；
}
A．CLASS A CLASS B
B．CLASS A CLASS B CLASS B
C．CLASS A CLASS B CLASS A CLASS B
D．CLASS A CLASS B CLASS B CLASS B

正确答案：C
解析：每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。注意：类的实例化和构造函数、析构函数的调用方式和何时调用。
第6题：

对于模板定义关键宁class和typename说法不正确的是( )。
A．程序中的class并不能都替换为typename
B．class和typename都可互相替换
C．程序中的typename都能替换为class
D．程序中的部分class可以替换为typename

正确答案：B
第7题：

有如下程序:include using namespace std;class AA{public: virtual void f() {cout<

有如下程序: #include ＜iostream＞ using namespace std; class AA { public: virtual void f() { cout＜＜ "AA"; } }; class BB : public AA { public: BB() { cout ＜＜ "BB"; } }; cla
A．AA
B．AABBCC
C．BBAABBCC
D．BBBBAACC

正确答案：D
解析：本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。最后执行语句“p=&cc； p-＞f()；”，输出AA和CC。
第8题：

有如下程序: include using namespaee std; class A{ public: A( ){cout<<"A";}

有如下程序：
include＜iostream＞
using namespaee std；
class A{
public：
A( ){cout＜＜"A"；}
～A( ){cout＜＜"A"；}
}；
class B{
A a；
public：
B( ){cout＜＜"B"；}
～B( )t cout＜＜"B"；}
}；
int main( ){
B b；
return 0；
}
程序的输出结果是______。

正确答案：ABBA
ABBA
第9题：

有以下程序:include using namespace std;class Base{public:Base(){}virtual void w

有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){} virtual void who() { cout＜＜"Base Class"＜＜end1; } ～Base(){} }; class Derivel : public Base { public: void who() { cout＜＜"Derivel Class"＜＜end1; } }; class Derive2 : public Base { public: void who () { cout＜＜"Derive2 Class"＜＜end1; } }; int main () { Base *p; Derivel obj1; Derive2 obj2; p=&obj1; p=&obj2; p-＞who ( ); return 0; } 执行程序后的输出结果是( )。
A．Base Class
B．Derivel Class
C．Derive2 Class
D．程序编译时出错

正确答案：C
解析：本题考核虚函数的应用。本题中，先定义了一个基类Base，它含有一个虚成员函数who()，随后定义的类Derivel和Derive2都是基类Base的公有派生类。在主函数中定义了一个指向Base类的指针，它也被允许指向其派生类。在执行过程中，不断改变它所指向的对象，p-＞who就能调用不同的函数实现。这是因为使用了虚函数，因而进行动态联编。程序最后把指针p指向派生类Derive2的对象，由于函数who()在基类Base中是虚函数，所以系统调用Derive2中的who()函数，最后输出Derive2Class。
第10题：

下列程序片段中,能通过编译的是( )。 A.public abstract class Animal{ public void speak;}S

下列程序片段中，能通过编译的是（）。
A.public abstract class Animal{ public void speak；}
B.public abstract class Animal{ public void speak{)；}
C.public class Animal{ pubilc abstract void speak；}
D.public abstract class Animal{ pubile abstract void speak{}；}

正确答案：A
A。【解析】Java中一个类是一个abstract类的子类，它必须具体实现父类的abstract方法。如果一个类中含有abstract方法，那么这个类必须用abstract来修饰(abstract类也可以没有abstract方法)。有abstract方法的父类只声明，由继承它的子类实现。所以选A。
第11题：

下列程序的运行结果是______。 include class Base { public: virtual void func(int

下列程序的运行结果是______。
include＜iostream.h＞
class Base
{
public:
virtual void func(int i){cout＜＜"class Base:"＜＜i＜＜end1;)
};
class Derived: public Base
{
public:
void func(double d){cout＜＜"class Derived:"＜＜d＜＜endl;}
};
void main( )
{
Base a,*p=a;
Derived b;
p=&b;
(*p).func(3.3);
}

正确答案：class Base:3
class Base:3 解析：题中基类和派生类中有同名函数，但是参数不同。派生关系中，只有在函数类型、函数名和参数个数、参数类型完全相同时，才表现多态性。本题中参数不同，编译器便认为是两个完全不同的函数。通过基类的指针指向派生类对象时，该指针只能访问到派生类中具有多态性的成员函数，而与基类无关的函数是无法通过基类指针来访问的。故调用的是base类的 func函数，系统将3.3强制转化为整型数3。如果将派生类中的func的形参改为int型，则执行的就会是派生类的func函数，此时表现为多态。
第12题：

在下面程序的横线处填上适当的内容,使程序执行后的输出结果为ABCD。 include using nam

在下面程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD。
include＜iostream＞
using namespace std;
class A
{
public: A(){cout＜＜'A';}
};
class B:【】
{
public:B(){cout＜＜'B';)
};
class C:【】
{
public;C(){cout＜＜'C';}
};
class D:public B,public C
{
public:D(){cout＜＜'D';}
};
void main(){D obi;}

正确答案：virtual public A virtual public A
virtual public A virtual public A
第13题：

在下面程序的画线处填上适当的内容,使程序执行后的输出结果为ABCD。 include using

在下面程序的画线处填上适当的内容，使程序执行后的输出结果为ABCD。
include ＜iostream＞
using namespace std；
class A{
public：A( ){cout＜＜'A'；}
}；
class B： (11) {
public：B( ){cout＜＜'B'；}
{；
class C： (12) {
public：C( ){cout＜＜'C'；}
}；
class D：public B，public C{
public：D( ){cout＜＜'D'；}
}；
void main( ){
D( )；
cout＜＜endl；
}

正确答案：public A 空格
public A 空格解析：考查在继承中构造函数的调用顺序，创建派生类对象时依次调用基类的构造函数，最后调用派生类的构造函数。考查在继承中构造函数的调用顺序，创建派生类对象时依次调用基类的构造函数，最后调用派生类的构造函数。
第14题：

下列程序的输出结果为2,请将程序补充完整。 inelude using namespace std; class Bas

下列程序的输出结果为2，请将程序补充完整。
inelude＜iostream.h＞
using namespace std;
class Base
{
public:
______ void fun( ){cout＜＜1;}
};
class Derived: public Base
{
pbulic:
void fubn( ){cout＜＜2;}
};
int main( )
{Base*P=new Derived;
P→fun( );
delete P;
return 0;
}

正确答案：virtual
virtual 解析：本题考查虚函数的概念。在C++中，一个基类的指针可以用于指向它的派生类对象。而且通过这样的指针调用虚函数时，被调用的是该指针实际指向的对象类的那个重定义版本。在本题中，通过对象指针P调用的是派生类中重定的。fun函数，那么基类中的fun只有是虚函数才能满足要求。
第15题：

有如下程序:includeusing namespace std;class BASE{public:~BASE( ){cout<<"BASE";}

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public：～BASE( ){cout＜＜"BASE"；} }； class DERIVED：public BASE{ public：～DERIVED( ){cout＜＜"DERIVED"；} }； int main( ){DERIVED x；return 0；} 程序的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE

正确答案：D
解析：基类和派生类的析构函数的执行顺序是先执行派生类的析构函数，最后执行基类的析构函数；故先执行DIVERED的析构函数，后执行BASE的析构函数。
第16题：

编译下面源程序会得到—文件。 class A1 { } class A2 { } public class B { public static void main(String args[]) { } }
A．只有B.class文件
B．只有A1．class和A2．class文件
C．有A1．class、A2．class和B.class文件
D．编译不成功

正确答案：C
解析：Java语言一个源程序可以含有多个类，每个类编译都生成一个字节码文件。因此这里有3个类，应该有3个字节码文件。
第17题：

若有以下程序: include using namespace std; class Base { public:void who(){ cout

若有以下程序：
include ＜iostream＞
using namespace std;
class Base
{
public:
void who()
{
cout＜＜"class Base"＜＜end1;
}
};
class Derivedl : public Base
{
public:
void who()
{
cout＜＜"class Derivedl"＜＜end1;
}
};
class Derived2 : public Base
{
public:
void who()
{
cout＜＜"class Derived2"＜＜end1;
}
};
int main()
{
Base *p;
Derivedl obj1;
Derived2 obi2;
p=&obj 1;
p=&obj2;
p-＞who ( );
return 0;
}
则该程序运行后的输出结果是【】。

正确答案：class Derived2
class Derived2 解析：本题考核对象指针的应用。主函数中定义了一个Base类对象指针p，然后逐步被赋值为obj1和obj2，最后通过对象指针p调用函数who()，也即调用Derived2中的函数who()，输出class Derived2。
第18题：

有以下程序: include class A { intx; public: A(int a) { x=a;} friend class B;

有以下程序：
include＜iostream.h＞
class A
{
int x;
public:
A(int a)
{
x=a;
}
friend class B;
}
class B{
public:
void print(A a){
a. x--;
cout＜＜a.x＜＜end1;
}
};
void main()
{
A a(10);
B b;
b.print(a) ;
}
程序执行后的输出结果是【】。

正确答案：9
9 解析：本题考核友元类的应用。在程序中，类B是类A的友元类，因此，在类B的所有成员函数中均可访问类A的任何成员。在main()中，先定义类A的一个对象a(10)和类B的一个对象b。然后通过对象b调用其成员函数print输出对象a的私有成员x的值减1即9。
第19题：

有如下程序: include class x { protected: int a; public:x(){ a=1;} }; class x

有如下程序： #include ＜iostream.h＞ class x { protected: int a; public: x() { a=1; } }; class x1 : virtual public x { public: x1() { a+=1; cout＜＜a; } }; class x2 : virtual public x { public: x2() { a+=2; cout＜＜a; } }; class y : public xl,public x2 { public: y() { cout＜＜a＜＜end1; } }; int main() { y obj; return O; } 该程序运行后的输出结果是( )。
A．1
B．123
C．242
D．244

正确答案：D
解析：本题程序中引入了虚基类。在主函数main中，执行语句“yobj；”时，先执行虚基类x的构造函数，使a=1；然后执行类x1的构造函数，使a=2，并输出值2；再执行类x2的构造函数，使a=4，并输出值4；最后执行类y的构造函数，输出值4。
第20题：

下面程序输出的结果为 #include"iostream.h” class A ｛ public: A()｛cout＜＜"CLASSA"＜＜endl;｝～A() ｛｝｝; class B:public A ｛ public: B()｛cout＜＜"CLASS B"＜＜endl;｝～B()｛｝｝; void main() ｛ A*p; p＝new B;
A．CLASS A CLASS B CLASS B CLASS B
B．CLASS A CLASS B CLASS A CLASS B
C．CLASS A CLASS B CLASS B
D．CLASS A CLASS B

正确答案：C
第21题：

下面程序输出的结果为( )。 #inClUde”iostream.h” Class A {public： A(){cout＜＜“CLASS A”＜＜endl；} ～A()＜)}； class B：public A {public： B(){cout＜＜”CLASSB”＜＜endl；} ～B(){}}； void main() {A*p； p＝new B； B *q； q＝new B；}
A．CLASS A CLASS B
B．CLASS A CLASS B CLASS B
C．CLASS A ClASS B
D．CLASS A CLASS B CLASS A CLASS B CLASS B CLASS B

正确答案：C
解析：本题考查类的继承、类的实例化和构造函数、析构函数的调用方式和何时调用。每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。
第22题：

编译下面源程序会得到哪些文件( )? Class A4{ } Class A2{ } public class B{ public static void main(String args[ ]){ } }
A．只有B. class文件
B．只有A1.class和A2.class文件
C．有A1.class、A2.class和B. class文件
D．编译不成功

正确答案：C
解析：Java语言一个源程序可以含有多个类，每个类编译都生成一个字节码文件。因为这里有3个类，应该有3个字节码文件。
第23题：

以下程序的执行结果为______。include class A {public:A(){cout<<“a”;} ~A(){cout<<

以下程序的执行结果为______。
include＜iostream.h＞
class A
{public：A(){cout＜＜“a”；}
～A(){cout＜＜“b”；}}；
class B：public A
{public：
B(){cout＜＜“c”；)
～B(){cout＜＜“d”；}}；
void main()
{B b；}

正确答案：acdb。
acdb。解析：本题考查在继承中构造函数和析构函数的调用顺序。先调用基类的构造函数，再调用派生类的构造函数，调用析构函数时的顺序是先调用派生类的析构函数，后调用基类的析构函数。
第24题：

单选题
在C#程序中，如果类B要继承类A，类B正确的定义为（）。
A
public class B inherit A
B
public class B ：： A
C
public class B ： A
D
public class B from A

正确答案： D
解析：暂无解析

程序： class MyDate{ private int year； private int month； private int day； public MyDate（ int year， int month，int day）{ this.year=year； this.month=month； this.day=day； } //Override Method } 为了让new MyDate（1980，11，9）==（判断是否相等）new MyDate（

题目

相似考题

参考答案和解析

更多“程序： class MyDa”相关问题

相关内容