第8章类与对象
8．1知识要点
1．掌握类与对象的概念和定义方法，掌握类成员的访问属性。
2．掌握构造函数的概念、定义方法和使用方法。
3．掌握析构函数的概念、定义方法和使用方法。
4．掌握拷贝构造函数的概念、定义方法和使用方法。
5．掌握包含对象成员的类构造函数的定义方法。
6．掌握静态成员的概念、定义方法、作用和特点。
7．掌握友元的概念、定义方法、作用和特点。
8．掌握类模板的定义格式与使用方法。
8．2典型例题分析与解答
例题1：下列有关类的说法不正确的是（）。
A．对象是类的一个实例
B．任何一个对象只能属于一个具体的类
C．一个类只能有一个对象
D．类与对象的关系和数据类型与变量的关系相似
答案：C
分析：对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。
例题2：下面（）项是对构造函数和析构函数的正确定义。
A．void X::X(), void X::~X()
B．X::X(参数),X::~X()
C．X::X(参数),X::~X(参数)
D．void X::X(参数),void X::~X(参数)
答案：B
分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、不可重载。
例题3：（）的功能是对象进行初始化。
A．析构函数B. 数据成员 C.构造函数 D.静态成员函数
答案：C
分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作；
例题4：下列表达方式正确的是（）。
A．class P{B．class P{
public： public：
int x=15； int x；
voidshow(){cout< }； } C． class P{ D. class P{ intf; public： }； int a； f=25； void Seta (int x) {a=x;} 答案：D 分析：在类体内不可对数据成员进行初始化；类定义结束时需用分号；只有类中的成员函数才能存取类中的私有数据。 例题5：拷贝构造函数具有的下列特点中，（）是错误的。 A．如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的 B．拷贝构造函数只有一个参数，并且是该类对象的引用 C．拷贝构造函数是一种成员函数 D．拷贝构造函数的名字不能用类名 答案：D 分析：如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的；拷贝构造函数只有一个参数，并且是该类对象的引用；拷贝构造函数的名字与类同名，并且不被指定返回类型；拷贝构造函数是一种成员函数。 例题6：关于静态成员的描述中，（）是错误的。 A．静态成员可分为静态数据成员和静态成员函数 B．静态数据成员定义后必须在类体内进行初始化 C．静态数据成员初始化不使用其构造函数 D．静态数据成员函数中不能直接引用非静态成员 答案：B 分析：静态成员可分为静态数据成员和静态成员函数；静态数据成员被定义后，必须对它进行初始化，初始化在类体外进行，一般放在该类的实现部分最合适，也可以放在其他位置，例如，放在主函数前面等；静态数据成员初始化与该类的构造函数和析构函数无关；在静态成员函数的实现中，可以直接引用静态成员，但不能直接引用非静态成员。 例题7：关于友元的描述中，（）是错误的。 A．友元函数是成员函数，它被说明在类体内 B．友元函数可直接访问类中的私有成员 C．友元函数破坏封装性，使用时尽量少用 D．友元类中的所有成员函数都是友元函数 答案：A 分析：友元函数是非成员函数，在类体内说明了，在类体外定义，定义和调用等同于一般的普通函数；由于它可以直接访问类的私有成员，因此破坏了类的封装性和隐藏性，尽量少用。 例题8：设有如下程序结构： class Box { … }; void main() {Box A,B,C; } 该程序运行时调用 (1) 次构造函数；调用 (2) 次析构函数。 答案：(1)3(2)3 分析：每创建一个对象自动调用一次构造函数，在这里创建了A、B、C三个对象，所以共调用了三次构造函数；每释放一个对象，系统自动调用一次析构函数，A、B、C对象释放时，分别调用析构函数，所以析构函数共调用了三次。 例题9：设A为test类的对象且赋有初值,则语句test B(A); 表示。 答案：将对象A复制给对象B。 分析：执行test B(A);语句相当于调用了默认复制构造函数，将A对象的属性复制给B对象。 例题10：利用“对象名.成员变量”形式访问的对象成员仅限于被声明为 (1)的成员；若要访问其他成员变量，需要通过 (2) 函数或 (3) 函数。 答案：(1) public (2) 成员函数 (3)友元函数 分析：类体内的数据成员可声明为公有的、私有的和保护的，公有的数据成员可利用“对象名.成员变量”形式来进行访问；私有的数据成员能被类中的其他成员函数或友元函数所调用；保护的数据成员可以在类体中使用，也可以在派生类中使用，但不能在其他类外通过对象使用。 例题11：分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。 #include class one { int a1,a2; public: one(int x1=0, x2=0); }; void main() { one data(2,3); cout< cout< } 分析：出错原因：构造函数参数表语法错；构造函数没有函数体；类的对象不能直接访问类的私有成员变量。 改正后的程序如下： #include class one { int a1, a2; public: one(int x1=0, int x2=0) {a1=x1;a2=x2;} int geta1(){ return a1; } int geta2(){ return a2; } }; void main() {one data(2,3); cout< cout< } 例题12：分析以下程序的错误原因，给出修改方案使之能正确运行。 #include class Amplifier{ float invol,outvol; public: Amplifier(float vin,float vout) {invol=vin;outvol=vout;} float gain(); }; Amplifier::float gain(){ return outvol/invol; } void main() {Amplifier amp(5.0,10.0); cout<<"\n\nThe gain is =>"< } 分析：成员函数在类体外定义格式是：函数返回类型类名：：成员函数名（参数表）；成员函数调用格式是：对象名.成员函数名（参数表）。 改正后的程序如下： #include class Amplifier { float invol,outvol; public: Amplifier(float vin,float vout) {invol=vin;outvol=vout;} float gain(); }; float Amplifier::gain(){ return outvol/invol;} void main() { Amplifier amp(5.0,10.0); cout<<"\n\nThe gain is =>"< } 例题13：下列程序的运行结果是。 #include class point {int x,y; public: point(int a,int b) {x=a;y=b; cout<<"calling the constructor function."< } point(point &p); friend point move(point q); ~point(){cout<<"calling the destructor function.\n";} int getx(){return x;} int gety() {return y;} }; point::point(point &p) {x=p.x;y=p.y; cout<<"calling the copy_initialization constructor function.\n"; } point move(point q) {cout<<"OK!\n"; int i,j; i=q.x+10; j=q.y+20; point r(i,j); return r; } void main() { point m(15,40),p(0,0); point n(m); p=move(n); cout<<"p="< } 分析：根据构造函数、拷贝构造函数和友元函数的特点，执行该程序后，输出结果是： calling the constructor function. calling the constructor function. calling the copy_initialization constructor function. calling the copy_initialization constructor function. OK！ calling the constructor function. calling the copy_initialization constructor function. calling the destructor function. calling the destructor function. calling the destructor function. P=25,60 calling the destructor function. calling the destructor function. calling the destructor function. 说明： （1）构造函数执行三次，分别初始化主函数中的对象m，p和move函数中的对象r。（2）拷贝构造函数共执行了三次。第一次，初始化对象n；第二次在调用函数move()时，实参n给形参q进行初始化；第三次是执行函数move的return r；语句时，系统用r初始化一个匿名对象时使用了拷贝构造函数。 （3）析构函数执行了六次。在退出函数move时释放对象r和q共调用二次；返回主函数后，匿名对象赋值给对象p后，释放匿名对象又调用一次析构函数；最后退出整个程序时释放对象m，n和p调用三次。 例题14：定义一个学生类，其中有3个数据成员：学号、姓名、年龄，以及若干成员函数。同时编写main函数使用这个类，实现对学生数据的赋值和输出。 程序代码如下： #include #include classstudent {int no; char name[10]; int age; public: student(int i, char *str, int g) {no=i; strcpy(name,str); age=g; } student( ) {no=0; strcpy(name,”none”); age=-1; } void display() {if (no>0)cout<<”no” < } }; void main() { student d1(1001,”Tom”,18); d1.display(); student d2; d2.display(); } 例题15：计算两点之间的距离。 方法一：可以定义点类（Point），再定义一个类（Distance）描述两点之间的距离，其数据成员为两个点类对象，两点之间距离的计算可设计由构造函数来实现。#include #include class Point { public: Point(int a=0, int b=0) {x=a; y=b; } int xcord() { return x;} int ycord (){ return y;} private: int x,y; }; class Distance { public: Distance(Point q1,Point q2); double getdist() {return dist; } private: Point p1,p2; double dist; }; Distance::Distance(Point q1,Point q2):p1(q1),p2(q2) { double x=double(p1.xcord()-p2.xcord()); double y=double(p1.ycord()-p2.ycord()); dist=sqrt(x*x+y*y); } void main() { Point p(0,0),q(1,1); Distance dis(p,q); cout<<”The distance is: ”< } 方法2：将两点之间距离函数声明为Point类的友元函数。#include #include class Point {public: Point(int a=0, int b=0) {x=a; y=b; } int xcord() { return x;} int ycord (){ return y;} private: int x,y; friend double Distance(Point p1,Point p2); }; double Distance(Point p1,Point p2) { double dx=double(p1.x-p2.x); double dy=double(p1.y-p2.y); return sqrt(dx*dx+dy*dy); } void main() { Point q1(0,0),q2(1,1); cout<<”The distance is: ”< 8．3教材习题分析与解答 1．选择题 （1）对类的构造函数和析构函数描述正确的是（）。 A. 构造函数可以重载，析构函数不能重载 B. 构造函数不能重载，析构函数可以重载 C. 构造函数可以重载，析构函数也可以重载 D. 构造函数不能重载，析构函数也不能重载 答案：A （2）类的析构函数的作用是（D）。 A.一般成员函数 B.类的初始化 C.对象初始化 D.删除对象 答案：D （3）假设OneClass为一个类，则该类的拷贝初始化构造函数的声明语句为（）。 A.OneClass(OneClass p); B. OneClass& (OneClass p); C. OneClass(OneClass & p); D. OneClass (OneClass *p); 答案：C (4)下面对于友元函数描述正确的是（）。 A.友元函数的实现必须在类的内部定义 B.友元函数是类的成员 C.友元函数破坏了类的封装性和隐藏性 D.友元函数不能访问类的私有成员 答案：C （5）对于结构中定义的成员，其默认的访问权限为（）。 A.public B. protected C.private D. static 答案：C (6)为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（）。 A.public B. protected C.private D. static 答案：A （7）下面对静态数据成员的描述中，正确的是（）。 A.静态数据成员可以在类体内进行初始化 B.静态数据成员不可以在类体内进行初始化 C.静态数据成员不能受private控制符的作用 D.静态数据成员可以直接用类名调用 答案：C （8）下面对静态数据成员的描述中，正确的是（）。 A.静态数据成员是类的所有对象共享的数据 B.类的每一个对象都有自己的静态数据成员 C.类的不同对象有不同的静态数据成员值 D.静态数据成员不能通过类的对象调用 答案：A 2．写出下列程序的运行结果。 （1）#include class Point{ int x,y; public: Point(){x=1;y=1;} ~Point(){cout<<"Point "< void main() {Pointa;} 运行结果为： Point 1,1 is deleted. （2） #include #include int count=0; class Point {int x,y; public: Point() { x=1;y=1; count++; } ~Point(){count--;} friend void display(); }； void display() { cout <<"There are "< { Point a; display(); {Point b[5]; display(); } display(); } 运行结果为： There are 1 points, There are 6 points, There are 1 points, （3）#include class Csample {int i; public: Csample( ); void Display( ); ~Csample(); }; Csample::Csample( ) { cout<<”Constructor”<<”,”; i=0; } void Csample::Display() {cout<<”i=”< { cout<<”Destructor”< void main( ) { Csample a; a.Display( ); } 运行结果为： Constructor,i=0,Destructor (4) #include #include class Csample { int i; public: Csample(){cout <<"constructor1" < Csample(int val){cout <<"Constructor2"< {cout<<"i="< ~Csample() {cout<<"Destructor"< }; void main() {Csample a,b(10); a.Display(); b.Display(); } 运行结果为： Constructor1 Constructor2 i=-858993460 i=10 Destructor Destructor (5)#include class Csample {private: int i; static int k; public: Csample( ); void Display( ); }; int Csample::k=0; Csample::Csample( ) { i=0;k++;} void Csample::Display( ){ cout<<”i=”< void main( ) { Csample a,b; a.Display( ); b.Display( ); } 运行结果为: i=0,k=2 i=0,k=2 3．按要求编写程序。 (1)编写一个程序，设计一个产品类Product,其定义如下： class Product {char *name;//产品名称 int price; //产品单价 int quantity； //剩余产品数量 public: product(char *n,int p int q); //构造函数 ~product( ); //析构函数 void buy(int money);//购买产品 void get() const;//显示剩余产品数量 }; 并用数据进行测试。 (2)计算两点之间的距离。 提示：可以定义点类（Point），再定义一个类（Distance）描述两点之间的距离，其数据成员为两个点类对象，两点之间距离的计算可设计由构造函数来实现。 参照本章例15 (3)定义盒子Box类，要求具有以下成员：可设置盒子形状；可计算盒子体积；可计算盒子的表面积。 #include class Box { int x,y,z;int v,s; public: void init(int x1=0,int y1=0,int z1=0){x=x1;y=y1;z=z1;} void volue(){v=x*y*z;} void area() {s=2*(x*y+x*z+y*z);} void show() {cout<<"x= "< cout<<"长方形的周长和面积为："< (6)编写一个程序，采用一个类求n!,并输出10!的值。 #include class fac { int p; public: fac() { p=1;} fac( int j) {p=1; if(j>=0) for(int i=1 ;i<=j;i++) p=p*i; else cout<<"数据错误\n"; } void show() { cout<<" 阶乘为："< }; void main() { int n; cout<<"请输入一个整数："; cin>>n; fac a(n); cout< } (7)编写一个程序，设计一个Cdate类，它应该满足下面的条件： 1）用这样的格式输出日期：日-月-年； 2）输出在当前日期上加两天后的日期； 3）设置日期。 #include class Cdate {int year,month,day; int y1,m1,d1; public: void setdate(int y,int m,int d) {year=y;month=m;day=d;} void show() {cout<<"当前日期："< cout<<"两天后日期："< } void datetwo() //加一天后的年月日 { d1=day;y1=year;m1=month; for(int i=0;i<2;i++) {d1++; switch(d1) {case 29:if(!(month==2 &&(year%400==0||year%4==0&&year%100!=0))) {m1=3;d1=1;};break; case 30:if(month==2 &&(year%400==0||year%4==0&&year%100!=0)) {m1=3;d1=1;};break; case 31:if(month==4||month==6||month==9||month==11) {m1=m1+1;d1=1;};break; case 32: m1=m1+1;d1=1;if(month==12){y1=y1+1;m1=1;};break; } } } }; void main() {Cdated; int y,m,d1; cout<<"请输入年月日: "; cin>>y>>m>>d1; d.setdate(y,m,d1);//加一天 d.setdate(y,m,d1);//再加一天 d.datetwo(); d.show(); } 8.4 补充习题 1．选择题 (1) 下列有关类的说法不正确的是。 A.类是一种用户自定义的数据类型 B.只有类中的成员函数或类的友元函数才能存取类中的私有数据 C.在类中(用class定义)，如果不作特别说明，所有的数据均为私有数据 D.在类中(用class定义)，如果不作特别说明，所有的成员函数均为公有数据 (2) 以下有关析构函数的叙述不正确的是( ) A. 在一个类只能定义一个析构函数 B. 析构函数和构造函数一样可以有形参 C. 析构函数不允许用返回值 D. 析构函数名前必须冠有符号“~” (3) 以下有关类与结构体的叙述不正确的是( ) A. 结构体中只包含数据；类中封装了数据和操作 B. 结构体的成员对外界通常是开放的；类的成员可以被隐藏 C. 用struct不能声明一个类型名；而class可以声明一个类名 D. 结构体成员默认为public；类成员默认为private (4) 以下叙述中不正确的是( ) A. 一个类的所有对象都有各自的数据成员，它们共享函数成员 B. 一个类中可以有多个同名的成员函数 C. 一个类中可以有多个构造函数、多个析构函数 D. 在一个类中可以声明另一个类的对象作为它的数据成员 (5) 以下不属于构造函数特征的是( ) A. 构造函数名与类名相同 B. 构造函数可以重载 C. 构造函数可以设置默认参数 D. 构造函数必须指定函数类型 (6) 以下有关类和对象的叙述不正确的是( ) A. 任何一个对象都归属于一个具体的类 B. 类与对象的关系和数据类型与变量的关系相似 C. 类的数据成员不允许是另一个类的对象 D. 一个类可以被实例化成多个对象 (7) 设有定义： class person { int num; char name[10]; public: void init(int n, char *m); ... }; person std[30]; 则以下叙述不正确的是( ) A. std是一个含有３０个元素的对象数组 B. std数组中的每一个元素都是person类的对象 C. std数组中的每一个元素都有自己的私有变量num和name D. std数组中的每一个元素都有各自的成员函数init (8) 设有以下类的定义： class Ex { int x; public: void setx(int t=0); }; 若在类外定义成员函数setx(),以下定义形式中正确的是( ) A. void setx(int t) { ... } B. void Ex::setx(int t) { ... } C. Ex::void setx(int t) { ... } D. void Ex::setx(){ ... } (9) 以下关于静态成员变量的叙述不正确的是（） A．静态成员变量为类的所有对象所公有 B．静态成员变量可以在类内任何位置上声明 C．静态成员变量的赋初值必须放在类外 D．定义静态成员变量时必须赋初值 (10) 定义静态成员函数的主要目的是（） A．方便调用B．有利于数据隐藏 C．处理类的静态成员变量D．便于继承 (11) 以下叙述不正确的是（） 使用静态数据成员： A．可以节省内存空间 B．是为了解决数据共享问题 C．可以直接用类名来引用D．可以提高序运算速度 2.填空题 (1) OOP技术由、、方法、消息和继承五个基本的概念所组成。 (2)类的成员函数可以在定义，也可以在定义。 (3)类test的析构函数名是。 (4)类是用户定义的类型，具有类类型的变量称作_______________。 (5)一个类的析构函数不允许有。 (6)建立对象时，为节省内存，系统只给_______分配内存。 (7)用于定义C++的类的关键字有____________、___________和union。 (8)类test的构造函数是和_______同名的函数，析构函数是__________。 (9)类中的数据和成员函数默认访问类型为。 (10)当建立一个新对象时，程序自动调用_______________。 3. 改错题 (1) 下面的程序定义了一个Point类，找出程序中的错误语句并改正。 #include class Point{ int x; public: void Point(int a) {x=a;} int Getx(){return x;} void Show() {cout< } ; void main() {Point A(76); cout< } (2) 根据静态成员的特点，指出下列程序的错误。 #include #include class part { public: Part(char *pname=”no name”) { strncpy(name,pname); noofpart++; no=noofpart; cout<<”create the no: ”< } ~Part() { noofpart--; cout<<”destroy the no: ”< } static int number() { return no; } protected: static int noofpart=0; int no; char name[40]; }; void main() { Part p1; Part p2; } (3) 以下程序的功能是：利用友员函数为类的成员变量进行初始化，然后利用成员函数输出。请改正程序中的错误，使之能正确运行。 #include class A {int a,b; public: friend void setval(int i,int j); void showA() {cout< }; void setval(int i,int j) {a=i; b=j;} void main() {A obj1; setval(2,3); obj1.showA(); } 4. 看程序写结果 (1) #include class test { public: test(); test(int); ~test(); void display(); protected: int n; }; test::test() {cout<<”Constructing normally\n”;} test::test(int num) {n=num; cout<<”Constructing with a number: ”< } void test::display() {cout<<”Display a number: ”< test::~test(){cout<<”Destructing”< void main() {test obj1; test obj2(59); obj1.display(); obj2.display(); } (2) #include class Count {public: Count() { count++;} static int getn() {return count;} ~Count() { count--; } private: static int count; }; int Count::count=100; void main() { Count c1,c2,c3,c4; cout< } (3) #include class myclass {int a,b; public: void init(int i, int j) {a=i; b=j;} friend int sum(myclass x); }; int sum( myclass x) {return x.a+x.b; } void main() {myclass y; y.init(15,20); cout< } 5. 编程题 （1）某商店经销一种货物，货物成箱购进，成箱卖出，购进和卖出时以重量为单位，各箱的重量不一样，因此，商店需要记下目前库存货物的总量，要求把商店货物购进和卖出的情况模拟出来。 （2）定义一个Car类和Truck类，用友元实现两类对象行使速度的快慢比较。 C语言的类和对象 【类实现了C++面向对象程序设计的基础，我们使用类来定义对象的属性，类是 C++封装的基本单元。】 一、----- 类 使用关键字class创建类，一个类声明定义了一个连接代码和一个数据的新类型，这个新的类型又可以用来声明该类的对象。因此，类又是逻辑逻辑抽象概念，儿对象是物理存在的，也就是说对象是类的实例。 类的声明语法上和结构相似。 [一下是完整的类的形式] class class_name { private data and functions access_specifier: data and functions access_specifiter: data and functions //…….. access_specifier:是 data and functions }object_list; 其中，object_list是任选项，如过存在，他声明类的对象。access_specifier为下面的三个关键字之一： Public private protected 默认时，在类声明的函数和数据属于该类私有，只能被该类的成员访问。如果使用，pubilc访问限定符号，函数和程序就可以被其他部分访问。Protected访问限定符，仅在涉及继承的时候才需要（十五章了解）。访问限定符已经使用，其作用就保持到遇到别的访问限定符或者达到类声明的结束处。 在类声明内可以任意改变访问说明符号，对于某些声明，可以转换位public，然后再转换成private。 [如下所述] /******************************* ··构造函数和析构函数学习··· *******************************/ //Using a constructor and destructor. /******************************* 声明C++ 程序头文件 *******************************/ #include C++实验报告 实验4 类与对象 一、实验目的 1、掌握类的声明和使用 2、掌握类的声明和对象的声明 3、复习具有不同访问属性的成员的访问方式 4、观察构造函数和析构函数的执行过程 5、学习类的组合使用方法 6、使用DEBUG调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序 二、实验任务 1、声明一个CPU类，包含等级rank、频率frequency、电压voltage等属性，有两个公有成员函数run、stop。其中，rank为枚举类型CPU-Rank，声明为enum CPU-Rank{P1=1,P2,P3,P4,P5,P6,P7}, frequency为MHz的整数型，voltage为浮点型的电压值。观察构造函数好析构函数的调用顺序。 2、声明一个简单的Computer类，有数据成员芯片cpu、内存ram、光驱cdrom 等，有两个公有成员函数run、stop。cpu为CPU类的一个对象，ram为RAM 类的一个对象，cdrom为CDROM类的一个对象，声明并实现这个类。 3、设计一个用于人事管理的People类。考虑到通用性，这里只抽象出所有类型人员都具有的属性：number编号、sex性别、birthday出生日期、id身份证号等。其中出生日期声明为一个日期类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括：构造函数和析构函数、拷贝构造函数、内嵌成员函数、组合。 三、实验内容 任务1：首先声明枚举类型，在这里出现了知识性错误，不清楚具体应如何声明，经查询相关书籍，知道应在类外进行声明。初次用类来进行编程，在概念上是有一些混乱的，例如构造函数和析构函数的调用顺序等。在用debug单步调试后，明白其中道理。 源程序： //Lab4_1.cpp #include 实验3 类和对象的创建与使用 一、实验目的 1、掌握类的定义和对象的创建； 2、掌握构造方法的作用、格式及重载； 3、掌握修饰词对成员存取权限的限制。 4、掌握实例成员、类成员的定义和使用方法。 二、实验内容 1、定义储蓄账户类，并创建对象模拟银行基本操作。 2、两游戏角色决斗。给定二个不同的角色，判定交手的胜负关系。(选做) 3、设计学生类、学校类、录取类，根据学生成绩和学校分数线，判断是否录取。 三、实验步骤 说明：请将第1,3题代码写入实验报告实验步骤处。 1、模拟银行账户功能。 编写程序，模拟银行账户功能。要求如下： 属性：账号、姓名、地址、存款余额、最小余额。 方法：存款、取款、查询。 根据用户操作显示储户相关信息。 如存款操作后，显示储户原有余额、今日存款数额及最终存款余额。 取款时，若取款成功，显示信息提示；若最后余额小于最小余额，拒绝取款，并显示信息提示。具体显示信息可据方便性原则自拟。 public class AccountOperation { public static void main(String [] args) { Account account1=new Account("650101","柳眉","天河学院",800.00); Account account2=new Account("650102","郑杰","天河学院",200.00); account1.transfer(account1,account2,300.0); account1.deposit(300.5); account1.withdraw(200); account1.withdraw(300); account1.query(); System.out.println(account1.toString()); //System.out.println(https://www.doczj.com/doc/e112067036.html,); error!! } } class Account { private String account; private String name; private String address; private double balance; 类和对象 一、选择题 1、下面对方法的作用描述不正确的是：（ d ） A、使程序结构清晰 B、功能复用 C、代码简洁 D、重复代码 2、方法定义的变量：（ b ） A 、一定在方法所有位置可见B、可能在方法的局部位置可见 C、在方法外可以使用 D、在方法外可见 3、方法的形参：（a） A、可以没有 B、至少有一个 C、必须定义多个形参 D、只能是简单变量 4、方法的调用：（c） A、必须是一条完整的语句 B、只能是一个表达式 C、可能是语句，也可能是表达式 D、必须提供实际参数 5、return 语句：( d) A、不能用来返回对象 B、只可以返回数值 C、方法都必须含有 D、一个方法中可以有多个return 语句 6、void 的含义：（d） A、方法体为空 B、方法体没有意义 C、定义方法时必须使用 D、方法没有返回值 7、main()方法的返回类型是：（ c ） A 、boolean B、int C、void D、static 8、方法重载所涉及的方法：（ a ） A、有相同的名字 B、参数个数必须不同 C、参数类型必须不同 D、返回类型必须不同 9、下面关于类和对象之间关系的描述，正确的是（ c ） A、联接关系Ｂ、包含关系Ｃ、具体与抽象的关系Ｄ、类是对象的具体化 10、下面关于java中类的说法哪个是不正确的（ c ） A、类体中只能有变量定义和成员方法的定义，不能有其他语句。 B、构造方法是类中的特殊方法。 C、类一定要声明为public的，才可以执行。 D、一个java文件中可以有多个class定义。 11、下列哪个类声明是正确的( d) A、public void H1｛…｝ B 、public class Move()｛…｝ C、public class void number{} D、public class Car｛…｝ 12、下面的方法声明中，哪个是正确的（c） A、public class methodName(){} B、public void int methodName(){} C、public void methodName(){} D、public void methodName{} 13、下述哪些说法是不正确的？（ b ） A、实例变量是类的成员变量 B、实例变量是用static关键字声明的 C、方法变量在方法执行时创建 D、方法变量在使用之前必须初始化 14、下面对构造方法的描述不正确是( b)。 A、系统提供默认的构造方法 B、构造方法可以有参数，所以也可以有返回值 C、构造方法可以重载 D、构造方法可以设置参数 15、定义类头时，不可能用到的关键字是( b)。 A、class B、private C、extends D、public 16、下列类头定义中，错误的是( )。 A、public x extends y {...} B、public class x extends y {...} C、class x extends y implements y1 {...} D、class x {...} 17、设A为已定义的类名，下列声明A类的对象a的语句中正确的是( ) 。 A、float A a; B、public A a=A( ); C、A a=new int( ); D、static A a=new A( ); 18、设i , j为类X中定义的int型变量名，下列X类的构造方法中不正确的是( a )。 A、void X(int k ){ i=k; } B、X(int k ){ i=k; } C、X(int m, int n ){ i=m; j=n; } D、X( ){i=0;j=0; } 19、有一个类A，以下为其构造方法的声明，其中正确的是 实验九类和对象的使用实验报告 一实验目的 1、学会用构造函数对类对象进行初始化 2、掌握析构函数，并了解构造函数和析构函数的调用顺序 3、了解对象数组和对象指针的用法 4、学会共用数据的保护，了解常对象、常成员函数等的使用限制 二实验内容和要求 1.回顾课本知识，掌握重点和难点，认真分析例题熟悉本章内容。 2.完成本章课后习题2、6、7题，认真分析每一题的代码。 三实验环境 Visual C++6.0开发环境 四源程序 2、 #include Date::Date() { month=1; day=1; year=2005; } void Date::display() { cout< JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。 计算机科学与技术实验报告 实验二类和对象(1) 姓名：易XX 班级：计科二班学号：2015110121 实验目的：深入理解类和对象，学会定义类，申明私有、公有变量，学会定义对象，并调用成员函数，解决实际问题。 实验内容： （一）、题目要求： 定义一个描述角度的类CAngle，包含的内容如下： (1)私有成员变量value，表示角度，类型为double； (2)公有成员变量SetValue，实现功能是使用形参为value赋值。 声明为：viod SetValue（double）； (3)公有成员函数GetCos，实现功能计算余弦值，并作为返回值返回。 声明为 double GetCos（）； 编程实现如下功能：定义一个Cangle类的对象deg，调用成员函数设置deg的角度为30度，调用成员函数计算并输出deg的余弦值。 代码： #include 实验报告_实验3 类与对象(学生学号_姓 名) 一、实验目的 1．熟悉类的组成，掌握类的声明方法； 2．理解构造方法的作用，并掌握构造方法的定义； 3．熟练使用访问器和设置器实现信息隐藏和封装； 4．熟悉一般方法、构造方法的重载； 5．能够正确地区分静态变量与实例变量、静态方法与实例方法的不同，掌握静态变量和静态方法的使用；6．掌握对象的创建、引用和使用及向方法传递参数的方式； 7．掌握this关键字的使用以及对象数组的创建和访问； 8．掌握Java包的创建、包成员的各种访问方式; 9．掌握一维数组：声明，创建，初始化，数组元素的访问； 10．掌握多维数组的概念：二维数组的声明，初始化，元素的访问。 二、实验内容与步骤 1．请回答下列问题： （1）Cirecle类定义了几个属性？它们的类型、访问权限各为什么？ 答：两个PI，floatl类型，静态私有权限 Radius，float；类型，私有权限 （2）类中的“PI”的值可以在程序的方法中更改吗？ 答：不可以，因为PI为静态变量 （3）Cirecle类定义了几个方法？它们的访问权限怎样？ 答：四个，getRadius()，setRadius(float radius)，getPerimeter()，getArea()都是公有权限 2．写出Rectangle类的程序代码： class Rectangle { private float width; private float length; public float getWidth( ) //获取矩形宽度 {return width;} public float getLength( ) //获取矩形长度 {return length;} public float getPerimeter( ) //获取矩形周长 {return 2*(width+length);} public float getArea( ) //获取矩形面积 {return (width*length);} public void setWidth(float w) //设置矩形宽度 {width=w;} public void setLength(float l) //设置矩形长度 {length=l;} } 3．回答下列问题： (1)该程序中有几个类？主类是什么？如果将这两个类放在一个文件中，源程序文件名应是什么？答：两个类：Circle、CircleTest；主类是CircleTest；源程序文件名是CircleTest。 实验四数组、指针与字符串 1.实验目的 1.学习使用数组 2.学习字符串数据的组织和处理 3.学习标准C++库的使用 4.掌握指针的使用方法 5.练习通过Debug观察指针的内容及其所指的对象的内容 6.联系通过动态内存分配实现动态数组，并体会指针在其中的作用 7.分别使用字符数组和标准C++库练习处理字符串的方法 2.实验要求 1.编写并测试3*3矩阵转置函数，使用数组保存3*3矩阵。 2.使用动态内存分配生成动态数组来重新完成上题，使用指针实现函数的功能。 3.编程实现两字符串的连接。要求使用字符数组保存字符串，不要使用系统函数。 4.使用string类定义字符串对象，重新实现上一小题。 5.定义一个Employee类，其中包括姓名、街道地址、城市和邮编等属性，以及change_name()和display()等函数。Display()显示姓名、街道地址、城市和邮编等属性，change_name()改变对象的姓名属性。实现并测试这个类。 6.定义包含5个元素的对象数组，每个元素都是Employee类型的对象。 7. （选做）修改实验4中的选做实验中的people（人员）类。具有的属性如下：姓名char name[11]、编号char number[7]、性别char sex[3]、生日birthday、身份证号char id[16]。其中“出生日期”定义为一个“日期”类内嵌对象。用成员函数实现对人员信息的录入和显示。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、聚集。在测试程序中定义people类的对象数组，录入数据并显示。 3.实验内容及实验步骤 1.编写矩阵转置函数，输入参数为3*3整形数组，使用循环语句实现矩阵元素的行列对调，注意在循环语句中究竟需要对哪些元素进行操作，编写main（）函数实现输入、输出。程序名：lab6_1.cpp。 2.改写矩阵转置函数，参数为整型指针，使用指针对数组元素进行操作，在main（）函数中使用new操作符分配内存生成动态数组。通过Debug观察指针的内容及其所指的对象中的内容。程序名：lab6_2.cpp。 3.编程实现两字符串的连接。定义字符数组保存字符串，在程序中提示用户输入两个字符串，实现两个字符串的连接，最后用cout语句显示输出。程序名：lab6_3.cpp。用cin实现输入，注意，字符串的结束标志是ASCII码0，使用循环语句进行字符串间的字符拷贝。 4.使用string类定义字符串对象，编程实现两字符串的连接。在string类中已重载了运算符“+=”实现字符串的连接，可以使用这个功能。程序名：lab6_4.cpp。 5.在employee.h文件中定义Employee类。Employee类具有姓名、街道地址、城市和邮编等私有数据成员，在成员函数中，构造函数用来初始化所有数据成员;display()中使用cout显示 浙江理工大学信息学院 面向对象程序设计实验报告 实验名称：类的定义与使用学时安排：3 实验类别：设计性实验实验要求：1人1组姓名：邵旸珂学号：2016329621068 ￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣一、实验目的 1）掌握类的概念、类的定义格式、类与结构的关系、类的成员属性和类的封装性； 2）掌握类对象的定义； 3）理解类的成员的访问控制的含义，公有、私有和保护成员的区别； 4）掌握构造函数和析构函数的含义与作用、定义方式和实现，能够根据要求正确定义和重载构造函数。能够根据给定的要求定义类并实现类的成员函数； 二、实验原理介绍 通过建立类及对象，用类的成员函数和对象访问类的成员； 利用建立类的构造函数，完成类的成员的初始化工作； 三、实验设备介绍 软件需求: windows或linux下的c++编译器 硬件需求: 对于硬件方面的要求，建议配置是Pentium III 450以上的CPU 处理器，64MB以上的内存，200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。 四、实验内容 编写一个程序，模拟电梯的功能。功能接口包括电梯上行按钮、下行按钮、楼层选择和电梯在行驶过程中的楼层显示。 要求： 1.由用户选择按上行按钮还是下行按钮，选择操作后再由用户输入要进入的楼层，进而电梯开始运行，显示所到的每一楼层层数。 2.如果是上行，则选择输入的楼层号不能比当前楼层号小，否则应给出不合法提示。 3. 如果是下行，则选择输入的楼层号不能比当前楼层号大，否则应给出不合法提示。 4.电梯一旦开始运作就会始终运行，直到窗口关闭。 5.电梯在经过不同楼层时，最好每个楼层的显示之间能有延迟，最终停靠的楼层的输出形式能更加醒目。如果可以，在电梯最初开始运行时，能在电梯由内部显示当前日期（提示：实现这些功能时，需要调用系统api，实现时间显示功能可以使用CDate类）。 五程序清单 #include 试验四 类和对象的创建 一.类的定义 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类用来定义对象的模板。 类的实现包括两部分：类声明和类体。基本格式为： 修饰符class类名[extends父类名]{ /*类体的内容*/ } 1.类声明 以下是一个类声明的例子。 class People成为类声明，People是类名。习惯上，类名的第一个字母大写，但这不是必须的。类的名字不能是Java中的关键字，要符合标识符规定，即类的名字可以由字母、下划线、数字或美元符号组成，并且第一个字母不能是数字。但给类命名时，最好遵守下列规则： (1)如果类名使用拉丁字母，那么名字的首写字母使用大写字母，如Hello、Time、People等。 (2)类名最好容易识别，当类名由几个“单词”复合而成时，每个单词的首写字母使用大写，如BeijingTi me、AmericanGame、HelloChina等。 2.类体 编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的一对大括号“{”、“}”以及它们之间的内容称为类体，大括号之间的内容称为类体的内容。 类体的内容由两部分构成：一部分是变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。 下面是一个类名为“Trapezia”的类，类体内容的变量定义部分定义了4个float类型变量：top、bottom、h igh和laderArea，方法定义部分定义了两个方法：“getArea”和“setHigh”。 二.对象 1.对象的创建 创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)对象的声明。 一般格式为： 类的名字对象名字; 如： 这里People是类的名字，zhubajie是我们声明的对象的名字。 (2)为声明的对象分配内存。 使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（你一定还记得构造方法的名字必须和类名相同这一规定），如： 例1： 「注」如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。 2.对象的使用 对象不仅可以改变自己变量的状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 例2： Java编程面向对象——类与对象的关系 面向对象是一种组件化的设计思想，OOA、OOD、OOP 类与对象是整个面向对象之中最为基础的组成单元，如果需要给划出定义：类就是共性的集合，而对象是某一个性的产物；所有类实际上是用来描述一个对象的结构。 类是通过对象来使用的，而对象是通过类来创建的。 类与对象的基本定义： 在程序中，定义类，可以使用“class 类名称{}”的语法结构完成。 而类之中的组成主要有两点： * Field （属性、成员、变量），就是一推变量的集合 * Method （方法、行为），此时的方法是由对象调用的。 这个类中定义了两个属性和一个方法（可以定义更多属性和方法） *类虽然存在，但是类的使用，必须有对象； 对象的定义格式： 声明并实例化对象： 类名称对象名称 = new 类名称(); 分步完成： 声明对象：类名称对象名称 = null； 实例化对象：对象名称 = new 类名称(); 引用数据类型： 引用数据类型最大的不同在于需要内存的开辟及使用，所以关键字new 的主要功能就是开辟内存空间； 即：只要引用数据类型想使用，就必须使用关键字new 来开辟空间。 当一个对象实例化之后就可以使用以下方式利用对象来操作类的结构： 对象.属性：表示要操作类中属性内容 对象.方法()：表示要调用类中的方法内容 内存概念： 堆内存：保存每一个对象的属性内容，堆内存需要用关键字 new 才可以开辟； 栈内存：保存的是一块堆内存的地址。简单的理解，栈内存保存的是对象的名字； 编程中的栈内存和堆内存的操作过程： 引用数据的初步分析： 引用是整个 Java 开发中的核心精髓所在，即：只有掌握了“引用”这一概念之后，才能加入下一步学习，类似C/C++ 中的指针概念。 在所有的引用分析里面，最关键的还是在于关键字 “new ”，每一次使用关键字new ，都会开辟新的堆内存空间，如果你的代码里面声明两个对象，并且使用了关键字new 为两个对象分别实例化操作，那么一定是各自占有各自(独立)的堆内存空间 1.实现简易计算器，分别实现两个整数、三个浮点数的加法运算.（用JAVA中的类和对象） 源码如下： package days;//包名自己修改 import java.util.Scanner;//注意别忘记导入这个包名了public class NumSum { public int add(int num1,int num2){ return num1+num2; } public double add(double num1,double num2,double num3){ return num1+num2+num3; } public static void main(String[] args) { // TODO Auto-generated method stub NumSum nc=new NumSum(); NumSum nc1=new NumSum(); //调用2个整数相加的方法 //Scanner是用键盘手动输入数字。 System.out.println("请用键盘手动输入两个整数："); System.out.println(nc.add(new Scanner(System.in) .nextInt(),new Scanner(System.in).nextInt())); //调用3个浮点数相加的方法 System.out.println("请用键盘手动输入三个浮点数："); System.out.println(nc1.add(new Scanner(System .in).nextDouble(), new Scanner(System.in).nextDouble( ), new Scanner(System.in).nextDouble())); } } 从C到O b j e c t i v e C类 和对象续 集团文件发布号：（9816-UATWW-MWUB-WUNN-INNUL-DQQTY- 从 C++ 到 Objective-C（4）：类和对象（续） 作者:日期: 2011 年 03 月 19 日(9) 方法 Objective-C 中的方法与 C++ 的函数在语法方面风格迥异。下面，我们就来讲述 Objective-C 的方法。 原型、调用、实例方法和类方法 以–开头的是实例方法（多数情况下都应该是实例方法）； 以 + 开头的是类方法（相当于 C++ 里面的 static 函数）。 Objective-C 的方法都是 public 的； 返回值和参数的类型都需要用小括号括起来； 参数之间使用冒号：分隔； 参数可以与一个标签 label 关联起来，所谓标签，就是在 : 之前的一个名字。标签被认为是方法名字的一部分。这使得方法 比函数更易读。事实上，我们应该始终使用标签。注意，第一个 参数没有标签，通常它的标签就是指的方法名； 方法名可以与属性名相同，这使 getter 方法变得很简单。 C++ // 原型 void Array::insertObject(void*anObject, unsigned int atIndex); // shelf 是 Array 类的一个实例，book 是一个对象 shelf.insertObject(book, 2); Objective-C（不带 label，即直接从 C++ 翻译来） // 方法原型 // 方法名字是“insertObject::” // 这里的冒号:用来分隔参数，成为方法名的一部分（注意，这不同于C++ 的域指示符::） -(void) insertObject:(id)anObject:(unsigned int)index // shelf 是 Array 类的一个实例，book 是一个对象 [shelf insertObject:book:2]; Objective-C（带有 label） // 方法原型。“index” 有一个标签“atIndex” // 方法名为“insertObject:atIndex:” // 这样的话，调用语句就很容易阅读了 -(void) insertObject:(id)anObject atIndex:(unsigned int)index // shelf 是 Array 类的一个实例，book 是一个对象 [shelf insertObject:book:2]; // 错误！ [shelf insertObject:book atIndex:2]; // 正确 注意，方括号语法不应该读作“调用 shelf 对象的 insertObject 方法”，而应该是“向 shelf 对象发送一个 insertObject 消息”。这是Objective-C 的实现方式。你可以向任何对象发送任何消息。如果目标对象不能处理这个消息，它就会将消息忽略（这会引发一个异常，但不 实验一类和对象 实验课程名：面向对象程序设计（C++） 专业班级：学号：姓名： 实验时间：实验地点：指导教师： 一、实验目的和要求 (1) 理解类和对象的概念，掌握声明类和定义对象的方法。 (2) 掌握构造函数和析构函数的实现方法。 (3) 初步掌握使用类和对象编制C++程序。 (4) 掌握对象数组、对象指针和string类的使用方法。 (5) 掌握使用对象、对象指针和对象引用作为函数参数的方法。 (6) 掌握类对象作为成员的使用方法。 (7) 掌握静态数据成员和静态成员函数的使用方法。 (8) 理解友元的概念和掌握友元的使用方法。 二、实验内容 1．设计一个静态数组存储结构的顺序表类，要 求编程实现如下任务：建立一个线性表，首先 依次输人数据元素1，2，3，…，10，然后删除 数据元素6，最后依次显示当前线性表中的数 据元素。要求采用顺序表实现，假设该顺序表 的数据元素个数在最坏情况下不会超过50个。实验代码：#include SeqList( ) {length=0;} //无参构造函数 SeqList(T a[ ], int n); //有参构造函数 ~SeqList( ) { } //析构函数为空 int Length( ) {return length;} //求线性表的长度 T Get(int i); //按位查找，取线性表的第i个元素 int Locate(T x ); //按值查找，求线性表中值为x的元素序号 void Insert(int i, T x); //在线性表中第i个位置插入值为x的元素 T Delete(int i); //删除线性表的第i个元素 void PrintList( ); //遍历线性表，按序号依次输出各元素 private: T data[MaxSize]; //存放数据元素的数组 int length; //线性表的长度 }; template c类和对象练习题 Standardization of sany group #QS8QHH-HHGX8Q8-GNHHJ8-HHMHGN# 第8章类与对象 8．1知识要点 1．掌握类与对象的概念和定义方法，掌握类成员的访问属性。 2．掌握构造函数的概念、定义方法和使用方法。 3．掌握析构函数的概念、定义方法和使用方法。 4．掌握拷贝构造函数的概念、定义方法和使用方法。 5．掌握包含对象成员的类构造函数的定义方法。 6．掌握静态成员的概念、定义方法、作用和特点。 7．掌握友元的概念、定义方法、作用和特点。 8．掌握类模板的定义格式与使用方法。 8．2典型例题分析与解答 例题1：下列有关类的说法不正确的是（）。 A．对象是类的一个实例 B．任何一个对象只能属于一个具体的类 C．一个类只能有一个对象 D．类与对象的关系和数据类型与变量的关系相似 答案：C 分析：对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。 例题2：下面（）项是对构造函数和析构函数的正确定义。 A．void X::X(), void X::~X() B．X::X(参数),X::~X() C．X::X(参数),X::~X(参数) D．void X::X(参数),void X::~X(参数) 答案：B 分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、不可重载。 例题3：（）的功能是对象进行初始化。 A．析构函数B. 数据成员 C.构造函数 D.静态成员函数 答案：C 分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作； 例题4：下列表达方式正确的是（）。 A．class P{B．class P{ public： public： int x=15； int x； voidshow(){cout< 类与对象 知识要点 1．掌握类与对象的概念和定义方法，掌握类成员的访问属性。 2．掌握构造函数的概念、定义方法和使用方法。 3．掌握析构函数的概念、定义方法和使用方法。 4．掌握拷贝构造函数的概念、定义方法和使用方法。 5．掌握包含对象成员的类构造函数的定义方法。 6．掌握静态成员的概念、定义方法、作用和特点。 7．掌握友元的概念、定义方法、作用和特点。 8．掌握类模板的定义格式与使用方法。 典型例题分析与解答 例题1：下列有关类的说法不正确的是（）。 A．对象是类的一个实例 B．任何一个对象只能属于一个具体的类 C．一个类只能有一个对象 D．类与对象的关系和数据类型与变量的关系相似 答案：C 分析：对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。 例题2：下面（）项是对构造函数和析构函数的正确定义。 A．void X::X(), void X::~X() B．X::X(参数), X::~X() C．X::X(参数), X::~X(参数) D．void X::X(参数), void X::~X(参数) 答案：B 分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、不可重载。 例题3：（）的功能是对象进行初始化。 A．析构函数 B. 数据成员 C.构造函数 D.静态成员函数 答案：C 分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作； 例题4：下列表达方式正确的是（）。 A．class P{ B． class P{ public： public： int x=15； int x； void show(){cout< 实验名称：类与对象 一．实验目的： （1）理解C#语言是如何体现面向对象编程基本思想； （2）掌握类对象的定义； （3）了解类的封装方法，以及如何创建类和对象； （4）了解成员变量和成员方法的特性； （5）掌握静态成员的用法； （6）掌握构造函数和析构函数的含义与作用、定义方式和实现，能够根据要求正确定义和重载构造函数。能够根据给定的要求定义类并实现类的成员函数； （7）掌握参数传递的用法； （8）掌握属性的作用和使用。 二．上机内容： 1）创建MyDataTime类，熟悉构造函数、析构函数的定义方法、属性的定义方法以及一般方法的定义过程。 （2）创建Fraction类，掌握运算符重载、静态方法的使用及其与实例方法的区别。（3）创建Swap类，掌握C#方法中参数的传递。 （4）整理上机步骤，总结经验和体会。 （4）完成实验报告。 四．上机步骤： 类的创建与应用： 创建一个MyDataTime类，要求如下： （1）私有字段：year，month，day； （2）属性：Year，Month，Day。注意在定义Month和Day的settor时要检验设置值的有效性，其中，，同时在对Day进行设置的时候要注意闰年和平 年的2月的天数。 （3）方法：构造函数：根据需求确定不同参数列表的构造方法。 析构函数：提示析构对象。 PrintMyDataTime：以“2011/4/24”、“2011年4月24日”、“2011.4.24”、“二〇一一年四月二十四日”的形式输出Year，Month和Day。 using System; using ; namespace ConsoleApplication1 { class MyDataTime { private int year; public int Year { set { year = value; } get { return year; } 实验三类与对象 一、实验目的 1、掌握类和构造方法的定义 2、理解静态和非静态成员变量的区别 3、掌握创建类实例的方法 4、理解Java中包的概念及其使用方法 二、实验要求 1.写一个名为Rectangle的类表示矩形。其属性包括宽width、高height和颜色color，width 和height都是double型的，而color则是String类型的。要求该类具有： (1)使用构造函数完成各属性的初始赋值 (2)使用getter和setter的形式完成属性的访问及修改 提供计算面积的getArea()方法 public class mianji { private double height; private double width; private String color; public double getHeight() { return height; } public void setHeight(double height) { this.height = height; } public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public mianji(double width,double height,String color){ this.setColor(color); this.setHeight(height); this.setWidth(width); } public void getArea(){ double area=0; area=this.height*this.width; System.out.println("矩形的面积为"+area); } public String toString(){ String recStr="矩形的高度："+this.getHeight() +"宽度："+this.getWidth() +"颜色:"+this.getColor(); return recStr; } public static void main(String[] args) { mianji rec=new mianji(3, 4, "红色"); rec.getArea(); System.out.println(rec.toString());}C语言的类和对象
C++实验报告 第四章 类与对象
实验3 类和对象
类和对象练习题
C++实验九类和对象的使用实验报告
JAVA类与对象及数组习题及答案
C++类和对象实验报告
实验报告_实验3 类与对象
C上机实验报告实验四
实验一.类与对象实验报告
JAVA类与对象的创建
Java实例对象概念图解
java类和对象的例子
从C到ObjectiveC类和对象续修订稿
c++类和对象实验报告
c类和对象练习题
类与对象答案
实验报告4类与对象
实验3 Java类与对象
相关主题
文本预览