编译如下Java程序片断:  class test{  int count = 9;  public void a(){    int count=10;  System.out.println("count 1 =" + count);  }  public void count(){  System.out.println("count 2 =" + count);  }  public static void main(String args[]){    test t=new test();   

题目

编译如下Java程序片断:  class test{  int count = 9;  public void a(){    int count=10;  System.out.println("count 1 =" + count);  }  public void count(){  System.out.println("count 2 =" + count);  }  public static void main(String args[]){    test t=new test();    t.a();   t.count();   } }  结果将()。    

  • A、不能通过编译
  • B、输出:       count 1 = 10        count 2 = 9
  • C、输出:          count 1 = 9          count 2 = 9
参考答案和解析
正确答案:B
如果没有搜索结果或未解决您的问题,请直接 联系老师 获取答案。
相似问题和答案

第1题:

下面程序的运行结果是【】。 inChlde using namespace std; class count { static int n;

下面程序的运行结果是【 】。

inChlde<iOStream>

using namespace std;

class count

{

static int n;

public:

count()

{

n++;

}

static int test()

{

for(int i=0:i<4;i++)

n++;

return n;

}

};

int count::n=0;

int main()

{

cout<<COUnt::test()<<" ";

count c1, c2;

cout<<count::test()<<end1;

return 0;

}


正确答案:4 10
4 10 解析:本题主要考查C++类中静态数据成员的使用。题目程序首先定义了类count,其内部含有private类型数据成员static int n;同时含有public类型构造函数count()和静态成员函数static int test(),这两个函数的功能分别是为对象申请系统资源并将静态数据成员n加1和将静态数据成员n加4。主函数前,程序将静态数据成员n初始化为0,该数据成员为所有类count的对象所共有的数据成员:主函数中程序首先执行静态成员函数test()(由于test声明为static,因此其调用时无需通过具体对象),其执行过程中,静态数据成员n应该加4变成n=4,因此此处输出为4:此后程序创建对象c1和c2,由于在每次创建过程中都要调用构造函数count(),而每次调用 count()函数后,静态数据成员n值都会加1因此,创建两个对象之后,n值变为n= 6:再次执行test()函数后,n的值再次加4,因此变为n=6+4=10。故程序全部执行后,变量n值变为10,而中间程序输出为“410”。

第2题:

如下程序的输出结果是( )。 public class Test { void printValue(int m) { do { System.out.println("The value is"+m); } while( --m>10) } public static void main(String args[]) { int i=10; Test t=new Test(); t.printValue(i); } }

A.The value is 8

B.The value is 9

C.The value is 10

D.The value is 11


正确答案:C
解析:此题考查的是do-while循环和“--”操作符的知识。do-while最少执行一次,在执行完do中的内容后,判断while中的条件是否为true。如果为true,就再执行do中的内容,然后再进行判断。以此类推,直到while的判断为false时退出循环,执行循环后面的内容。而“--”操作符的规则是,变量右边的“--”将先进行运算,然后才使变量的值减一。而在变量左边的“--”,则先将变量的值减一再运算。本程序中I的值为10,当程序运行到do-while循环时,程序先执行一次循环后然后再做判断,因此选C。

第3题:

编译如下Java程序片断:classtest{intcount=9;publicvoida(){intcount=10;System.out.println(&qu

编译如下Java程序片断:classtest{intcount=9;publicvoida(){intcount=10;System.out.println("count1="+count);}publicvoidcount(){System.out.println("count2="+count);}publicstaticvoidmain(Stringargs[]){testt=newtest();t.a();t.count();}}结果将()。

A.不能通过编译

B.输出: count1=10 count2=9

C.输出:count1=9 count2=9


参考答案:B

第4题:

有如下程序: #include using name space std; classB{ public: B(int xx):x(xx){++count;x+=10;} virtual void show()const {cout<<count<<'_'<<x<<endl;} protected: static int count; private: intx; }; class D:publicB{ public: D(int xx,int yy):B(xx),y(yy){++count;y+=100;} virtual void show()const {cout<<count<<'_'<<y<endl}; pnvate: inty; }; int B::count=0; intmain(){ B*ptr=new D(10,20); ptr->show(); delete ptr; return 0; } 运行时的输出结果是( )。

A.1_120

B.2_120

C.1_20

D.2_20


正确答案:B
解析:本题考查了类的继承。继承有三种方式,public公有、pnvate私有和protected保护,本题都涉及到了。本题中类D公有继承类B。在类B中又定义了虚函数,并且有保护类静态类型count及私有变量x。主函数中调用类D,类D又继承了类B,经过系统及调用,本题最终结果为2120。

第5题:

( 35 )有如下程序:

#include <iostream>

using namespace std;

Class B{

public:

B(int xx):x(xx) {++cout; x+=10;}

virtual void show() const

{cout<<count<< ' _ ' <<x<<endl;}

protected:

static int count;

private:

int x;

};

class D:public B{

public:

D(int xx,int yy):B(xx),y(yy) {++count; y+=100;}

virtual void show() const

{cout<<count<< ' _ ' <<y<<endl;}

private:

int y;

};

int B::count=0;

int main(){

B *ptr=new D(10,20);

ptr->show();

delete ptr;

return 0;

}

运行时的输出结果是

A ) 1_120

B ) 2_120

C ) 1_20

D ) 2_20


正确答案:B

第6题:

下列程序段的输出结果是【 】。

public class Test {

void printValue(int m) {

do {

System.out.println("The value is"+m);

}while (--m>10);

}

public static void main (String args[]) {

int i=10;

Test t= new Test();

t.printValue(i);

}

}


正确答案:Thevalue is 10
Thevalue is 10 解析:本题考查do-while循环的用法。do-while至少执行一次,在执行完do中的内容后,判断while中的条件是否为true。如果为true,就再执行do中的内容,然后再进行判断。依次类推,直到while的判断为false时退出循环,执行循环后面的内容。题目中m的值为10,当程序运行到do-while循环时,程序先执行一次循环然后再作判断,在判断条件--m>10时,其值为false,退出循环。因此只执行了一次输出操作,输出内容为:The value is 10。

第7题:

下面程序的正确输出是( )。 public class Hello { public static void main(String args[]) { int count, xPos=25; for ( count=1; count<=10; count++ ) { if ( count==5 ) break; System.out.println(count ); xPos += 10; } } }

A.1 2 3 4

B.1 3 4

C.编译错误

D.以上都不是


正确答案:A
解析:该程序经过编译、运行后,在屏幕上显示;1 2 3 4。public class Hello中Hello为类名,public static void main(String args[])有关参数的解释如下。public——表示该方法可以被任意代码所调用,包括Java解释器。 static——它告诉编译器,main()方法是一个类方法,可以通过类名直接调用,调用时不需要该类的实例对象。void——表示main()方法没有返回值。这是非常重要的。因为Java类型检查非常严格,包括检查这些方法返回值的类型是否与声明的一致。String args[]——声明一个字符串类型的数组。它是命令行传递给main()方法的参数,参数在命令行中出现在类名称后面。包含main()方法的类(Hello为包含main()方法的类名)名称必须与其文件名相同,也就是说,其文件名必须为Hello.java。经过编译,在当前文件夹下将出现一个Hello.class文件,这就是编译后的字节码文件。在程序段最后有两个大括号,分别说明结束main()方法和Hello类。在本程序中由于有count==5这个条件判断,因此当count==5时,程序结束,输出为1 2 3 4。

第8题:

如下程序的输出结果是______。 include using namespace std; class pumpkin{ publ

如下程序的输出结果是______。

include<iostream>

using namespace std;

class pumpkin{

public:

pumpkin( ){++count;}

~pumpkin( ){--eount;}

static void total_count( ){cout<<count<<"pumpkin(s)"<<endl;}

private:

static int count;

};

int pumpkin::count=0;

int main( ){

pumpkin pl[10];

pumpkin::total_count( );

return 0;

}


正确答案:10pumpkin(s)
10pumpkin(s) 解析:在主函数中pumpkin pl[10];定义了一个有10个元素的对象数组,所以调用了10次构造函数,静态数据成员court累加了10次,pumpkin::total_count( );显式调用类成员函数,直接调用静态成员函数:total_count( ),打印pumpkin(s)。

第9题:

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

有如下程序: #include <iostream> using namespace std; class MyClass { public: MyClass() { ++count; } ~MyClass() { --count; } static int getCount() { return count; } private: static int count; }; int MyClass::count=0; int main() { MyClass obj; cout<<obj.getCount(); MyClass *ptr=new MyClass; cout<<MyClass::getCount(); delete ptr; cout<<MyClass::getCount(); return 0; }程序的输出结果是

A.121

B.232

C.221

D.122


正确答案:A
解析:本题考查的知识点是:静态成员。对于类中的非静态数据成员,每一个类对象都拥有一个拷贝(副本),即每个对象的同名数据成员可以分别存储不同的数值,这是保证每个对象拥有区别于其他对象的特征的需要。而类中的静态成员则是解决同一个类的不同对象之间的数据和函数共享问题的。静态成员的特性是不管这个类创建了多少个对象,它的静态成员都只有一个拷贝(副本),这个副本被所有属于这个类的对象共享。这种共享与全局变量或全局函数相比,既没有破坏数据隐藏的原则,又保证了安全性。题目中,首先定义了一个obj对象,其构造函数使MyClass的静态数据成员count增1,所以第一条输出语句输出的结果是1。然后通过指针动态创建了一个MyClass类的对象,构造函数再次被调用,count变为2,所以第2次输出结果是2。接下来是用delete删除了刚才动态创建的MyClass对象,析构函数被调用,count减1变为1,第3次输出1。故本题的输出为121,选项A正确。

第10题:

下面程序的运行结果是【】。 include using namespace std; class count{ static int n;

下面程序的运行结果是【 】。

include <iostream>

using namespace std;

class count

{

static int n;

public:

count()

{

n++;

}

static int test()

{

for(int i=0;i<4;i++)

n++;

return n;

}

};

int count::n = O;

int main()

{

cout<<count:: test()<<" ";

count c1, c2;

cout<<count:: test()<<endl;

return 0;

}


正确答案:410
410 解析:本题主要考查C++类中静态数据成员的使用。题目程序首先定义了类count,其内部含有private 类型数据成员static int n;同时含有public 类型构造函数 count()和静态成员函数static int test(),这两个函数的功能分别是为对象申请系统资源并将静态数据成员n加1和将静态数据成员n加4。主函数前,程序将静态数据成员n初始化为0,该数据成员为所有类count 的对象所共有的数据成员;主函数中程序首先执行静态成员函数test() (由于test 声明为 static,因此其调用时无需通过具体对象),其执行过程中,静态数据成员n应该加4变成n:4,因此此处输出为4;此后程序创建对象c1和c2,由于在每次创建过程中都要调用构造函数count(),而每次调用count()函数后,静态数据成员n值都会加1。因此,创建两个对象之后,n值变为n=6:再次执行test()函数后,n的值再次加4,因此变为n=6+4=10。故程序全部执行后,变量n值变为10,而中间程序输出为“410”。

更多相关问题