java中的类的专题.docx

java中的类的专题.docx

《java中的类的专题.docx》由会员分享，可在线阅读，更多相关《java中的类的专题.docx（38页珍藏版）》请在冰豆网上搜索。

java中的类的专题

（1）类的默认的无参构造函数[]。

A）在任何情况下都存在

B）仅当未定义无参构造函数时存在

C）仅当未定义有参构造函数时存在

D）仅当未定义任何构造函数时存在

（2）类的默认的拷贝构造函数[]。

A）在任何情况下都存在

B）仅当未定义拷贝构造函数时存在

C）仅当未定义有参构造函数时存在

D）仅当未定义任何构造函数时存在

改错题：

每题有一处错误，请在出错语句后用注释说明出错原因并提出更改意见

（1）classLocation{

intX,Y;

protected:

intSetZero（intzeroX,intzeroY）;

private:

intlength,height;

public:

voidLocation（intinitX,intinitY）;

intGetX（）;

intGetY（）;};

（2）下面的程序有一处语法错误：

#include

classPair{

intX,Y;

public:

Pair（intinitX,intinitY）:

X（initX）,Y（initY）{}

intsumXY（）{returnX+Y;};

};

voidmain（）

{

PairA1（5,3）;

cout<

}

题1.分析以下程序执行的结果

#include

#include

classSample

{

   public:

       intx,y;

       Sample（）{x=y=0;}

       Sample（inta,intb）{x=a;y=b;}

       voiddisp（）

       {

           cout<<"x="<

       }

};

voidmain（）

{

   Samples1（2,3）;

   s1.disp（）;

}

解：

本题说明了重载构造函数的定义方法。

首先定义了一个类Sample,在main（）中定义了它的一个对象，定义s1对象时调用其重载构造函数（x=2,y=3），然后，调用其成员函数输出数据成员。

所以输出为：

x=2,y=3。

注意：

构造函数是唯一不能被显式调用的成员函数，它在定义类的对象时自动调用，也称为隐式调用。

--------------------------------------------------------

题2.分析以下程序的执行结果

#include

classSample

{

   intx,y;

   public:

       Sample（）{x=y=0;}

       Sample（inta,intb）{x=a;y=b;}

       ~Sample（）

       {

           if（x==y）

               cout<<"x=y"<

           else

               cout<<"x!

=y"<

       }

       voiddisp（）

       {

           cout<<"x="<

       }

};

voidmain（）

{

   Samples1（2,3）;

   s1.disp（）;

}

解：

本题说明了析构函数的定义方法。

首先定义了一个类Sample,在main（）中定义了它的一个对象，定义s1对象时调用其重载构造函数（x=2,y=3），然后，调用其成员函数输出数据成员，最后在退出程序时自动调用析构函数。

所以输出为：

   x=2,y=3

   x!

=y

注意：

析构函数在对象的作用域结束时被自动隐式调用。

----------------------------------------------------

题3.分析以下程序的输出结果

#include

classSample

{

   intx;

   public:

       Sample（inta）

       {

           x=a;

           cout<<"constructingobject:

x="<

       }

};

voidfunc（intn）

{

   staticSampleobj（n）;

}

voidmain（）

{

   func

（1）;

   func（10）;

}

解：

本题说明静态对象构造函数的调用情况，由于在func（）函数中定义的对象obj是静态对象，故只被构造一次，所以输出为：

       counstructingobject:

x=1

注意：

静态对象和静态变量一样，只被构造一次。

块作用域的静态变量，在首次进入到定义该静态对象的函数时，构造该静态对象，以后进入该函数时不再构造静态对象。

------------------------------------------------------

题1.4分析以下程序的执行结果

#include

classSample

{

   intx,y;

   public:

       Sample（）{x=y=0;}

       Sample（inta,intb）{x=a;y=b;}

       voiddisp（）

       {

           cout<<"x="<

       }

};

voidmain（）

{

   Samples（2,3）,*p=&s;

   p->disp（）;

}

解：

本题说明了对象指针的使用方法。

这里通过指向对象的指针来调用对象的成员函数。

对象指针p指向对象s，p->disp（）等价于s.disp（）。

所以输出为：

x=2,y=3.

题1.5分析以下程序的执行结果

#include

classSample

{

   public:

       intx;

       inty;

       voiddisp（）

       {

           cout<<"x="<

       }

};

voidmain（）

{

   intSample:

:

*pc;

   Samples;

   pc=&Sample:

:

x;

   s.*pc=10;

   pc=&Sample:

:

y;

   s.*pc=20;

   s.disp（）;

}

解：

本题说明了类数据成员指针的使用方法。

在main（）中定义的pc是一个指向Sample类数据成员的指针。

执行pc=&Sample:

:

x时，pc指向数据成员x，语句s.*pc=10等价于s.x=10（为了保证该语句正确执行，Sample类中的x必须是公共成员）；执行pc=&Sample:

:

y时，pc指向数据成员y，语句s.*pc=20等价于s.y=20（同样，Sample类中的y必须是公共成员）。

所以输出为：

x=10,y=20。

-----------------------------------------------------

题1.6下面是一个类的测试程序，设计出能使用如下测试程序的类。

voidmain（）

{

   Testa;

   a.init（68,55）;

   a.print（）;

}

其执行结果为：

   测试结果：

68-55=13

解：

本题是要设计Test类，其设计方法很多，这里给出一种解法。

Test类包含两个私有数据成员x、y，以及两个公共成员函数init（）和print（），前者用于给数据成员赋值，后者用于x,y的减法运算和输出相应的结果。

#include

classTest

{

   intx,y;

   public:

       voidinit（int,int）;

       voidprint（）;

};

voidTest:

:

init（inti,intj）

{

   x=i;y=j;

}

voidTest:

:

print（）

{

   cout<<"测试结果：

"<

}

注意：

类是一个外壳，它包含了类实例化时数据和代码的使用方法，它是一种模板，只有在定义类的对象时，才为对象分配空间，而不会为类分配空间。

------------------------------------------------------

1：

下列有关类的说法不正确的是（）。

A．A． 对象是类的一个实例

B．B． 任何一个对象只能属于一个具体的类

C．C． 一个类只能有一个对象

D．D．类与对象的关系和数据类型与变量的关系相似

2：

下面（）项是对构造函数和析构函数的正确定义。

A．voidX:

:

X（）,voidX:

:

~X（）

B．X:

:

X（参数）,X:

:

~X（）

C．X:

:

X（参数）,X:

:

~X（参数）

D．voidX:

:

X（参数）,voidX:

:

~X（参数）

3：

（）的功能是对象进行初始化。

A．析构函数B.数据成员C.构造函数D.静态成员函数

4：

下列表达方式正确的是（）。

A．classP{B．classP{

public：

public：

intx=15；intx；

voidshow（）{cout<

}；}

C．classP{D.classP{

intf;public：

}；inta；

f=25；voidSeta（intx）{a=x;}

5：

拷贝构造函数具有的下列特点中，（）是错误的。

A． 如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的

B． 拷贝构造函数只有一个参数，并且是该类对象的引用

C． 拷贝构造函数是一种成员函数

D．拷贝构造函数的名字不能用类名

6：

关于静态成员的描述中，（）是错误的。

A． 静态成员可分为静态数据成员和静态成员函数

B． 静态数据成员定义后必须在类体内进行初始化

C． 静态数据成员初始化不使用其构造函数

D． 静态数据成员函数中不能直接引用非静态成员

7：

设有如下程序结构：

classBox

{…};

voidmain（）

{BoxA,B,C;}

该程序运行时调用

（1）次构造函数；调用

（2）次析构函数。

8：

设A为test类的对象且赋有初值,则语句testB（A）;表示。

例题11：

分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。

#include

classone

{inta1,a2;

public:

one（intx1=0,x2=0）;

};

voidmain（）

{onedata（2,3）;

cout<

cout<

}

分析：

出错原因：

构造函数参数表语法错；构造函数没有函数体；类的对象不能直接访问类的私有成员变量。

改正后的程序如下：

#include

classone

{inta1,a2;

public:

one（intx1=0,intx2=0）{a1=x1;a2=x2;}

intgeta1（）{returna1;}

intgeta2（）{returna2;}

};

voidmain（）

{onedata（2,3）;

cout<

cout<

}

例题12：

分析以下程序的错误原因，给出修改方案使之能正确运行。

#include

classAmplifier{

floatinvol,outvol;

public:

Amplifier（floatvin,floatvout）

{invol=vin;outvol=vout;}

floatgain（）;

};

Amplifier:

:

floatgain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp（5.0,10.0）;

cout<<"\n\nThegainis=>"<

}

分析：

成员函数在类体外定义格式是：

函数返回类型类名：

：

成员函数名（参数表）；成员函数调用格式是：

对象名.成员函数名（参数表）。

改正后的程序如下：

#include

classAmplifier

{floatinvol,outvol;

public:

Amplifier（floatvin,floatvout）{invol=vin;outvol=vout;}

floatgain（）;

};

floatAmplifier:

:

gain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp（5.0,10.0）;

cout<<"\n\nThegainis=>"<

}

例题14：

定义一个学生类，其中有3个数据成员：

学号、姓名、年龄，以及若干成员函数。

同时编写main函数使用这个类，实现对学生数据的赋值和输出。

程序代码如下：

#include

#include

classstudent

{intno;

charname[10];

intage;

public:

student（inti,char*str,intg）

{no=i;

strcpy（name,str）;

age=g;

}

student（）

{no=0;

strcpy（name,”none”）;

age=-1;

}

voiddisplay（）

{if（no>0）cout<<”no”<

”<

elsecout<<”no”<

None!

\n”;

}

};

voidmain（）

{studentd1（1001,”Tom”,18）;

d1.display（）;

studentd2;

d2.display（）;

}

例题15：

计算两点之间的距离。

方法一：

可以定义点类（Point），再定义一个类（Distance）描述两点之间的距离，其数据成员为两个点类对象，两点之间距离的计算可设计由构造函数来实现。

#include

#include

classPoint

{public:

Point（inta=0,intb=0）{x=a;y=b;}

intxcord（）{returnx;}

intycord（）{returny;}

private:

intx,y;

};

classDistance

{public:

Distance（Pointq1,Pointq2）;

doublegetdist（）{returndist;}

private:

Pointp1,p2;

doubledist;

};

Distance:

:

Distance（Pointq1,Pointq2）:

p1（q1）,p2（q2）

{doublex=double（p1.xcord（）-p2.xcord（））;

doubley=double（p1.ycord（）-p2.ycord（））;

dist=sqrt（x*x+y*y）;

}

voidmain（）

{Pointp（0,0）,q（1,1）;

Distancedis（p,q）;

cout<<”Thedistanceis:

”<

}

1． 选择题

（1）对类的构造函数和析构函数描述正确的是（）。

A.A.     构造函数可以重载，析构函数不能重载

B.B.     构造函数不能重载，析构函数可以重载

C.C.     构造函数可以重载，析构函数也可以重载

D.D.     构造函数不能重载，析构函数也不能重载

（2）类的析构函数的作用是（D）。

A.一般成员函数B.类的初始化C.对象初始化D.删除对象

（3）假设OneClass为一个类，则该类的拷贝初始化构造函数的声明语句为（）。

A.OneClass（OneClassp）;B.OneClass&（OneClassp）;

C.OneClass（OneClass&p）;D.OneClass（OneClass*p）;

（5）对于类中定义的成员，其默认的访问权限为（）。

A.publicB.protectedC.privateD.static

（6）为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（）。

A.publicB.protectedC.privateD.static

（7）下面对静态数据成员的描述中，正确的是（）。

A.静态数据成员可以在类体内进行初始化

B.静态数据成员不可以在类体内进行初始化

C.静态数据成员不能受private控制符的作用

D.静态数据成员可以直接用类名调用

（8）下面对静态数据成员的描述中，正确的是（）。

A.静态数据成员是类的所有对象共享的数据

B.类的每一个对象都有自己的静态数据成员

C.类的不同对象有不同的静态数据成员值

D.静态数据成员不能通过类的对象调用

2．2．  写出下列程序的运行结果。

（1）#include

classPoint{

intx,y;

public:

Point（）{x=1;y=1;}

~Point（）{cout<<"Point"<

};

voidmain（）

{Pointa;}

运行结果为：

Point1,1isdeleted.

（3）#include

classCsample

{inti;

public:

Csample（）;

voidDisplay（）;

~Csample（）;

};

Csample:

:

Csample（）

{cout<<”Constructor”<<”,”;

i=0;

}

voidCsample:

:

Display（）{cout<<”i=”<

Csample:

:

~Csample（）

{cout<<”Destructor”<

voidmain（）

{Csamplea;

a.Display（）;

}

运行结果为：

Constructor,i=0,Destructor

（4）#include

#include

classCsample

{inti;

public:

Csample（）{cout<<"constructor1"<

Csample（intval）{cout<<"Constructor2"<

voidDisplay（）

{cout<<"i="<

~Csample（）

{cout<<"Destructor"<

};

voidmain（）

{Csamplea,b（10）;

a.Display（）;

b.Display（）;

}

运行结果为：

Constructor1

Constructor2

i=-858993460

i=10

Destructor

Destructor

（5）#include

classCsample

{private:

inti;

staticintk;

public:

Csample（）;

voidDisplay（）;

};

intCsample:

:

k=0;

Csample:

:

Csample（）{i=0;k++;}

voidCsample:

:

Display（）{cout<<”i=”<

voidmain（）

{Csamplea,b;

a.Display（）;

b.Display（）;

}

运行结果为:

i=0,k=2

i=0,k=2

3．按要求编写程序。

（1）编写一个程序，设计一个产品类Product,其定义如下：

classProduct

{char*name;//产品名称

intprice;//产品单价

intquantity；//剩余产品数量

public:

product（char*n,intpintq）;//构造函数

~product（）;//析构函数

voidbuy（intmoney）;//购买产品

voidget（）const;//显示剩余产品数量

};

并用数据进行测试。

（2）计算两点之间的距离。

提示：

可以定义点类（Point），再定义一个类（Distance）描述两点之间的距离，其数据成员为两个点类对象，两点之间距离的计算可设计由构造函数来实现。

参照本章例15

（3）定义盒子Box类，要求具有以下成员：

可设置盒子形状；可计算盒子体积；可计算盒子的表面积。

#include

classBox

{intx,y,z;intv,s;

public:

vo