以下程序的运行结果为?class ValHold{public int i = 10;}public class ObParm{public static void main(String argv[]){ObParm o = new ObParm();o.amethod();}public void amethod(){int i = 99;ValHold v = new ValHold();v.i=30;another(v,i);System.out.print( v.i );}public void
题目
以下程序的运行结果为?
class ValHold{
public int i = 10;
}
public class ObParm{
public static void main(String argv[]){
ObParm o = new ObParm();
o.amethod();
}
public void amethod(){
int i = 99;
ValHold v = new ValHold();
v.i=30;
another(v,i);
System.out.print( v.i );
}
public void another(ValHold v, int i){
i=0;
v.i = 20;
ValHold vh = new ValHold();
v = vh;
System.out.print(v.i);
System.out.print(i);
}
}
A.10030
B. 20030
C. 209930
D. 10020
相似考题
更多“以下程序的运行结果为?class ValHold{public int i = 10;}public class ObParm{public static ”相关问题
-
第1题：
有以下程序:includeusing namespace std;class A{private:int a;public:A(int i){a=i 有以下程序： #include＜iostream＞ using namespace std； class A {private： int a； public： A(int i) {a＝i;} void disp() {cout＜＜a＜＜“，”；}}； class B {private： int b； public： B(int j) {b=j;} void disp() {cout＜＜b＜＜“，”；
A．10，10，10
B．10，12，14
C．8，10，12
D．8，12，10
正确答案：D
解析： 本题中，派生类C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第2题：
若有以下程序 includeusing namespace std; class A {private:int a; public: A(in 若有以下程序 #include ＜iostream＞ using namespace std; class A { private: int a; public: A(int i) { a=i; } void disp() { cout＜＜a＜＜","; } }; class B { private: int b; public: B(int j) { b=j; } void disp() { cout＜＜b＜＜","; } }; class C: public B,public A { private: int c; public: C(int k):A(k-2),B(k+2) { c=k; } void disp() { A::disp(); B::disp(); cout＜＜c＜＜end1; } }; int main() { C obj(10); obj.disp(); return 0; } 程序执行后的输出结果是
A．10,10,10
B．10,12,14
C．8,10,12
D．8,12,10
正确答案：D
解析：本题考核派生类构造函数的使用。本题中，派生C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第3题：
有以下程序:includeusing namespace std;class A{private:int a;public:A (int i){a 有以下程序： #include ＜iostream＞ using namespace std; class A { private: int a; public: A (int i) { a=i; } void disp() { cout＜＜a＜＜","; } }; class B { private: int b; public: B(int j) { b=j; } void disp() { cout＜＜b＜＜","; } }; class C : public B,public A { private: int c; public: C(int k) :A(k-2),B(k+2) { c=k; } void disp () { A::disp (); B::disp (); cout＜＜c＜＜endl; } }; int main () { C obi (10); obj.disp (); return 0; } 程序执行后的输出结果是
A．10,10,10
B．10,12,14
C．8,10,12
D．8,12,10
正确答案：D
解析：本题考核派生类构造函数的使用。本题中，派生类C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第4题：
写出程序的输出结果：
public class A
{
public virtual void Fun1(int i)
{
Console.WriteLine(i);
}
public void Fun2(A a)
{
a.Fun1(1);
Fun1(5);
}
}
public class B : A
{
public override void Fun1(int i)
{
base.Fun1 (i + 1);
}
public static void Main()
{
B b = new B();
A a = new A();
a.Fun2(b);
b.Fun2(a);
}
}
正确答案：
-
第5题：
下面程序运行的结果是()。includeusing namespace std;class A{ protected:int a; pub 下面程序运行的结果是( )。 #include＜iostream＞ using namespace std； class A{ protected: int a; public: void input(int i) {a=i;} }; class B{ protected: int a; public: void input(int j) {a=j;} }; class C: public A, public B { int x; public: void input() {x=A::a * B::a;cout＜＜x＜＜endl;} }; void main() { C c; c.A::input(5); c.B::input(8); c.input(); }
A．5
B．8
C．40
D．编译出错
正确答案：C
解析：用成员名限定法来消除二义性，故答案为C。 -
第6题：
若有以下程序:includeusing namespace std;class Base {public:Base() { x=0; } int 若有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base() { x=0; } int x; }; class Derivedl: virtual public Base { public: Derivedl() { x=10; } }; class Derived2: virtual public Base { public: Derived2() ( x=20; } }; class Derived: public Derivedl,protected Derived2 { }; int main() { Derived obj; cout＜＜obj.x＜＜end1; return 0; } 该程序运行后的输出结果是
A．20
B．30
C．10
D．0
正确答案：A
解析：本题考核虚基类的应用。本题中，虽然Derivedl和Derivec[2都是由共同的基类x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derivedl中修改，还是在类Derivect2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derivedl的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。 -
第7题：
若有以下程序:includeusing namespace std;class A{private:int a;public:A(int i){ 若有以下程序： #include ＜iostream＞ using namespace std; class A { private: int a; public: A(int i) { a=i; } void disp () { cout＜＜a＜＜","; } }; class B { private: int b; public: B(int j) { b=j; } void disp () { cout＜＜b＜＜","; } }; class C : public B,public A { private: int c; public: C(int k):A(k-2),B(k+2) { c=k; } void disp () { A::disp(); B::disp(); cout＜＜c＜＜endl; } }; int main() { C obj(10); obj.disp(); return 0; }
A．10,10,10
B．10,12,14
C．8,10,12
D．8,12,10
正确答案：D
解析：本题考核派生类构造函数的使用。本题中，派生类c具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第8题：
若有以下程序:includeusing namespace std;class A{private:int a;public:A(int i){a 若有以下程序： #include＜iostream＞ using namespace std； class A {private： int a； public： A(int i) {a=i;} void disp() {cout＜＜a＜＜“，”；}}； class B {private： int b； public： B(int j {b＝j；} void disp() {cout＜＜b＜＜
A．10，10，10
B．10，12，14
C．8，10，12
D．8，12，10
正确答案：D
解析： 本题考查派生类构造函数的使用。派生类C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第9题：
下列程序的运行结果是______。 includeclass 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函数，此时表现为多态。 -
第10题：
以下程序的输出结果为:public class example {public static void main(String args[]) {int i=0;for (i=0;i<4;i＋＋) {if (i==3、break;System.out.print(i);}System.out.println(i);}}A.0123 B.0122 C.123 D.234
正确答案：A
-
第11题：
以下程序调试结果为: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
-
第12题：
现有： public class TestDemo{ private int X-2； static int y=3； public void method（）{ final int i=100； int j =10； class Cinner { public void mymethod（）{ //Here } } } } 在Here处可以访问的变量是哪些？（）
- A、X
- B、y
- C、j
- D、i
正确答案:A,B,D -
第13题：
下列程序的功能是为变量赋值，程序运行后，输出i=51。请改动main方法中的错误，使程序能够正确编译、运行并输出正确的结果。
注意：不改动程序结构。
class A
{
private int a;
public void setA (int x)
{
a=x;
}
public int getA()
{
return a;
}
}
public class MethodTest
{
public static void main(String args[])
{
A a=A();
a.getA(51);
int i=a.getA();
System.out.println ("i="+i);
}
}
正确答案：改正后的main方法如下： public static void main(String args[]) { A a=new A(); a.getA(51); int i=a.getA(); System.out.println("i="+i); }
改正后的main方法如下： public static void main(String args[]) { A a=new A(); a.getA(51); int i=a.getA(); System.out.println("i="+i); } 解析：本题综合考查类及类成员的定义与使用方面的知识。该程序中定义了两个类：A和MethodTest，类A中封装了一个私有的成员变量a和两个公有的方法setA和getA。在类MethodTest中包含了main方法。创建对象应使用new操作符来实例化对象，程序在创建对象a时未使用new，故存在错误。由于a是对象a的私有变量，在main方法中不能直接访问，只能通过对象a的公有方法setA和getA来访问。公有方法setA的功能是将传递回来的参数值赋给a，所以应当调用setA方法来为变量a赋值。 -
第14题：
若有以下程序:includeusing namespace std;class Base{public: Base ( ) {x=0; } in 若有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base ( ) { x=0; } int x; }; class Derivedl : virtual public Base { public: Derivedl () { x=10; } }; class Derived2 : virtual public Base { public: Derived2 () { x=20; } }; class Derived : public Derivedl,protected Derived2{ }; int main ( ) { Derived obj; cout＜＜obj .x＜＜end1; return 0; } 该程序运行后的输出结果是 ( )。
A．20
B．30
C．10
D．0
正确答案：A
解析：本题中，虽然Derivedl和Derived2都是由共同的基类x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数，使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。 -
第15题：
有以下程序 includeusing namespace std; class Base { int a; public: Base(int x) 有以下程序
include ＜iostream＞
using namespace std;
class Base
{
int a;
public:
Base(int x){ a=x; }
void show(){ cout＜＜a; }
class Derived : public Base
{
int b;
public:
Derived(int i) :Base(i+1),b(i){}
void show() { cout＜＜b;
};
int main ()
{
Base b(5),*pb;
Derived d(1);
pb=&d;
pb-＞show ();
return 0;
}
运行后的打印结果是______。
正确答案：2
2 解析：本题考核基类指针与派生类指针的使用。本例程序中类Derived是从基类Base公有继承来的。main()中定义了基类对象b和一个基类指针pb，又定义了派生类Derived的对象d。由于Derived是Base的子类型，因此可以将派生类Derived的对象d的地址赋值给指向基类Base的指针pb，但这时指针pb只能使用从基类Base继承的成员。所以通过对象指针Pb调用的show函数是基类的成员函数show()，从而输出基类私有数据成员a的值2。 -
第16题：
若有以下程序:includeusing namespace std;class A{protected: int a;public: A() { 若有以下程序： #include ＜iostream＞ using namespace std; class A { protected: int a; public: A() { a=10; } }; class A1 : public A { public: A1() { a=a+1; } }; class A2 : public A { public: A2 () { a=a+2; } }; class B : public A1,public A2 { public: B(){} void print() { cout＜＜a＜＜end1; } }; int main ( ) { B obj; obj.print(); return 0; } 程序运行后的输出结果是( )。
A．产生语法错误
B．11
C．12
D．10
正确答案：A
解析：本题考核派生类的定义和使用。本程序有语法错误，这是由于类B中的print函数中的语句“coutaend1；”要输出成员a的值，从而产生了二义性。分析如下：程序中定义了类A，类A1和类A2都是在类A的基础上以公有继承方式产生的派生类，而类B是在类A1和类A2的基础上经过多重继承方式产生的派生类，所以在类B中成员a有两个拷贝，系统无法区分是从A1继承过来的a，还从A2类继承过来的a。修改方法有以下两种：①在被访问的成员加上作用域分辨符“::”。将类B中的print()函数体中语句改为：coutA1：：aend1；或coutA2：：aend1；但两者的输出结果不同，前者输出11，而后者输出12。②采用虚基类的方法。就是在定义A1和A2时，在派生方式前加上关键词“virtual”。 -
第17题：
设有如下程序: includeusing namespace std; class A { public:int i;display(){co 设有如下程序： #include ＜iostream＞ using namespace std; class A { public: int i; display() { cout＜＜"class A\n"; } }; class B { public: int i; display() { cout＜＜"class B\n"; } }; class C : public A, public B { int j; public: int i; show ( ) { j = i * i; display(); } }; int main() { C demo; demo.show(); return O; } 则主程序运行时将( )。
A．因为变量i的重复定义而报错
B．因为对象demo间接调用display()函数时产生二义性而报错
C．因为类定义的语法错误而不能运行
D．没有语法错误，能够正常输出结果
正确答案：B
解析：本题主要考察C++中多继承的工作方式和二义性的解决办法。在C++中，允许一个派生类从多个基类派生，这种继承方式称为多继承。多继承的定义格式如下：class派生类名＞：继承方式＞基类名1＞，继承方式2＞基类名2＞，…{派生类类体＞}；但是，如果一个派生类的两个或多个基类中有某个同名成员，在派生类中对这个成员的访问就可能出现二义性；同时，如果一个派生类是由两个或多个基类派生出来的，而这几个基类又有一个共同的基类，对该基类进行访问时，也可能会出现二义性。本题程序中，类C是由类A和类B多继承得到的派生类，但其自身函数show()中调用了display()函数，而这个函数是同时出现在类C的两个基类中的，因此程序会出现二义性，编译器将无法确定调用哪一个display()函数来执行操作，因此报错。解决二义性的通常办法是通过作用域运算符“::”进行限定。 -
第18题：
分析以下程序的执行结果【】。includeclass S{ int A[10]; public: int &operato 分析以下程序的执行结果【 】。
include ＜iostream. h＞
class S{
int A[10];
public:
int &operator () (int);
};
int &S: :operator() (int x) {
return A[x];
}
void main() {
S a;
int i,j;
for (i=0; i＜10; i++)
a(i)=i*2;
for (i=0; i＜10; i++)
cout＜＜a(i)＜＜" ";
cout＜＜end1; }
正确答案：0 2 4 6 8 10 12 14 16 18
0 2 4 6 8 10 12 14 16 18 -
第19题：
设有如下程序:includeclass A{public:int i;display(){ cout<<"class A\n"; }};c 设有如下程序：#include ＜iostream. h＞class A{public:int i;display(){ cout＜＜"class A\n"; }};class B{public:int i;display(){ cout＜＜"class B\n"; }};class C: public: A, public: B{int j;public:int i;show(){ j=i*i; display(); }};void main(){C demo;demo. show();}则主程序运行时，将( )。
A．因为变量i的重复定义而报错
B．因为对象demo间接调用display函数时产生歧义性而报错
C．因为类定义的语法错误而不能运行
D．没有语法错误，能够正常输出结果
正确答案：B
-
第20题：
若有以下程序:includeusing namespacestd;class A {private: int a;public:A(int i) 若有以下程序： #include ＜iostream＞ using namespace std; class A { private: int a; public: A(int i) { a=i; } void disp() { cout ＜＜a＜＜","; } }; class B { private: int b; public: B(int j) { b=j; } void disp() { cout＜＜b＜＜","; } }; class C: public B,public A { private: int c; public: C(int k):A(k-2),B(k+2) { c=k; } void disp() { A::disp(); B::disp(); cout＜＜c＜＜end1; } }; int main() { C obj (10); obj.disp(); return 0; } 程序执行后的输出结果是
A．10,10,10
B．10, 12,14
C．8,10,12
D．8,12,10
正确答案：D
解析：本题考核派生类构造函数的使用。本题中，派生类C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第21题：
以下程序的运行结果为:public class test {public static void main(String args[]) {int i=0, j=2;do {i=＋＋i;j－－;} while(j>0);System.out.println(i);}}A. 0
B. 1
C. 2
D.3
正确答案：C
-
第22题：
以下的程序的调试结果为?public class MyAr{public static void main(String argv[]) {MyAr m = new MyAr();m.amethod();}public void amethod(){static int i;System.out.println(i);}}A. 输出结果为 0
B. 运行出错
C. 输出结果为 null
D. 编译错误
正确答案：D
-
第23题：
以下的程序的调试结果为public class Scope{int i;public static void main(String argv[]){Scope s = new Scope();s.amethod();}public static void amethod(){System.out.println(i);}}A. 输出结果为：0
B. 无输出
C. 编译错误
D. 输出null
正确答案：C