设有如下代码：class Base{}public class MyCast extends Base{static boolean b1=false;static int i = -1;static double d = 10.1;public static void main(String argv[]){MyCast m = new MyCast();Base b = new Base();//Here}}则在 //Here处插入哪个代码将不出现编译和运行错误。A.b=m;B.m=b;C.d =i;
题目
设有如下代码：
class Base{}
public class MyCast extends Base{
static boolean b1=false;
static int i = -1;
static double d = 10.1;
public static void main(String argv[]){
MyCast m = new MyCast();
Base b = new Base();
//Here
}
}
则在 //Here处插入哪个代码将不出现编译和运行错误。
A.b=m;
B.m=b;
C.d =i;
D.b1 =i;
相似考题
更多“设有如下代码:class Base{}public class MyCast extends Base{static boolean b1=false;stat ”相关问题
-
第1题：
有如下程序: includeusing namespace std; class BASE { public 有如下程序： #include＜iostream＞ using namespace std; class BASE { public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE { public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVEDx;retum 0;} 执行后的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：本题考查基类析构函数和派生类析构函数的调用次序。 -
第2题：
如下程序的输出是includeusing namespace std;class Base{public:Base( ){cout<<"BB" 如下程序的输出是 #include＜iostream＞ using namespace std； class Base{ public： Base( ){cout＜＜"BB"；f( )；} void f( ){cout＜＜"Bf"；} }； class Derived：public Base{ public： Derived( ){eout＜＜"DD"；} void f( ){cout＜＜"Df"；} }； int main( ){Derived d；return 0；}
A．BBBff)D
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析：当创建派生类对象时，首先调用基类的构造函数，最后调用派生类的构造函数。 -
第3题：
有以下程序:includeusing 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题：
执行下列代码后，输出的结果为( )。 class Base { int x = 30; void setX( ) {x=1O;} } class SubClass extends Base { int x=40; void setX ( ) {x=20;} int getX( ) {return super. x; } } public class Test { public static void main(String[ ] args) { SubClass sub=new SubClass( ); sub. setX( ); System. out. println(sub, getX( ) ); } }
A．10
B．20
C．30
D．40
正确答案：C
解析：本题主要考查有关类的继承方面的知识。Java中，类是分层次的，当子类的成员变量与父类的成员变量名字相同时，子类的成员变量会隐藏父类的成员变量，当子类的成员方法与父类的成员方法名字、参数列表、返回值类型都相同时，子类的方法是父类的方法的重写。这样，在子类的对象调用方法时，是按照子类中方法定义执行，隐藏父类的方法的定义。当子类隐藏了父类的变量，并重写了父类的方法后，又要使用父类变量或父类被重写的方法时，可通过super来实现对父类变量的访问和父类方法的调用。因此，本题中在main ()中调用setX ()时，是调用的SubClass类中的setX ()函数，同时将SubClass类中的i变量值设为20。当main ()函数中调用getX ()函数时，并不是取了SubClass类中的i的值，而是取的Base类中i变量的值，此时i的值为其初始值30。 -
第5题：
有如下程序: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的析构函数。 -
第6题：
有如下程序:includeinclude using namespace std;class BASE{char c;public 有如下程序： #include＜iostream＞#include＜iosream＞ using namespace std； class BASE{ char c； public； BASE(char n)：c(n){} virtual ～ BASE(){cout＜＜c;} }； class DERIVED; public BASE{ char c； public： DERIVED (char n): BASE (n+1)
A．XY
B．YX
C．X
D．Y
正确答案：A
-
第7题：
有如下程序includeusing namespace std;class Base{protected:Base(){cout<<'A';}Bas 有如下程序 #include＜iostream＞ using namespace std； class Base{ protected： Base(){cout＜＜'A'；} Base(char c){cout＜＜c;) }; class Derived: public Base{ public： Derived(char c){cout＜＜c;) }； int main(){ Derived dl('B')； return 0； } 执行这个程序屏幕上将显示输出( )。
A．B
B．BA
C．AB
D．BB
正确答案：C
-
第8题：
设有类定义如下：
class Base{
public Base(int i){}
}
public class MyOver extends Base{
public static void main(String arg[]){
MyOver m = new MyOver(10);
}
MyOver(int i){
super(i);
}
MyOver(String s, int i){
this(i);
//Here
}
}
以下哪条语句可以安排在//Here处 ?
A.MyOver m = new MyOver();
B.super();
C.this("Hello",10);
D.Base b = new Base(10);
正确答案：D
-
第9题：
设有如下代码：
interface IFace{}
class CFace implements IFace{}
class Base{}
public class ObRef extends Base{
public static void main(String argv[]){
ObRef bj = new ObRef();
Base b = new Base();
Object obj1 = new Object();
IFace obj2 = new CFace();
//Here
}
}
则在 //Here处插入哪个代码将不出现编译和运行错误。
A.obj1=obj2;
B.b=obj;
C.obj=b;
D.obj1=b;
正确答案：ABD
-
第10题：
class Base { Base（） { System.out.print（“Base”）； } } public class Alpha extends Base { public static void main（ String[] args ） { new Alpha（）； new Base（）； } } What is the result？（）
- A、 Base
- B、 BaseBase
- C、 Compilation fails.
- D、 The code runs with no output.
- E、 An exception is thrown at runtime.
正确答案:B -
第11题：
填空题Given the following code, write a line of code that, when inserted at the indicated location, will make the overriding method in Extension invoke the overridden method in class Base on the current object. class Base { public void print（ ） { System.out.println("base"); } } class Extention extends Base { public void print（ ） { System.out.println("extension"); // insert line of implementation here } } public class Q294d { public static void main(String args[]) { Extention ext = new Extention（ ）; ext.print（ ）; } } Fill in a single line of implementation.（）正确答案： super.print();解析： 暂无解析 -
第12题：
单选题public class Base { public static final String FOO = “foo”； public static void main（String[] args） { Base b = new Base（）； Sub s = new Sub（）； System.out.print（Base.FOO）； System.out.print（Sub.FOO）； System.out.print（b.FOO）； System.out.print（s.FOO）； System.out.print（（（Base）s）.FOO）； } } class Sub extends Base {public static final String FOO=bar；} What is the result？（）Afoofoofoofoofoo
Bfoobarfoobarbar
Cfoobarfoofoofoo
Dfoobarfoobarfoo
Ebarbarbarbarbar
Ffoofoofoobarbar
Gfoofoofoobarfoo
正确答案： B解析： 暂无解析 -
第13题：
有如下程序:includeusing namespace std;class Base{protected:Base(){cout<<'Base'; 有如下程序： #include＜iostream＞ using namespace std; class Base{ protected: Base(){cout＜＜'Base';} Base(char c){cout＜＜c;} }; class Derived:public Base{ public: Derived(char c){cout＜＜c;} }; int main(){ Derived d('Derived'); return 0; } 执行这个程序屏幕上将显示输出( )。
A．Derived
B．DerivedBase
C．BaseDerived
D．DerivedDerived
正确答案：C
解析：派生类Derived由基类Base公有派生，在派生类构造函数声明时系统会自动调用基类的缺省构造函数。调用Derived d('Derived')；后，执行类Derived构造函数的Derived(char c)，系统自动调用基类的缺省构造函数Base()，输出字母Base；再执行派生类的构造函数Derived(char c)，输出字母Derived。 -
第14题：
有如下程序:includeusing namespace std;class Base{public:Base(int x=0){cout< 有如下程序： #include＜iostream＞ using namespace std； class Base{ public： Base(int x=0){cout＜＜x；} }； class Derived：public Base{ public： Derived(int x=0){cout＜＜x；} private： Base val； }； int main( ){ Derived d(1)； return 0； } 程序的输出结果是
A．0
B．1
C．01
D．001
正确答案：D
解析：派生对象在创建时先调用基类的构造函数，然后调用派生类的构造函数；撤销对象时，先调用派生类的构造函数，然后调用基类的构造函数。当类中出现其他类对象时，在初始化时先调用该对象的类的构造函数创建该对象。第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
解析：本题考核派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。所以当main函数结束时，派生类DERIVED的对象x将被删除，那么派生类DERIVED的析构函数先被调用，输出DERIVED，然后调用基类的析构函数输出BASE。第16题：
下面程序段的输出结果是 class Base { int i； Base() { add(1)； } void add(int v) { i+=v； } void print() { System．out．println(i)； } } class Extension extends Base { Extension() { add(2)； } void add(int v) { i+＝v*2； } } public class Test { public static void main(String args[]) { bogo(new Extension())； } static void bogo(Baseb){ b．add(8)； b．print()； } }
A．9
B．18
C．20
D．22
正确答案：D
解析：本题考查继承和构造函数的用法。首先要明确对一个类的继承是指在父类的基础上构建了一个子类，子类继承了父类的方法和状态。题目所给程序段创建的是Extension类的实例，在运行时，从main()函数进入程序，所有调用add()方法的过程将始终和Extension类的add()方法动态绑定。初始值：i＝0；创建实例new Extension()；先调用父类的默认构造函数Base()，并在父类的默认构造函数中执行add(1)，i=0+1×2，所以i=2，再调用子类的默认构造函数Extension()，子类的默认构造函数中执行add(2)，i=2+2×2，所以i＝6；执行add(8)；i=6+8×2，因此，最终i=22，正确答案为选项D。第17题：
如下程序是为变量i赋值。若程序的输出结果是180。请将程序补充完整。
注意：不改动程序结构，不得增行或删行。
class Base
{
int i;
Base()
{
add(10);
}
void add(int v)
{
i+=v;
}
void print()
{
System.out.println(i);
}
}
class Extension extends Base
{
Extension()
{
add(______);
}
void add(int v)
{
i+=v*2;
}
}
public class ConstructTest3
{
public static void main(String args[])
{
bogo(new Extension());
}
static void bogo(Base b)
{
b.add(60);
b.print();
}
}
正确答案：20
20 解析：本题综合考查了几个知识点，如调用子类的构造函数时，会先调用父类的构造函数；如果在子类的构造函数中没有显示调用父类的构造函数，那么创建子类的实例时，会先调用父类的缺省构造函数；方法的动态绑定。这些知识是考试的难点。以上代码创建的是Extension类的实例，所以，在运行时，所有调用add()方法的过程，将始终和Extension类的 add()方法动态绑定。以下是程序依次对变量i的改变过程。
初始值：i=0
Step1：创建实例new Extension()
先调用父类的缺省构造函数Base()，注意，父类中的add方法已被子类重写。父类的缺省构造函数中执行add(10)，i=0+10*2得到i=20，再调用子类的缺省构造函数Extension()，假设横线处应填入的数是x，子类的缺省构造函数中执行add(x),i=20+x*2。
step2：执行add(60)
i=20+x*2+60*2=180得到x=20第18题：
下面程序段的输出结果是（ ）。 class Base { int i； Base { add(1)； } void add(int v) { i+=v： } void print { System．out．println(i)； } } class Extension extends Base { Extension { add(2)； } void add(int v) { i+=v*2： } } public class Test { public static void main(String args[]) { bogo(new Extension)； } static void bogo(Base b) { add(8)； print； } }
A.9
B.18
C.20
D.22
正确答案：D
D。【解析】本题考查继承和构造函数的用法。首先要明确对一个类的继承是指在父类的基础上构建了一个子类，子类继承了父类的方法和状态。题目所给程序段创建的是Extension类的实例，在运行时，从main函数进入程序，所有调用add方法的过程将始终和Extension类的add方法动态绑定。初始值：i=0；创建实例newExtension；先调用父类的默认构造函数Base，并在父类的默认构造函数中执行add(1)，i=O+1×2，所以i=2，再调用子类的默认构造函数Extension，子类的默认构造函数中执行add(2)，i-2+2×2，所以i=6；执行add(8)；i=6+8×2，因此，最终i=22，正确答案为选项D。第19题：
当你编译运行下列程序代码，会得到什么结果?
private class Base{ Base(){ int i = 100; System.out.println(i); } }
public class Pri extends Base{ staticint i = 200;
public static void main(String argv[]){ Pri p = new Pri(); System.out.println(i); } }
A.这段代码不能通过编译
B.输出200
C.输出100和200
D.输出100
正确答案：A
第20题：
以下程序调试结果为:class Base{Base(){int i = 100;System.out.print (i);}}public class Pri extends Base{static int i = 200;public static void main(String argv[]){Pri p = new Pri();System.out.print(i);}}A.编译错误
B.200
C.100200
D.100
正确答案：C
第21题：
public class Base { public static final String FOO = “foo”； public static void main（String[] args） { Base b = new Base（）； Sub s = new Sub（）； System.out.print（Base.FOO）； System.out.print（Sub.FOO）； System.out.print（b.FOO）； System.out.print（s.FOO）； System.out.print（（（Base）s）.FOO）； } } class Sub extends Base {public static final String FOO=bar；} What is the result？（）
- A、 foofoofoofoofoo
- B、 foobarfoobarbar
- C、 foobarfoofoofoo
- D、 foobarfoobarfoo
- E、 barbarbarbarbar
- F、 foofoofoobarbar
- G、 foofoofoobarfoo
正确答案:D第22题：
单选题class Base { Base（） { System.out.print（“Base”）； } } public class Alpha extends Base { public static void main（ String[] args ） { new Alpha（）； new Base（）； } } What is the result？（）ABase
BBaseBase
CCompilation fails.
DThe code runs with no output.
EAn exception is thrown at runtime.
正确答案： A解析： 暂无解析第23题：
单选题What will be written to the standard output when the following program is run？（） class Base { int i； Base（） { add（1）； } void add（int v） { i += v； } void print（） { System.out.println（i）； } } class Extension extends Base { Extension（） { add（2）； } void add（int v） { i += v*2； } } public class Qd073 { public static void main（String args[]） { bogo（new Extension（））； } static void bogo（Base b） { b.add（8）； b.print（）； } }A9
B18
C20
D21
E22
正确答案： E解析： 暂无解析