一、选择题
1定义类头时，不可能用到的关键字是()。
A) class B)private C)extends D)public
2.下列类定义中，不正确的是()。
A) class x { .... }
B) class x extends y { .... }
C) static class x implements y1,y2 { .... }
D) public class x extends Applet { .... }
3.下列类头定义中，错误的是()。
A)public x extends y {...}
B) public class x extends y {...}
C)class x extends y implements y1 {...}
D)class x {...}
4.设A为已定义的类名，下列声明A类的对象a的语句中正确的是( )。
A) float A a; B) public A a=A( );
C) A a=new int( ); D) static A a=new A( );
5.设A为已定义的类名，下列声明A类的对象a的语句中正确的是()。
A) public A a=new A( ); B) public A a=A( );
C) A a=new class( ); D) a A;
6.设X 、Y均为已定义的类名，下列声明类X的对象x1的语句中正确的是()。
A) public X x1= new Y( ); B) X x1= X ( );
C) X x1=new X( ); D) int X x1;
7.设X 、Y为已定义的类名，下列声明X类的对象x1的语句中正确的是()。
A) static X x1; B) public X x1=new X(int 123);
C) Y x1; D) X x1= X( );
8.通过类MyClass中的不含参数的构造方法，生成该类的一个对象obj，可通过以下语句实现：_______________________________。
9. 设i , j为类X中定义的int型变量名，下列X类的构造方法中不正确的是( )。
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; }
10. 有一个类A，以下为其构造方法的声明，其中正确的是( )。
A)public A(int x){...} B)static A(int x){...}
C)public a(int x){...} D)void A(int x){...}
11.有一个类A，以下为其构造方法的声明，其中正确的是( )。
A)void A(int x){...} B)A(int x){...}
C)a(int x){...} D)void a(int x){...}
12.设i、j、k为类X中定义的int型变量名，下列类X的构造方法中不正确的是( )。
A) X( int m){ ... } B) void X( int m){ ... }
C) X( int m, int n){ ... } D) X( int h,int m,int n){ ... }
13. 设i , j为类X中定义的double型变量名，下列X类的构造方法中不正确的是( )。
A) double X(double k ){ i=k; return i; } C) X( ){i=6;j=8; }
B) X(double m, double n ){ i=m; j=n; } D) X(double k ){ i=k; }
二、填空题
1.下面是一个类的定义，请完成程序填空。
public class ____________
{
int x, y;
Myclass ( int i, _______) // 构造方法
{
x=i; y=j;
}
}
14. 下面是一个类的定义，请将其补充完整。
class _____
{
String name;
int age;
Student( _____ s, int i)
{
name=s;
age=i;
}
}
2.下面是一个类的定义，请将其补充完整。
class ____________ // 定义名为myclass的类
{
__________ int var=666;
static int getvar()
{ return var; }
}
3.下面程序的功能是通过调用方法max（）求给定的三个数的最大值，请将其补充完整。
public class Class1
{
public static void main( String args[] )
{
int i1=1234,i2=456,i3=-987;
int MaxValue;
MaxValue=____________;
System.out.println("三个数的最大值："+MaxValue);
}
public ______ int max(int x,int y,int z)
{ int temp1,max_value;
temp1=x>y?x:y;
max_value=temp1>z?temp1:z;
return max_value;
}
}
4.下面是一个类的定义，请将其补充完整。
___________ A
{ String s;
_____ int a=666;
A(String s1) { s=s1; }
static int geta( ) { return a; }
}
三、程序阅读题
1.下面是一个类的定义,根据题目要求回答以下问题.
class B
{
private int x;
private char y;
public B(int i,char j)
{
x=i; y=j;
}
public void show()
{
System.out.println("x="+x+"; y="+y);
}
public void methodC(int x)
{
this.x=this.x+x;
y++;
show();
}
}
(1)定义类B的一个对象b，将类中的变量x初始化为10、变量y初始化为’A’，请写出相应的语句。
(2)若在(1)问基础上有方法调用语句：
b.show();
则输出如何？
(3)若在(1)问基础上增加语句: b.methodC(1); 则输出为何？
2.阅读程序，回答问题。
public class Test52
{
static String str1="Hello, Java world! \t";
static String str2="Hello, students! ";
public static void main(String args[])
{ System.out.print(str1); System.out.println(str2); } }
问题：1)这是哪种形式的java 程序？
2)程序的输出是什么？
3. 写出下列程序的输出结果
public class Test
{
public static void main(String[] args)
{
Count myCount = new Count();
int times = 0;
for(int i=0;i<100;i++)
increment(myCount , times);
System.out.println(“count is” + myCount.count);
System.out.println(“time is”+ times);
}
public static void increment(Count c , int times)
{
c.count++;
times++;
}
}
class Count
{
public int count;
Count(int c)
{
count =c;
}
Count()
{
count =1;
}
}
4.写出下列程序的输出结果：
public class Test
{
public static void main(String[] args)
{
Cirecle circle1 = new Circle(1);
Cirecle circle2 = new Circle(2);
// Attempt to swap circle 1 with circle2
System.out.println(“Before swap:circle1 = ”+circle1.radius
+”circle2 = ”+circle2.radius);
swap(circle1,circle2);
System.out.println(“After swap: circle1 = ”+circle1.radius
+”circle2 = ”+circle2.radius);
}
public static void swap(Circle x , Circle y)
{
System.out.println(“Before swap: x = ”+x.radius
+”y = ”+y.r adius);
Circle temp = x;
x = y;
y = temp;
System.out.println(“Before swap: x = ”+x.radius
+”y = ”+y.radius);
}
}
答案：
5.阅读下面程序，回答问题：
public class Foo
{
int i;
static String s;
void imethod()
{
}
static void smethod()
{
}
}
设f是Foo的一个实例，下列语句正确吗？
System.out.println(f.i);
System.out.println(f.s);
f.imethod();
f.smethod();
System.out.println(Foo.i);
System.out.println(Foo.s);
Foo.imethod();
Foo.smethod();
6.下列程序的输出结果是什么？
public class Foo
{
static int i=0;
static int j=0;
public static void main(String[] args)
{
int i=2;
int k=3;
{
int j=3;
System.out.println(“i + j is ”+ i + j);
}
k = i +j;
System.out.println(“k is ”+k);
System.out.println(“j is ”+ j);
}
}
答案：
7. 根据下面的程序，指出下面每个元素的作用域（类作用域或块作用域）
a)变量x
b)变量y
c)方法cude
d)变量i
e)变量yPos
public class CubeTest
{
int x;
public void print()
{
int yPos = 10;
for(x=1;x<=10;x++)
{
System.out.println(cude(x));
for(int i=1;i<=yPos;i++)
System.out.println(" ");
}
}
public int cude (int y)
{
return y*y*y;
}
}
答案：
四、简答题
1. 面向对象的软件开发方法用什么把数据和基于数据的操作封装在一起？（
2. 在一个类定义中，用什么描述对象的状态? 用什么描述对象的行为?
3. 什么方法是一个特殊的方法，用于对对象进行初始化？
4.一个源程序文件中，能有多于一个的public 类吗?
5. 构造方法的方法名可由编程人员任意命名吗?
6.类的构造方法名必须和类名相同吗？
7.构造函数有返回值吗?
8. 构造函数可以重载吗？
9. 如果一个类定义中没有定义构造方法，该类有构造函数吗？
10. 如果一个类定义中已经定义了构造方法，java还会给它定义缺省的构造方法吗？
11. 类的访问控制权有哪两种？
12. 用什么修饰符修饰的方法称为静态方法? 用什么修饰符修饰的属性称为静态属性?
13.静态属性和静态方法仅属于类的一个具体对象吗？它属于谁？
14. static 变量能是private 变量吗？
15. 使用静态成员都能以什么做前缀？
16. static方法中能有this引用吗？
17. 非static方法中可以有this引用吗？
18．static方法能处理非static成员吗？
19．非static方法能处理static成员吗？
五、编程题
1、//基本类定义
编写一个类，描述学生的学号、姓名、成绩。学号用整型，成绩用浮点型,姓名用String类型。
编写一个测试类，测试学生类。
class Student{
int sNum;
double score;
String name;
}
public class T1_Student{
public static void main(String[] args){
Student s=new Student();
s.sNum=101;
s.score=97;
https://www.doczj.com/doc/1518529411.html,="张三";
System.out.println(https://www.doczj.com/doc/1518529411.html,+"的学号是"+s.sNum+"成绩是"+s.score);
}
}
2、//基本类定义
将上述类进行改写，学生拥有判断自己的成绩是否及格的功能。并能够打印输出自己的姓名和是否及格的信息（方法名：printInfo（））
编写一个测试类，对学生类进行测试。
class Student{
int sNum;
double score;
String name;
void printInfo(){
if(score>=60){
System.out.println("我的姓名是"+name+"我的成绩为及格");
}
else{
System.out.println("我的姓名是"+name+"我的成绩为不及格");
}
}
}
public class T1_Student{
public static void main(String[] args){
Student s=new Student();
s.sNum=101;
s.score=97;
https://www.doczj.com/doc/1518529411.html,="张三";
System.out.println(https://www.doczj.com/doc/1518529411.html,+"的学号是"+s.sNum+"成绩是"+s.score);
s.printInfo();
}
}
3．//构造方法：
设计一个关于三角形的类Trival，其中的属性包括三角形的底di，三角形的高gao，方法包括：默认构造方法、为di和gao指定初值的构造方法、获取三角形面积findArea()。
class Trival
{
double di;
double gao;
Trival()
{
di=1.0;
gao=2.0;
}
Trival(double i,double j)
{
di=i;
gao=j;
}
double findArea()
{
return di*gao/2;
}
}
4、//构造方法：
编写一个类，描述桌子，包括以下几种属性：长、宽、高、颜色。并且使该类具有这样的功能：在定制桌子（即创建桌子对象时），就可以同时指定桌子的长宽高来订制。也可以同时指定长、宽、高、颜色来订制，也可单独指定桌子颜色来订制。
并编写一个测试类测试这几种定制方法。
public class T2_Desk{
public static void main(String[] args){
Desk d1=new Desk(2,1.5,0.6);
System.out.println("第一个桌子的长宽高分别为："+d1.length+" "+d1.width+" "+d1.height);
Desk d2=new Desk(1,0.6,0.3,"red");
System.out.println("第二个桌子的长宽高和颜色分别为："+d2.length+" "+d2.width+" "+d2.height+" "+d2.color);
Desk d3=new Desk("green");
System.out.println("第三个桌子的颜色是"+d3.color+"色");
}
}
class Desk{
double length;
double width;
double height;
String color;
Desk(double l,double w,double h){
length=l;
width=w;
height=h;
}
Desk(double l,double w,double h,String c){
length=l;
width=w;
height=h;
color=c;
}
Desk(String c){
color=c;
}
}
5、//访问器方法：
编写一个类，描述银行账户，包括收入、支出和账户余额三种属性，同时包括对这三种属性的读、写的访问器方法，这三种属性都定义为私有的。
该类定义的银行账户还能够通过自己的收入和支出自动计算账户余额。对于账户余额只能读取，自动计算，但不能够直接赋值，也就是不能够写。
编写一个测试类，输入收入和支出项，打印账户余额。
public class T4_Bank{
public static void main(String[] args){
Bank b=new Bank();
b.setIncome(30);
b.setOutcome(10);
System.out.println(b.getAll());
}
}
class Bank{
private double income;
private double outcome;
private double all;
public void setIncome(double i){
income=i;
}
public double getIncome(){
return income;
}
public void setOutcome(double o){
outcome=o;
}
public double getOutcome(){
return outcome;
}
public double compute(){
all=income-outcome;
return all;
}
public double getAll(){
return compute();
}
}
6. //访问器方法：
下面是Name类、Person类和Test类，请将Name类和Person类中所有private数据域的访问器方法填写完整。
class Name
{
private String firstName;//姓
private String lastName;//名
Name(String f,String l)
{
firstName=f;
lastName=l;
}
//填写访问器方法
public String toString()
{
return firstName + lastName;
}
}
class Person
{
private Name name;//姓名
Person(Name n)
{
name=n;
}
//填写访问器方法
}
class Test
{
public static void main(String[] args)
{
Name theName=new Name("张","三");
Person p=new Person(theName);
System.out.println(p.getName());//输出结果：张三
}
}
class Name
{
private String firstName;//姓
private String lastName;//名
Name(String f,String l)
{
firstName=f;
lastName=l;
}
public String getFirstName()
{
return firstName;
}
public void setFirstName(String fn)
{
firstName=fn;
}
public String getLastName()
{
return lastName;
}
public void setLastName(String ln)
{
lastName=ln;
}
public String toString()
{
return firstName + lastName;
}
}
class Person
{
private Name name;//姓名
Person(Name n)
{
name=n;
}
public Name getName()
{
return name;
}
public void setName(Name n)
{
name=n;
}
}
class Test
{
public static void main(String[] args)
{
Name theName=new Name("张","三");
Person p=new Person(theName);
System.out.println(p.getName());//输出结果：张三
}
}
7. //类的定义
编写一个类实现复数的运算：
复数类ComplexNumber 的属性：
m_dRealPart ：实部，代表复数的实数部分；
m_dMaginPart ：虚部，代表复数的虚数部分；
复数类ComplexNumber 的方法：
ComplexNumber(double r , double i ) ：构造方法，创建复数对象的同时完成复数的实部、虚部的初始化，r为实部的初值，i为虚部的初值；
getRealPart() ：获得复数对象的实部；
getImaginPart() ：获得复数对象的虚部；
setRealPart(double d ) ：把当前复数对象的实部设置为给定的形式参数的数字；
setImaginaryPart ( double d ) ：把当前复数对象的虚部设置为给定的形式参数的数字；
complexAdd(ComplexNumber c) ：当前复数对象与形式参数复数对象相加，所得的结果也是复数值，返回给此方法的调用者；
complexMinus(ComplexNumber c) ：当前复数对象与形式参数复数对象相减，所得的结果也是复数值，返回给此方法的调用者；
complexMulti(ComplexNumber c) ：当前复数对象与形式参数复数对象相乘，所得的结果也是复数值，返回给此方法的调用者；
编程实现这个类，并验证所编写的类能否正常使用。
class ComplexNumber
{
double m_dRealPart;
double m_dImaginPart;
public ComplexNumber(double r, double i)
{
m_dRealPart = r;
m_dImaginPart = i;
}
public double getRealPart()
{
return m_dRealPart;
}
public double getImaginaryPart()
return m_dImaginPart;
}
public void setRealPart(double d)
{
m_dRealPart = d;
}
public void setImaginaryPart(double d)
{
m_dImaginPart = d;
}
public ComplexNumber complexAdd(ComplexNumber c)
{
return (new ComplexNumber(this.m_dRealPart+c.m_dRealPart,
this.m_dImaginPart+c.m_dImaginPart));
}
public ComplexNumber complexMinus(ComplexNumber c)
{
return (new ComplexNumber(this.m_dRealPart-c.m_dRealPart,
this.m_dImaginPart-c.m_dImaginPart));
}
public ComplexNumber complexMulti(ComplexNumber c)
{
return (new ComplexNumber(
this.m_dRealPart*c.m_dRealPart - this.m_dImaginPart*c.m_dImaginPart,
this.m_dRealPart*c.m_dImaginPart + this.m_dImaginPart*c.m_dRealPart));
}
}
public class TestComplexNumber
{
public static void main(String args[])
{
ComplexNumber cn1 = new ComplexNumber(2,4);
ComplexNumber cn2 = new ComplexNumber(1,-1);
ComplexNumber cn3;
cn3 = https://www.doczj.com/doc/1518529411.html,plexMulti(cn2);
System.out.println(cn1.getRealPart()+"+"+cn1.getImaginPart+"i");
System.out.println(cn2.getRealPart()+"+"+cn2.getImaginPart+"i");
System.out.println(cn3.getRealPart()+"+"+cn3.getImaginPart+"i");
}
8. //类的定义
写一个名为Rectangle的类表示矩形。属性为宽width、高height和颜色color，widthhe height 是double型的，color是String型的。假定所有矩形颜色相同，用一个类变量（类属性）表示颜色。要求提供访问器方法和计算矩形面积的findArea()方法。
写一个用户程序测试Rectangle类：创建两个Rectangle对象。给两个对象设置任意的宽和高。设矩形颜色为黄色。显示两个对象的属性并求面积。
答案：
public class Rectangle
{
private double width = 1;
private double height = 1;
private static String color = “white”;
public Rectangle()
{
}
public Rectangle(double width, double height , String color)
{
this.width = width;
this.height = height;
this.color = color;
}
public double getWidth()
{
return width;
}
public void setWidth(double width)
{
this.width = width;
}
public double getHeight()
{
return height;
}
public void setHeight(double height)
{
this. height = height;
}
public static String getColor()
{
return color;
}
public static void setColor(String color)
this.color = color;
}
public double findArea()
{
return width*height;
}
public static void main(String[] args)
{
Rectangle r1 = new Rectangle();
Rectangle r2 = new Rectangle();
r1.setWidth(2.0);
r1.setHeight(3.0);
r1.setColor(“红色”);
r2.setWidth(5.0);
r2.setHeight(4.0);
r2.setColor(“黄色”);
System.out.println(r1.getWidth());
System.out.println(r1.getHeight());
System.out.println(r1.getColor());
System.out.println(r1.findArea());
System.out.println(r2.getWidth());
System.out.println(r2.getHeight());
System.out.println(r2.getColor());
System.out.println(r2.findArea());
}
}
9、//static修饰符
设计一个学生类，其中成员变量应包括：学号，姓名，性别，班级，并提供方法打印学生信息，和计算已经创建学生对象的数目。编写一个程序测试这个类。
public class Student
{
private long id;
private String name;
private char sex;
private String banji;
private static int count=0;
public Student(long id,String name,char sex,String banji)
{
this.id=id;
https://www.doczj.com/doc/1518529411.html,=name;
this.sex=sex;
this.banji=banji;
count++;
}
public void print()
{
System.out.println(“该生信息如下：”);
System.out.println(“学号:”+id+” 姓名：”+name+” 性别:”+sex+” 班级:”+banji);
}
public static void count()
{
System.out.println(“已经创建的学生个数为:”+count);
}
public static void main(String[] args)
{
Student a=new Student(01,“zhangsan”,’男’,”计专01班”);
a.print();
Student.count();
Student b=new Student(03,”刘倩”,’女’,”计专03班”);
b.print();
Student.count();
}
}
10、//static修饰符
编写一个类Teacher，描述教师的课时数量和计算课时的系数，均为double类型。Teacher 类还有一个方法，courseCompute()，可计算教师的当量课时(课时量*系数)，返回值类型为double，所有教师的课时系数相同。
编写一个测试类进行测试。
创建两个教师对象，计算的系数为1.2，输出计算后的两位老师的当量课时。
将系数修改后，输出修改后的当量课时。
public class Test{
public static void main(String[] args){
Teacher t1=new Teacher(96);
Teacher t2=new Teacher(64);
Teacher.classXishu=1.2;
double realCourseNum=t1.courseCompute();
System.out.println("第一位老师的实际课时数为："+realCourseNum);
realCourseNum=t2.courseCompute();
System.out.println("第一位老师的实际课时数为："+realCourseNum);
Teacher.classXishu=1.5;
realCourseNum=t1.courseCompute();
System.out.println("更改系数后，第一位老师的实际课时数为："+realCourseNum);
realCourseNum=t2.courseCompute();
System.out.println("更改系数后，第一位老师的实际课时数为："+realCourseNum);
}
}
class Teacher{
public Teacher(int courseNum){
this.courseNum=courseNum;
}
int courseNum;
static double classXishu;
double courseCompute(){
return courseNum*classXishu;
}
}
11、设计一个描述二维平面上点的类Position，该类需要描述点的横坐标和纵坐标，并提供访问器方法（set方法和get方法）和计算两点间距离的方法。写一个程序测试这个类class Position
{
private int x = 0;
private int y = 0;
public Position()
{
}
public Position (int x,int y)
{
this.x = x;
this.y = y;
}
public void setX(int x)
{
this.x = x;
}
public int getX()
{
return x;
}
public void setY(int y)
{
this.y = y;
}
public int getY()
{
return y;
}
public double distance(Positon p)
{
int d1 = x - p.getX();
int d2 = y - p.getY();
return Math.sqrt(d1*d1+d2*d2);
}
}
class Test
{
public static void main(String[] args)
{
Position p1 = new Position ();
Position p2 = new Position(3,5);
System.out.println(p1.distance(p2));
}
}
Java iSW程序设il?（郑莉） 第二章习题答案 1.什么是对象、类，它们之间的联系 答：1）对象是包含现实世界物体特征的捕象实体，它反映系统为之保存信息和与它交互的能力。对象是一些属性及服务的封装体，在程序设计领域，可以用“对象二数据+作用于这些数据上的操作”来表示。现实生活中对象是指客观世界的实体：在程序中对象是指一组变量和相关方法的集合。 2）类是既有相同操作功能和相同的数据格式的对象的集合与抽象！ 3）两者的关系：对象是类的具体实例 2.什么是而向对象的程序设计方法它有那些基本特征 答:而向对象程序设计从所处理的数据入手，以数抵为中心而不是以服务为中心来描述系统。 它把编程问题视为一个数据集合，数据相对于功能而言，具有更强的稳世性。 它的特征：抽象，封装，继承，多态。 3.在下而的应用中，找出可能用到的对象，对毎一个对象，列出可能的状态和行为。 1）模拟航空预订系统交易的程序 2）模拟银行交易的程序 答：1）航空预订交易： 状态：旅客姓名，身份证号，联系号码，出发地址，抵达地址，出发日期。 行为：订票，领票，买票，退票。 2）银行交易： 状态：客户姓名，账号，身份证号。 行为：存款，取款，『款。 4.请解释类属性、实例属性及其区别。 答：实例属性，由一个个的实例用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。 5.请解释类方法、实例属性及其区别。 答：实例方法表示特定对象的行为，在声明时前而不加static修饰符，在使用时需要发送给一个类实例。 类方法也称为静态方法，在方法声明时前而需加static修饰符，类方法表示具体实例中类对象的共有行为。 区别：实例方法可以宜接访问实例变量，调用实例方法，实例方法可以直接访问类变量, 调用类方法：类方法可以直接调用类变量和类方法，类方法不能直接调用实例变量和实例方法： 6.类的访问控制符有哪几种具体含义及其区别。 答：类的访问控制符只有public （公共类）及无修饰符（默认类）两种。 区別：当使用public修饰符时表示所有其他的类都可以使用此类；当没有修饰符时，则只有与
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
宁夏师范学院数学与计算机科学学院《面向对象程序设计（C++）》实验报告
}*/ // ~CPU() {cout<<"析构了一个CPU!"< 一、选择题 1定义类头时，不可能用到的关键字是()。 A) class B)private C)extends D)public 2.下列类定义中，不正确的是()。 A) class x { .... } B) class x extends y { .... } C) static class x implements y1,y2 { .... } D) public class x extends Applet { .... } 3.下列类头定义中，错误的是()。 A)public x extends y {...} B) public class x extends y {...} C)class x extends y implements y1 {...} D)class x {...} 4.设A为已定义的类名，下列声明A类的对象a的语句中正确的是( )。 A) float A a; B) public A a=A( ); C) A a=new int( ); D) static A a=new A( ); 5.设A为已定义的类名，下列声明A类的对象a的语句中正确的是()。 A) public A a=new A( ); B) public A a=A( ); C) A a=new class( ); D) a A; 6.设X 、Y均为已定义的类名，下列声明类X的对象x1的语句中正确的是()。 A) public X x1= new Y( ); B) X x1= X ( ); C) X x1=new X( ); D) int X x1; 7.设X 、Y为已定义的类名，下列声明X类的对象x1的语句中正确的是()。 A) static X x1; B) public X x1=new X(int 123); C) Y x1; D) X x1= X( ); 8.通过类MyClass中的不含参数的构造方法，生成该类的一个对象obj，可通过以下语句实现：_______________________________。 9. 设i , j为类X中定义的int型变量名，下列X类的构造方法中不正确的是( )。 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; } 10. 有一个类A，以下为其构造方法的声明，其中正确的是( )。 A)public A(int x){...} B)static A(int x){...} C)public a(int x){...} D)void A(int x){...} 11.有一个类A，以下为其构造方法的声明，其中正确的是( )。 A)void A(int x){...} B)A(int x){...} C)a(int x){...} D)void a(int x){...} 12.设i、j、k为类X中定义的int型变量名，下列类X的构造方法中不正确的是( )。 A) X( int m){ ... } B) void X( int m){ ... } C) X( int m, int n){ ... } D) X( int h,int m,int n){ ... } 13. 设i , j为类X中定义的double型变量名，下列X类的构造方法中不正确的是( )。 A) double X(double k ){ i=k; return i; } C) X( ){i=6;j=8; } B) X(double m, double n ){ i=m; j=n; } D) X(double k ){ i=k; } oop概述 特别值得注意的是，以各地相继不能直接访问另一个兑现呢不得数据，也不能让其他对象直接访问自己内部的数据。对象之间的所有通信都是通过方法调用完成的。通过封装对象数据，最大限度提高可重用性，将少数据的依赖，必将程序调试时间降到最低。 类是构造对象的模板和蓝图，由类构造对象的过程成为类的实例。 封装给与对象黑盒的特征，这是提高重用性和可靠性的关键。 oop首先从设计类开始而不是从main方法开始 依赖user-a：如果一个类的方法操作另一个类的对象，我们就说这个类依赖于另一个类。 应该尽可能的将互相依赖的类减至最少。如果累A不知道类B的存在，那么他就不会关心类B的任何改变！（这意味着类B的改变不会使类A产生任何bug）。用软件工程术语来说，就是使类之间的耦合度最小！ 聚合has-a：聚合关系意味着类A的对象包含类B的对象 继承is-a 用UML绘制描述类之间关系的类图。类用矩形表示。类之间的关系带有各种箭头表示。 Date类 他的对象描述一个时间点 一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。 在java中必须使用clone方法获得对象的完整拷贝。 java苦衷的GregorianCalendar类（日历表示法）扩展类Calendar类这个类描述了日立的一般属性 java.util.GregorianCalendar GregorianCalendar()构造一个日历对象，用来表示默认地区、默认时区的当前时间。 自己编写类 这里编写类所采用的风格是类的方法在前面，域在后面。这种风格有利于促使人们更加关注接口的概念，并且削减对现实的注意。 隐式参数和显示参数 this是隐式参数 方法括号中的参数为显示参数 对数据的操作要用get取用set变 注意get方法中不能写返回一个对象的引用，要先克隆再返回这样才没有回话封装性 静态域 1.UML如何表示类?类图标中可以指明哪些信息? 类是描述一类对象的特征和行为，类图包含一组、接口及他们之间的关联、依赖和泛化的关系。它不仅显示了信息的结构，同时还描述了系统对象的的行为。 2.什么是类的多重性(关联的基数)?多重性怎么表示? 多重性是对象之间关联的一个重要方面，它说明了在关联中的一个类的对象可以对应另一个类的多个对象。 主要包含一组上下限数，用来指出可被允许生成的实例（instance）数量，即最多可以生成多少数目（上限），最少不得低于多少数目（下限）。关联的两端以"下限..上限"的格式标示出多重性，如图2-12中的1..*。星号（*）代表无指定上限，下限最低为0。如果上下限数相同，标示出一个数目就可以了 3.两者对象之间能够以多种方式关联吗？ 关联两边的"employee"和“employer”标示了两者之间的关系，而数字表示两者的关系的限制，是关联两者之间的多重性。通常有“*”（表示所有，不限），“1”（表示有且仅有一个），“0...”（表示0个或者多个），“0，1”（表示0个或者一个），“n...m”(表示n到m个都可以),“m...*”（表示至少m个）。在关联中有一种叫“限定关联”，还有一种谓之自身关联。另外，对象之间的关联就没那么复杂，只是将类的关联实例化而已 4.什么是约束？为什么要对类图附加注释？ 约束用来约束MUL成员的语义。约束用举例在大括号内的条件来表示（｛contrraint｝），可以直接放在图中，类图除了在设计新系统方面的用途外，它们还能用来记录一个存在系统（称它为“遗产”）的对象现在如何交互 5.聚集和组成之间有什么区别？ 聚合关系完全是概念上的，只是区分了整体与组成部分，没有改变整体与其组成部分之间的关联导航的含义，也没有将整体与部分的生命周期联系起来。而组合是聚合的变种，整体与部分之间有很强的所有关系，也就是说，在组合关系中，一个对象一次只是一个组合的一部分，而在简单的聚合关系中，一个部分可以被好几个整体共享。 另外，在组合关系中，整体负责部分的创建和破坏，部分的生命周期是依附于整体的，要么和整体一起创建和破坏，要么在整体存在后创建或在整体破坏前破坏，总之它不能单独存在。 6.什么叫实现?实现和继承有何相似之处？两者又有何不同之处？ 答：实现是类和它的接口之间的关系，可以说成是类实现了它的接口。相似之处：在于类可以使用它的接口中的操作，也可以操作从父类中继承操作。不同之处：类不能使用它的接口中的属性但可以继承父类中的属性。实现是对接口而言的，继承是对类而言的。 7.写出3种可见性的名称，并描述每一种可见性的含义。 答：public，protected，private及package。 第二章概念 内容提要 一、概念的内涵和外延 概念的内涵和外延是概念的两个基本逻辑特征。 概念的内涵是概念对对象本质属性的反映；概念的外延是概念对对象本身的反映。内涵是概念的质的方面，它涉及概念反映的对象“是什么”；外延是概念的量的方面，它涉及的是概念反映的对象“有哪些”。概念内涵和外延与客观对象的本质属性和对象本身并不等同，二者是反映与被反映的关系。概念内涵和外延是人脑对对象本质“属性及对象本身认识的结果，属于主观的东西，而对象的本质属性和对象本身则是客观存在的；只有当它们被反映到人的思维中来，才会成为概念的内涵和外延。 对于某一具体概念的理解就是对于概念内涵和外延的理解。逻辑学要求我们掌握概念的外延关系，因此对概念外延的理解是非常重要的。例如：“国家”的外延应该是指古今中外一切具有“国家性质”这样的实体性的对象，从时间上看指国家产生以来直至现在；从空间上讲指“整个世界”，我们在理解“国家”外延时常犯的错误是把它的外延缩小，理解为“现代国家”。再如：“犯罪行为”这一概念的外延是触犯刑律应受刑法处罚的行为，而非指一般的违法行为，如果我们把一般的赌博行为也理解为“犯罪行为”，就是把这一概念的外延扩大了。 二、概念的种类 （一）依据不同的标准，可以将概念分成不同的种类。根据概念外延所反映的对象的数量，可把概念分为单独概念和普遍概念；根据概念反映的对象是否为集合体，可把概念分为集合概念和非集合概念；根据概念反映的对象是否具有某种属性，可把概念分为肯定概念和否定概念；根据概念反映的对象是否为独立存在的实体，可把概念分为实体概念和属性概念。 在理解概念种类的划分时，难点在集合概念和非集合概念划分标准的掌握。 （二）区别集合概念与非集合概念应注意的问题。 １．集合体和个体的关系，与类和分子间的关系是不同的。 所谓“集合体”是指概念所反映的对象是作为一个整体来认识和使用的，集合体由许多个体有机构成的，但是，集合体所具有的属性，构成该集合体的任一个体并不具有。集合概念的外延不包括构成集合体的个体。 所谓“类”是指概念所反映的对象是由具有相同属性的分子所构成的，其特点是：“类”是对于分子属性的概括和反映，因此，“类”所具有的属性，其分子必然具有。“类”的外延必然包括分子的外延。 例如：“法律词汇”是个集合概念，因为“法律词汇”是由许多法律语词构成的一个集合体，构成“法律词汇”的用语是它的个体；“法律词汇”中的任一个法律用语都不具有“法律词汇”的特点，如我们不能说“诉讼”、“法庭调查”、“法律咨询……是法律词汇，而只能说它们是法律用语。 再如：“警察”是个非集合概念，这一概念是对从事“维护社会治安”这类人员的一种概括，凡从事这种工作的人都称之为“警察”，都具有警察的性质。因此，“警察”是一个类概念，构成这个类的分子就是“警察”中的具体对象，如警察这个类中的张××、王××等。 ２．注意在不同的语言环境里，同一语词既可表达集合概念，也可表达非集合概念如： ①警察是维护社会治安的； ②警察是能吃若耐劳的。 面向对象程序设计第二章课后答案 1．什么是命名空间，如何访问命名空间的成员？ 【解答】为了解决不同文件中同名变量的问题，C++标准中引入命名空间的概念。命名空间（namespace）是一种特殊的作用域，命名空间可以由程序员自己来创建，可以将不同的标识符集合在一个命名作用域内，这些标识符可以类、对象、函数、变量、结构体、模板以及其他命名空间等。 在作用域范围内使用命名空间就可以访问命名空间定义的标识符。有3种访问方法： （1）直接指定标识符，访问方式为：命名空间标识符名∷成员名。 （2）使用using namespace命令 （3）使用using关键词声明 2．什么是内联函数，它有什么特点？哪些函数不能定义为内联函数？ 【解答】用inline关键字声明或定义的函数称为内联函数。C++中对于功能简单、规模小、使用频繁的函数，可以将其设置为内联函数。 内联函数（inline function）的定义和普通函数相同，但C++对它们的处理方式不一样。在编译时，C++将用内联函数程序代码替换对它每次的调用。这样，内联函数没有函数调用的开销，即节省参数传递、控制转移的开销，从而提高了程序运行时的效率。但是，由于每次调用内联函数时，需要将这个内联函数的所有代码复制到调用函数中，所以会增加程序的代码量，占用更多的存储空间，增大了系统空间方面的开销。因此，内联函数是一种空间换时间的方案。 函数体内有循环语句和switch语句，递归调用的函数不能定义为内联函数。 3．什么是函数重载？在函数调用时，C++是如何匹配重载函数的？ 【解答】函数重载是指两个或两个以上的函数具有相同的函数名，但参数类型不一致或参数个数不同。编译时编译器将根据实参和形参的类型及个数进行相应地匹配，自动确定调用哪一个函数。使得重载的函数虽然函数名相同，但功能却不完全相同。 在函数调用时，C++是匹配重载函数规则如下：首先寻找一个精确匹配，如果能找到，调用该函数；其次进行提升匹配，通过内部类型转换（窄类型到宽类型的转换）寻求一个匹配，如char到int、short到int等，如果能找到，调用该函数；最后通过强制类型转换寻求一个匹配，如果能找到，调用该函数。4．设置函数参数的默认值有何作用？ 【解答】C++中允许函数提供默认参数，也就是允许在函数的声明或定义时给一个或多个参数指定默认值。在调用具有默认参数的函数时，如果没有提供实际参数，C++将自动把默认参数作为相应参数的值 5．什么叫引用，使用引用时需要注意哪些问题？ 【解答】引用是一个变量的别名。使用引用时，必须在定义时进行初始化，不能在定义完后再赋值。 6．new运算符的作用是什么？delete运算符的作用是什么？ 实验4 类和对象(一) 实验目的： 1．掌握类的构造方法； 2．掌握对象的使用方法。 3．复习具有不同访问属性的成员的访问方式。 4．观察构造函数和析构函数的执行过程。 5．学习类的使用方法。 6．使用VC++的debug调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序。 实验内容： 1．声明一个名为Ellipse的结构体，其分量为椭圆的外切矩形的左上角与右下角两个点的坐标，并用它声明两个结构体变量，分别输入顶点坐标，计算并输出椭圆的面积； 注意：椭圆面积S=π(圆周率)×a×b(其中a,b分别是椭圆的半长轴,半短轴的长) 2．声明一个名为Ellipse的椭圆类，其公有的（public）数据成员为椭圆的外切矩形的左上角与右下角两个点的坐标；声明两个Ellipse类的对象，分别输入顶点坐标，计算并输出椭圆的面积； 3．声明一个名为Ellipse的椭圆类，其私有的（private）数据成员为椭圆的外切矩形的左上角与右下角两个点的坐标，声明公有的（public）成员函数访问椭圆的外切矩形的顶点坐标；声明两个Ellipse 类的对象，分别输入顶点坐标，计算并输出椭圆的面积； 4．声明一个名为Ellipse的椭圆类，其私有的（private）数据成员为椭圆的外切矩形的左上角与右下角两个点的坐标，设计构造函数Ellipse(int,int,int,int)对椭圆的外切矩形的顶点坐标赋值，设计函数Area()计算椭圆的面积；声明两个Ellipse类的对象，计算并输出椭圆的面积。 5.定义一个类ClsName，要求该类设计如下： （1）该类有两个整型数据成员x和y； （2）为该类重载三个不同的构造函数：分别为无参数、带一个参数和带两个参数的构造函数，要求在构造函数中输出必要的信息以示区别； （3）设计2个成员函数用来读取数据成员x和y； （4）设计2个成员函数用来设置数据成员x和y； （5）设计1个成员函数用来在屏幕上打印输出数据成员x和y； （6）在main（）函数中用三个不同的构造函数创建3个对象，并使用所有的成员函数对这些对象进 1. 什么是类？类的定义格式？类的成员一般分为哪两部分？它们的区别如何？ 答：类是C++语言的数据抽象和封装机制，它描述了一组具有相同属性（数据成员）和行为特征（成员函数）的对象。类的定义格式如下： Class 类名 { private: //私有数据成员和成员函数 public: //共有数据成员和成员函数 protected: //受保护的数据成员和成员函数 }； 类的成员分为数据成员和成员函数两部分。数据成员定义了该类对象的属性，不同对象的属性值可以不同；成员函数定义了该类对象的操作即行为。 2. 类与结构体有什么区别？ 答：c语言中的结构体只有数据成员，无函数成员。C++语言中的结构可有数据成员和成员函数。在默认情况下，结构体中的数据成员和成员函数都是共有的，而在类中可以是私有的。从外部可以随意修改结构体变量中的数据，对数据的这种操作时很不安全的，程序员不能通过结构体对数据进行保护和控制；在结构体中，数据和其相应的操作是分离的，使得程序的复杂性难以控制，而且程序的可重用性不好，严重影响了软件的生产效率。 3. 什么是对象？如何定义一个对象？对象的成员如何表示？ 答：对象是类的实例，是属性和服务的封装体。对象的定义有两种方法： 方法一：在定义类的同时直接定义。 class 类名 { private: // public: // }对象1，对象2； 方法二：在使用时定义对象。 类名对象1，对象2； 对象的成员的表示有： (1)通过对象调用成员。 格式：对象名.公有成员 其中，“.“成为对象的选择符，简称点运算符。 (2)通过指向对象的指针调用成员。 格式：指向对象的指针->成员 (3)通过对象的引用调用成员。 格式：对象的引用.成员 4. 什么是构造函数？构造函数有哪些特点？ 答：构造函数就是与类名有相同名称的成员函数，它可自动进行对象的初始化。 特点：它没有返回值说明；它不能被继承；它可以有默认实参；它不可以是虚（virtual）的；不可以对它取地址；不能用常规调用方法调用构造函数；当定义对象时，编译程序自动调用构造函数。 5. 什么是析构函数？析构函数有哪些特点？ 答：析构函数的作用是当对象生命期结束后，收回对象占用的资源。 析构函数的特点是：1) 析构函数名是在类名前加以符号“~”。2) 析构函数没有参数、返回类型和修饰符。3) 一个类中至多有一个析构函数，如果程序员没有定义析构函数，那么系统会自动地加入一个析构函数。4) 不能显式地调用析构函数，而是由系统自动调用。 6. 什么是默认构造函数和默认析构函数？ 答：若用户未显式定义一个类的构造函数，则C++语言提供一个默认的构造函数，也叫默认构造函数。同样，如果一个类没有显式的定义类的析构函数，则编译器将合成一个，也就是默认的析构函数。 7. 什么是复制构造函数？它的功能和特点是什么？ 答：复制构造函数是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构件及初始化。 复制构造函数的功能是用一个已有的对象来初始化一个被创建的同类对象，是一种特殊的构造函数，具有一般构造函数的所有特性，它的特殊功能是将参数代表的对象逐域拷贝到新创建的对象中。 在C++中，下面三种对象需要拷贝的情况。因此，复制构造函数将会被调用。 C++程序设计与应用基础第二章类和对象习题答案 1、请完成下列填空题 1）在C语言中,编程的单位是___函数__:在C++语言中,编程的单位是____类__。 2）在下面程序的横线处填上适当的语句,使类型该程序执行结果为10。 #include 6）假定用户没有给一个名为MyClass的类定义构造函数,则系统对其定义的默认构造函数形式为___MyClass()_____。 2、编程题 1）定义一个复数类imaginary。用友元函数实现该类的加、减、乘和除运算。 答案： class Imaginary { public: Imaginary(float a,float b); friend Imaginary Add(Imaginary& img1,Imaginary& img2); friend Imaginary Sub(Imaginary& img1,Imaginary& img2); friend Imaginary Mul(Imaginary& img1,Imaginary& img2); friend Imaginary Div(Imaginary& img1,Imaginary& img2); private: float x,y; }; Imaginary::Imaginary(float a,float b) { x=a; y=b; } Imaginary Add(Imaginary& img1,Imaginary& img2) { float a,b; a=img1.x+img2.x; 实验4类与对象 一、实验目的 通过编程和上机实验理解Java 语言是如何体现面向对象编程基本思想，了解类的封装方法，以及如何创建类和对象，了解成员变量和成员修饰方法的特性，掌握OOP 方式进行程序设计的方法。 二、实验要求 1. 编写创建对象和使用对象的方法的程序。 2. 编写显示当前日期和时间的程序。 3．编写不同成员变量、成员方法修饰方法的程序。 三、实验内容 （一）类、对象的使用 1．编写Java代码实现一个计数器类Computer，要求： （1）包含属性counterV alue用来保存计数器的当前值； （2）成员方法increment() 计数器加一，decrement() 计数器减一，方法reset()计数器清零。2．编程实现矩形类，要求： （1）包含属性长与宽； （2）类中有成员方法计算矩形周长和面积的方法。 3 .编程完成梯形类（） （1）public class Tixing { double upper,lower,high; } （2）public class Tixing { double upper,lower,high; double getArea(){ return (upper+lower)*high/2; } } （3）public class Tixing { double upper,lower,high; double getArea(){ return (upper+lower)*high/2; } public double getUpper() { return upper; } public void setUpper(double upper) { this.upper = upper; } public double getLower() { return lower; } public void setLower(double lower) { this.lower = lower; } public double getHigh() { return high; } public void setHigh(double high) { this.high = high; } } （4）public class Tixing { double upper,lower,high; public Tixing() { } public Tixing(double upper, double lower, double high) { this.upper = upper; this.lower = lower; this.high = high; } double getArea(){ return (upper+lower)*high/2; } public double getUpper() { return upper; } public void setUpper(double upper) { this.upper = upper; } public double getLower() { return lower; } public void setLower(double lower) { this.lower = lower; 实验4 类和对象（一） 实验目的及要求 1．掌握C++类的概念和基本组成、类的使用方法以及静态数据成员的使用； 2．熟悉各种成员函数包括构造函数、析构函数、内嵌函数的定义与使用。 实验内容 1．设计一个Birthday类，包含数据成员year、month、day，成员函数Print()和Age()，计算年龄并输出。构造一个Birthday的对象进行测试。 2．改正以下程序中的错误，并分析错误原因。提示：该程序中point类的构造函数定义不正确, 在main()中对数据成员的访问不正确。 #include 实验步骤 1．设计一个Birthday类，包含数据成员year、month、day，成员函数Print()和Age()，计算年龄并输出。构造一个Birthday的对象进行测试。 参考程序如下： #include 《面向对象程序设计》习题班级：学号：姓名：名单序号：成绩： 第2章类与对象 一、选择题（共26分，每题1分） 1．下列有关类的说法不正确的是（）。 A．对象是类的一个实例 B．任何一个对象只能属于一个具体的类 C．一个类只能有一个对象 D．类与对象的关系和数据类型与变量的关系相似 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(参数) 3．（）的功能是对象进行初始化。 A．析构函数 B.数据成员 C.构造函数 D.静态成员函数 4．下列表达方式正确的是（）。 A．class P{ B． class P{ public：public： intx=15；int x； void show(){cout< 实验四类和对象定义 一、实验类型 设计型 二、实验目的 1、实验目的 (1) 掌握类的声明、定义和使用方法。 (2) 掌握对象的定义和使用方法。 (3) 掌握具有不同访问属性的类中成员的使用方法。 三、上机准备 1、实验室安装VC++6.0软件。 2、类的基本概念、对象的基本概念。 四、实验内容与步骤 1、在Rect.cpp中，定义一个矩形（Rect）类，包括矩形的左上角坐标（X1，Y1），矩形右下角坐标（X2，Y2）四个数据成员；包括计算矩形面积（getArea），计算矩形周长（getPerimeter），设置矩形数据成员（setRect）和输出矩形数据成员（print）四个成员函数。数据成员为私有成员，成员函数为公有成员且在类说明内定义实现。在main()函数中建立Rect类对象并进行测试。 提示与分析： (1) 分析类中数据成员的类型并定义对应的变量，如double X1,X2,Y1,Y2; (2) 分析成员函数的函数原型，即返回值及其类型以及相关参数，如： double getArea(); double getPerimeter(); void setRect(double,double ,double,double); void print(); (3) 思考成员函数的函数体实现代码。 计算矩形面积和周长的方法： Area=fabs(X2-X1)*fabs(Y2-Y1); Perimeter=(fabs(X2-X1)+fabs(Y2-Y1))*2; (4) 根据要求设定类成员的访问权限，如成员函数为公有成员（public），数据成员为私有成员（private）。 (5) 将成员函数的函数体代码放到类说明中。 (6) 在main()函数中建立Rect类的实例并调用对象的方法进行测试，如 第4章Java语言与面向对象作业习题与答案 一、简答题 1．什么是对象？什么是类？ 对象是一种抽象数据类型。它包含了事物的静态特征（属性）和动态特征（行为）两大特征。 类是一组同种对象的集合与抽象。即是具有相同属性和方法的一组对象集合。2．Java语言的单继承是指什么？ 一个类可以派生出多个子类，但子类只允许有一个父类，而不允许存在多个父类。3．在一个共有类中的数据成员及方法成员的访问控制符为缺省，则这个类可供什么样的包引用？ 当一个类的访问控制符为public共有时，表明这个类作为整体对其它类是可见和可引用的；但其数据成员和方法成员访问控制符为缺省时，它们只能被包中类（含当前类）引用。4．抽象类的用途 （1）设计在更高的层次上进行，不考虑具体对象，从而大大简化了处理问题的复杂性； （2）设计出的类也具有更加良好的可扩展性。 5．什么是非静态的成员变量？ 非静态成员即为实例成员变量（没有加static修饰的变量）。 6．异常Exception和错误Error有什么不同？Java如何处理它们？ 答：错误通常是指程序本身存在非法情形，常常是因为代码存在问题而引起的，如造成系统崩溃、虚拟机粗错、动态链接失败等，这一类错误无法恢复或不可能捕获，并将导致应用程序中断。 异常表示另外一种"非同寻常"的错误。这种错误通常是不可预测，但可以被捕获且可以恢复。常见的异常情况包括内存不足、找不到所需文件等。 对于错误，编程人员可以通过对程序进行更仔细的检查，以避免这种错误。 对于异常，可以使用捕获机制进行捕获，再编写出相应的处理程序。 7．简单陈述Java的异常处理机制。 答：Java采取"抛出-捕获"的方式，一旦一个异常想象产生，Runnable环境和应用程序会抛出各种标准类型和自己定义的异常，系统就可以捕获这些异常，并一定有相应的机制来处理它，确保不会产生司机、死循环或其它对操作系统的损害，从而保证了整个程序运行的安全性。 8．简单陈述throw语句和throws关键字之间的差别。 答：throw语句是在一个方法中用来直接抛出异常对象，其格式是： throw 异常对象； throws关键字是用一个方法声明首部，用来指出这个方法中可能产生若干种异常，其格式：[方法修饰符] 返回类型方法名（参数表）throws 异常类型表 { /*方法体*/ } 二、填空题 1．所有Java应用程序都必须包含的一个类方法是main() 。 2．面向对象程序设计语言的三种重要特性是封装性、继承性和多态性。 3．方法重载与方法覆盖的不同有：方法重载是指允许在同一个类中定义多个同名方法，它们通过形参的个数或形参参数的类型来区别；方法覆盖是指在子类中重新定义了与父类中的方法同名的方法。 1．什么是命名空间，如何访问命名空间的成员？ 【解答】为了解决不同文件中同名变量的问题，C++标准中引入命名空间的概念。命名空间（namespace）是一种特殊的作用域，命名空间可以由程序员自己来创建，可以将不同的标识符集合在一个命名作用域内，这些标识符可以类、对象、函数、变量、结构体、模板以及其他命名空间等。 在作用域范围内使用命名空间就可以访问命名空间定义的标识符。有3种访问方法： （1）直接指定标识符，访问方式为：命名空间标识符名∷成员名。 （2）使用using namespace命令 （3）使用using关键词声明 2．什么是内联函数，它有什么特点？哪些函数不能定义为内联函数？ 【解答】用inline关键字声明或定义的函数称为内联函数。C++中对于功能简单、规模小、使用频繁的函数，可以将其设置为内联函数。 内联函数（inline function）的定义和普通函数相同，但C++对它们的处理方式不一样。在编译时，C++将用内联函数程序代码替换对它每次的调用。这样，内联函数没有函数调用的开销，即节省参数传递、控制转移的开销，从而提高了程序运行时的效率。但是，由于每次调用内联函数时，需要将这个内联函数的所有代码复制到调用函数中，所以会增加程序的代码量，占用更多的存储空间，增大了系统空间方面的开销。因此，内联函数是一种空间换时间的方案。 函数体内有循环语句和switch语句，递归调用的函数不能定义为内联函数。 3．什么是函数重载？在函数调用时，C++是如何匹配重载函数的？ 【解答】函数重载是指两个或两个以上的函数具有相同的函数名，但参数类型不一致或参数个数不同。编译时编译器将根据实参和形参的类型及个数进行相应地匹配，自动确定调用哪一个函数。使得重载的函数虽然函数名相同，但功能却不完全相同。 在函数调用时，C++是匹配重载函数规则如下：首先寻找一个精确匹配，如果能找到，调用该函数；其次进行提升匹配，通过内部类型转换（窄类型到宽类型的转换）寻求一个匹配，如char到int、short到int等，如果能找到，调用该函数；最后通过强制类型转换寻求一个匹配，如果能找到，调用该函数。 4．设置函数参数的默认值有何作用？ 【解答】C++中允许函数提供默认参数，也就是允许在函数的声明或定义时给一个或多个参数指定默认值。在调用具有默认参数的函数时，如果没有提供实际参数，C++将自动把默认参数作为相应参数的值 5．什么叫引用，使用引用时需要注意哪些问题？ 【解答】引用是一个变量的别名。使用引用时，必须在定义时进行初始化，不能在定义完后再赋值。 6．new运算符的作用是什么？delete运算符的作用是什么？ 【解答】在C++程序中，new是动态分配内存的运算符，自动计算需要分配的空间。delete是撤销动态申请的内存运算符。delete与new通常配对使用，建立堆对象时使用new运算符、删除堆对象时delete使用运算符。 7、 #include"stdafx.h"第4章 类与对象2
4对象与类
UML第二章作业答案
第二章 概念部分练习题
面向对象程序设计第二章课后答案说课讲解
实验4 类和对象(一)
2.1 类和对象 (第二章 C++面向对象程序设计)
C++程序设计与应用基础第二章 类和对象习题答案
实验4 类与对象
实验4 类和对象(一)
c++第2章 类和对象习题
实验四 类和对象定义
第4章Java语言与面向对象作业习题与答案
面向对象程序设计第二章课后答案
相关主题
文本预览