出自:国家开放大学面向对象程序设计

假定没有给一个类XXK2显式地定义任何构造函数，则利用new运算创建该类的一个对象时，自动调用的构造方法为（ ）。
【A.】XXK2()
【B.】XXK2
【C.】new()
【D.】XXK2(new)
在类定义首部的语法格式中，（ ）不能作为其中的修饰符。
【A.】abstract
【B.】implements
【C.】private
【D.】final
在方法调用的参数传递中，对于基本数据类型的参数，则按照（ ）进行传递，对于数组类型或类类型的参数则按照（ ）进行传递。
【A.】值 引用
【B.】方法名称 代码
【C.】参数类型 返回值
【D.】参数 代码
在类定义首部的语法格式中，（ ）不能作为其中的修饰符。
【A.】public
【B.】protectd
【C.】extends
【D.】abstract
类中的成员方法也可以使用关键字（ ）进行修饰，表示该方法在继承类中不能被重载。
【A.】new
【B.】static
【C.】not
【D.】final
具有（ ）访问权限的成员只能被本类中的成员所访问。
【A.】public
【B.】protectd
【C.】private
【D.】缺省
在方法调用的参数传递中，若为（ ）传递，方法体中对形参内容的修改不影响实参的值。
【A.】无效
【B.】引用
【C.】按值
【D.】代码
假定要利用一个类XXK6访问类（静态）方法size()，则应表示为（ ）。
【A.】XXK6.size
【B.】class.size
【C.】object.size()
【D.】XXK6.size()
方法定义中的参数表称为形式参数表，其中的参数称为形式参数，每个形式参数的定义（声明）包括（ ）和（ ）两个方面。
【A.】参数数量 参数大小
【B.】参数类型 参数名
【C.】参数类型 返回值
【D.】表达式 代码
在方法调用中，首先需要实参表中的实参向形参表中的形参进行传递，此传递分为（ ）传递和（ ）传递两种方式。
【A.】参数数量 参数大小
【B.】按值 引用
【C.】参数类型 返回值
【D.】参数 代码
假定要采用默认的构造方法定义和创建类XXK3的一个对象x，则使用的语句为（ ）。
【A.】x=new
【B.】x=new class
【C.】XXK3() x=new XXK3
【D.】XXK3 x=new XXK3()
假定一个类的类名为XXK1，则该类的构造方法的名称为（ ）。
【A.】XXK
【B.】XXK1
【C.】new
【D.】name
假定类中定义的一个成员变量名为xyz，在一个方法定义的参数表中，一个参数名也为xyz，则把参数xyz的值赋给成员变量xyz的赋值语句为（ ）。
【A.】this.xyz=xyz
【B.】xyz=new xyz
【C.】this.xyz=xyz()
【D.】xyz==xyz
假定要利用一个类XXK6的对象x访问成员方法size()，则应表示为（ ）。
【A.】size= XXK6
【B.】x=size
【C.】x.size()
【D.】XXK6.size
当类中的成员定义采用static关键字修饰时，则称该成员为类的（ ）成员。。
【A.】新建
【B.】实例
【C.】动态
【D.】静态
在方法调用的参数传递中，若为（ ）传递，则实参变量和形参变量所引用的是内存中的同一个存储空间，方法体对形参内容的修改实际上就是对实参内容的修改。
【A.】无效
【B.】引用
【C.】按值
【D.】代码
定义一个终结类需要在类首部的关键字class前使用的修饰符为（ ）。
【A.】static
【B.】abstract
【C.】final
创建一个类的对象需要使用的单目运算符为（ ）。
【A.】new
【B.】class
【C.】newobject
【D.】create
在一个类中定义的任何方法都允许重载，在重载的多个方法中，（ ）是相同的，但（ ）是不同的。
【A.】返回值 方法名
【B.】代码 计算
【C.】参数表 方法名
【D.】方法名 参数表
具有（ ）访问权限的成员能够被本类和同一包中的其他任何类中的成员所访问。
【A.】公有
【B.】保护
【C.】私有
【D.】缺省
类中的成员变量也可以使用关键字（ ）进行修饰，表示其值被初始化后不能够再被修改。
【A.】new
【B.】static
【C.】not
【D.】final
public class XXK2 {
private int a,b;
public XXK2(int aa, int bb) {a=aa; b=bb;}
public int f1(int x) {
if(x>10) return a+b+3*x;
else return a*b*x;
}
public static void main(String[] args) {
XXK2 x=new XXK2(3,4);
int y=x.f1(12);
System.out.println("y="+y);
}
}
【A.】y=45
【B.】y=43
public class XXK2 {
private int a,b;
public XXK2(int aa, int bb) {a=aa; b=bb;}
public int f1(int x) {
if(x>10) return a+b+3*x;
else return a*b*x;
}
public static void main(String[] args) {
XXK2 x=new XXK2(3,4);
int y=x.f1(8);
System.out.println("y="+y);
}
}
【A.】y=96
【B.】y=98
public class XXK2 {
private final int a;
public XXK2(int a) {this.a=a;}
public int f1(int x) {
if(x%2==1) return 2*(a+x);
else return 3*a+x;
}
public int get() {return a;}
public static void main(String[] args) {
XXK2 x=new XXK2(3);
int y=x.f1(10);
y+=x.get();
System.out.println("y="+y);
}
}

【A.】y=22
【B.】y=24
public class XXK2 {
private int a;
public XXK2(int aa) {a=aa;}
public int f1(int x) {
if(x%2==1) return 2*(a+x);
else return 3*a+x;
}
public int get() {return a;}
public static void main(String[] args) {
XXK2 x=new XXK2(5);
int y=x.f1(9);
y+=x.get()*x.get();
System.out.println("y="+y);
}
}

【A.】y=52
【B.】y=53
public class XXK2 {
private int a;
public XXK2() {a=3;}
public XXK2(int aa) {a=aa;}
public double f1() {
return 2*Math.pow(a,3)+a;
}
public static void main(String[] args) {
XXK2 x=new XXK2(), y=new XXK2(5);
System.out.println(x.f1()+", "+y.f1());
}
}

【A.】58.0, 256.0
【B.】57.0, 255.0
public class XXK2 {
private final int a;
public XXK2(int a) {this.a=a;}
public int f1(int x) {
if(x%2==1) return 2*(a+x);
else return 3*a+x;
}
public int get() {return a;}
public static void main(String[] args) {
XXK2 x=new XXK2(8);
int y=x.f1(20);
y+=x.get();
System.out.println("y="+y);
}
}


【A.】y=52
【B.】y=54
Java语言中的每个类都隐含着继承一个父类，这个父类为（ ）。
【A.】super
【B.】father
【C.】Java.lang.Object
【D.】class.dad
在派生类的构造方法中调用父类构造方法时，其语句关键字为（ ）。
【A.】Object
【B.】super
【C.】father
【D.】mother
Java语言中的类的层次结构为（ ）结构。根节点为（ ）类。
【A.】树状 Object
【B.】数组 int
【C.】文件 math
【D.】树状 root
Java语言中的一个类只能有（ ）个父类，可以有（ ）个派生类。
【A.】一 一
【B.】一 多
【C.】多 一
【D.】多 多
class Rectangle {
private int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public int area() {return a*b;}
public int girth() {return 2*(a+b);}
}

public class XXK3 extends Rectangle {
private int c;
public XXK3(int aa, int bb, int cc) {super(aa,bb); c=cc;}
public int volume() {return area()*c;}
public int arrisLength() {return 2*girth()+4*c;}

public static void main(String[] args) {
XXK3 x=new XXK3(1,3,5);
int y1=x.volume();
int y2=x.arrisLength();
System.out.println(y1+", "+y2);
}
}

【A.】20, 40
【B.】15, 36
class Rectangle {
private int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public int area() {return a*b;}
public int girth() {return 2*(a+b);}
}

public class XXK3 extends Rectangle {
private int c;
public XXK3(int aa, int bb, int cc) {super(aa,bb); c=cc;}
public int volume() {return area()*c;}
public int arrisLength() {return 2*girth()+4*c;}

public static void main(String[] args) {
XXK3 x=new XXK3(2,3,4);
int y1=x.volume();
int y2=x.arrisLength();
System.out.println(y1+", "+y2);
}
}

【A.】24, 36
【B.】26, 38
abstract class Shape {
int a,b;
public Shape(int aa, int bb) {a=aa; b=bb;}
abstract public double area();
}
class Rectangle extends Shape {
public Rectangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b;}
}
class Triangle extends Shape {
public Triangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b/2;}
}

public class XXK3 {
public static void main(String[] args) {
Shape x,y;
x=new Rectangle(10,20);
y=new Triangle(10,15);
System.out.println(x.area()+", "+y.area());
}
}

【A.】200.0, 75.0
【B.】400.0, 150.0
interface Shape {
double area();
double girth();
}
class Rectangle implements Shape {
int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public double area() {return a*b;}
public double girth() {return 2*(a+b);}
}

public class XXK3 {
public static void main(String[] args) {
Shape x;
x=new Rectangle(5,8);
System.out.println(x.area()+", "+x.girth());
}
}



【A.】40.0, 26.0
【B.】80.0, 42.0
abstract class Shape {
int a,b;
public Shape(int aa, int bb) {a=aa; b=bb;}
abstract public double area();
}
class Rectangle extends Shape {
public Rectangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b;}
}
class Triangle extends Shape {
public Triangle(int aa, int bb) {super(aa,bb);}
public double area() {return a*b/2;}
}

public class XXK3 {
public static void main(String[] args) {
Shape x,y;
x=new Rectangle(5,8);
y=new Triangle(5,8);
System.out.println(x.area()+", "+y.area());
}
}

【A.】40.0, 20.0
【B.】80.0, 40.0
interface Shape {
double area();
double girth();
}
class Rectangle implements Shape {
int a,b;
public Rectangle(int aa, int bb) {a=aa; b=bb;}
public double area() {return a*b;}
public double girth() {return 2*(a+b);}
}

public class XXK3 {
public static void main(String[] args) {
Shape x;
x=new Rectangle(6,10);
System.out.println(x.area()+", "+x.girth());
}
}


【A.】60.0, 32.0
【B.】80.0, 42.0
假定一个字符串对象x的值为"abc"，则x.equals("acb")的值为（ ）。
【A.】True
【B.】NULL
【C.】False
【D.】"ab"
假定一个一维数组的定义语句为“int[]x=new int[20];”，则x.length的值为（ ）。
【A.】19
【B.】20
【C.】21
【D.】不确定
假定二维数组x中的一个元素为x[2][3]，则它的行下标和列下标分别为（ ）和（ ）。
【A.】1 2
【B.】2 3
【C.】3 4
【D.】3 2
假定一个数组对象为x，则x.length的值为该数组所包含元素的（ ）。
【A.】个数
【B.】NULL
【C.】类型
【D.】不确定
假定一个字符串对象x的值为"abc"，则x.concat("def")的值为（ ）。
【A.】"abc"
【B.】"defabc"
【C.】"cd"
【D.】"abcdef"
假定一个字符串对象x的值为"abc"，则x.compareTo("def")的值为（ ）0。
【A.】大于
【B.】等于
【C.】小于
【D.】不等于
基本数据类型int和double对应的包装类分别为（ ）和（ ）。
【A.】Integer Double
【B.】int double
【C.】Int、Double
【D.】IntClass、DoubleClass
假定一个字符串对象x的值为"abcdef\n"，则x.charAt(4)的值为（ ）。
【A.】.d.
【B.】.e.
【C.】.f.
【D.】.cdef.
假定要定义一个int型的二维数组为x，并假定它的行数为5，列数为6，则其定义语句为int [][] x=（ ）。
【A.】int[5][6];
【B.】new int[5][6];
【C.】new int[6][5];
【D.】new int[6][7];
假定一个二维数组的定义语句为“int[][]x=new int[3][4];”，则该数组包含的元素个数为（ ）。
【A.】12
【B.】6
【C.】7
【D.】20
对于String类的字符串，其值和长度都不能被改变，所以被称为（ ）字符串，对于StringBuffer类的字符串，其值和长度都可以被改变，所以被称为（ ）字符串。
【A.】常量 变量
【B.】变量 常量
【C.】通用 无效
【D.】固定 移动
假定要定义一个int型的一维数组为x，并假定它的长度为10，则其定义语句为int [] x=（ ）。
【A.】new int[10];
【B.】NULL
【C.】NEW int[];
【D.】int[10];
假定一个二维数组的定义语句为“int[][]x=new int[3][4];”，则x.length和x[0].length的值分别为（ ）和（ ）。
【A.】3 4
【B.】3 3
【C.】4 4
【D.】4 3
首页 <上一页 1 2 3 4 下一页> 尾页