1、请阅读下面程序
public class Test {
public Test(){
System.out.println(“构造方法一被调用了”);
}
public Test(int x){
this();
System.out.println(“构造方法二被调用了”);
}
public Test(boolean b){
this(1);
System.out.println(“构造方法三被调用了”);
}
public static void main(String[] args){
Test test = new Test(true);
}
}
上面程序的运行结果为()
A、
构造方法一被调用了
B、
构造方法一被调用了
构造方法二被调用了
C、
构造方法一被调用了
构造方法二被调用了
构造方法三被调用了
D、
构造方法三被调用了
答案: C
解析:
在测试类中调用了参数类型为boolean类型的构造方法,故运行结果为“构造方法三被调用了”。
2、请阅读下面程序
public class Test {
public Test(){
System.out.println(“构造方法一被调用了”);
}
public Test(int x){
this();
System.out.println(“构造方法二被调用了”);
}
public Test(boolean b){
this(1);
System.out.println(“构造方法三被调用了”);
}
public static void main(String[] args){
Test test = new Test(true);
}
}
上面程序的运行结果为()
A、 构造方法一、构造方法二和构造方法三都被调用了
B、 只有构造方法一被调用了
C、 只有构造方法一和构造方法三被调用了
D、 只有构造方法三被调用了
答案: A
解析:
在测试类中调用了参数类型为boolean类型的构造方法时,先调用this(1);方法;在this(1);方法中,先调用this();方法;故运行结果为
“构造方法一被调用了”
“构造方法二被调用了”
“构造方法三被调用了”。
3、请阅读下面程序
public class Test {
public Test(){
System.out.println(“构造方法一被调用了”);
}
public Test(int x){
this();
System.out.println(“构造方法二被调用了”);
}
public Test(boolean b){
this(1);
System.out.println(“构造方法三被调用了”);
}
public static void main(String[] args){
Test test = new Test(true);
}
}
上面程序的运行结果为()
A、 构造方法一、构造方法二和构造方法三都被调用了
B、 只有构造方法二和构造方法三被调用了
C、 只有构造方法一和构造方法三被调用了
D、 只有构造方法三被调用了
答案: A
解析:
在测试类中调用了参数类型为boolean类型的构造方法时,先调用this(1);方法;在this(1);方法中,先调用this();方法;故运行结果为
“构造方法一被调用了”
“构造方法二被调用了”
“构造方法三被调用了”。
4、下面选项中,类的声明方式正确的是()
A、 public void AA{…}
B、 public class Move(){…}
C、 public class void number{…}
D、 public class Car{…}
答案: D
5、阅读下列代码:
public class Test{
int count = 9;
public void count1(){
int count =10;
System.out.println("count1="+count);
}
public void count2(){
System.out.println("count2="+count);
}
public static void main(String args[]){
Test t=new Test();
t.count1();
t.count2();
}
}
编译运行后,输出结果是()
A、
count1=9 count2=9
B、
count1=10 count2=9
C、 count1=10 count2=10
D、
count1=9 count2=10
答案: B
6、在java中,以下程序的输出结果是()
class Point {
int x;
boolean y;
void output() {
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt =new Point();
pt.output();
}
}
A、
运行错误
B、
0 ture
C、
0 false
D、 0 0
答案: C
7、在Java中,提供了4种访问级别,以下访问控制级别由小到大顺序排列正确的是()
A、 private、default、protected、public
B、 default、public、protected、private
C、 private、default、public、protected
D、 protected、public、private、default
答案: A
8、在Java接口中,下列选项中属于有效的方法声明的是()
A、 public void aMethod();
B、 final void aMethod();
C、 void aMethod(){}
D、 private void aMethod();
答案: A
9、关于封装的描述,下面说法错误的是()。
A、 封装将变化隔离
B、 封装提高重用性
C、 封装提高安全性
D、 只有被private修饰才叫做封装
答案: D
10、在Java中,下面对于构造函数的描述正确的是()
A、 类必须显式定义构造函数
B、 构造函数的返回类型是void
C、 构造函数和类有相同的名称,并且不能带任何参数
D、 一个类可以定义多个构造函数
答案: D
解析:A:类可以不定义构造函数,类会自动生成一个默认的无参构造函数。 B:构造函数没有返回值类型。 C:构造函数可以有零个、一个和多个参数。
11、阅读下列代码:
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}
上述代码的运行结果为()
A、 6
B、 3 4
C、 8
D、 7
答案: D
12、编译运行下面的代码会发生什么情况()
public class MyClass{
static int i;
public static void main(String[] args){
System.out.println(i);
}
}
A、 错误,变量i没有被初始化
B、 输出null
C、 输出1
D、
输出0
答案: D
13、阅读下列代码:
public class Test{
static int i;
public int aMethod( ){
i++;
return i;
}
public static void main(String [] args){
Test test = new Test( );
test.aMethod( );
System.out.println(test.aMethod( ));
}
}
程序编译运行后,输出结果是()
A、 0
B、 1
C、 2
D、 3
答案: C
14、阅读下列代码:
class Parent{
protected void eat(){}
}
class Child extends Parent {
_______ void eat(){}
}
可以填入下划线处的访问控制修饰符为( )
A、 protected
B、 private
C、
什么也不填 //及默认修饰符
D、 public
答案: AD
15、下面对static的描述正确的是()
A、 静态修饰的成员变量和成员方法随着类的加载而加载
B、 静态修饰的成员方法可以访问非静态成员变量
C、 静态修饰的成员可以被整个类对象所共享
D、 静态修饰的成员变量和成员方法随着类的消失而消失
答案: ACD
16、以下关于static关键字的说法正确的是()
A、 static关键字可以修饰类
B、 static关键字可以修饰成员
C、 static关键字可以修饰所有的变量
D、 static关键字可以修饰代码块
答案: BD
17、在定义一个类的时候,如果类的成员被private所修饰,该成员不能在类的外部被直接访问。
答案: 正确
解析:如果类的成员被private访问控制符修饰,则这个成员只能被该类的其它成员访问,其它类无法直接访问。类的良好封装就是通过private关键字实现的。
18、Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。
答案: 正确
解析:Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。
19、构造方法不可以被继承。
答案: 正确
解析:构造方法不可以被继承,因为如果子类继承了父类的构造方法,父类的构造在子类中不符合构造方法的规则,也不符合一般方法的规则。父类的构造在子类中没有返回类型,方法名也与子类的类名不相同。不符合java语法规范。
20、类中static修饰的变量或方法,可以使用类名或对象的引用变量访问。
答案: 正确
21、在静态方法内可以调用非静态方法。
答案: 错误
22、静态代码块会随着类对象的创建而创建。
答案: 错误
23、在非静态成员方法中,可以使用关键字【】访问其他非静态成员。
答案: this;
24、面向对象的三大特征是【】、【】和【】。
答案: 封装性;继承性;多态性;
25、类与对象的关系中,【】用于描述多个对象的共同特征,它是对象的模板。
答案: 类;
26、在类中定义的【】用于描述对象的行为。
答案: 方法;
27、【】是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体。
答案: 类;
28、被static关键字修饰的成员变量被称为【】,它可以被该类所有的实例对象共享。
答案: 静态变量;
29、Person p1 = new Person();Person p2 = p1;这两句代码创建了【】个对象。
答案: 2;
30、一个类中可以定义多个构造方法,只要每个构造方法的【】或【】不同,即可实现重载。
答案:
参数类型
;
参数个数
;
31、在Java中,针对类、成员方法和属性提供了四种访问级别,分别是public、【】、【】和【】。
答案: private;default;protected;
32、所谓类的封装是指在定义一个类时,将类中的属性私有化,即使用【】关键字来修饰。
答案: private;
33、在一个类的内部嵌套定义的类称为【】。
答案: 内部类;
34、类的封装是指在定义一个类时,将类中的属性私有化,即使用【】关键字来修饰。
答案: private;
35、构造方法的名称必须和【】保持一致。
答案: 类名;
36、如果一个方法没有返回任何值,则该方法的返回值类型为【】。
答案: void;
37、this关键字可以访问一个类的【】变量,解决与局部变量名称冲突的问题。
答案: 成员;
38、请阅读下面程序
public class Test {
public Test(){
System.out.println(“构造方法一被调用了”);
}
public Test(int x){
this();
System.out.println(“构造方法二被调用了”);
}
public Test(boolean b){
this(1);
System.out.println(“构造方法三被调用了”);
}
public static void main(String[] args){
Test test = new Test(true);
}
}
上面程序的运行结果为()
A、
构造方法一被调用了
B、
构造方法一被调用了
构造方法二被调用了
C、
构造方法一被调用了
构造方法二被调用了
构造方法三被调用了
D、
构造方法三被调用了
答案: C
解析:
在测试类中调用了参数类型为boolean类型的构造方法,故运行结果为“构造方法三被调用了”。
39、请阅读下面程序
public class Test {
public Test(){
System.out.println(“构造方法一被调用了”);
}
public Test(int x){
this();
System.out.println(“构造方法二被调用了”);
}
public Test(boolean b){
this(1);
System.out.println(“构造方法三被调用了”);
}
public static void main(String[] args){
Test test = new Test(true);
}
}
上面程序的运行结果为()
A、
构造方法一、构造方法二和构造方法三都被调用了
B、
只有构造方法一被调用了
C、 只有构造方法一和构造方法三被调用了
D、
只有构造方法三被调用了
答案: A
解析:
在测试类中调用了参数类型为boolean类型的构造方法时,先调用this(1);方法;在this(1);方法中,先调用this();方法;故运行结果为
“构造方法一被调用了”
“构造方法二被调用了”
“构造方法三被调用了”。
40、请阅读下面程序
public class Test {
public Test(){
System.out.println(“构造方法一被调用了”);
}
public Test(int x){
this();
System.out.println(“构造方法二被调用了”);
}
public Test(boolean b){
this(1);
System.out.println(“构造方法三被调用了”);
}
public static void main(String[] args){
Test test = new Test(true);
}
}
上面程序的运行结果为()
A、
构造方法一、构造方法二和构造方法三都被调用了
B、 只有构造方法二和构造方法三被调用了
C、 只有构造方法一和构造方法三被调用了
D、 只有构造方法三被调用了
答案: A
解析:
在测试类中调用了参数类型为boolean类型的构造方法时,先调用this(1);方法;在this(1);方法中,先调用this();方法;故运行结果为
“构造方法一被调用了”
“构造方法二被调用了”
“构造方法三被调用了”。
41、阅读下列代码:
public class Test{
int count = 9;
public void count1(){
int count =10;
System.out.println("count1="+count);
}
public void count2(){
System.out.println("count2="+count);
}
public static void main(String args[]){
Test t=new Test();
t.count1();
t.count2();
}
}
编译运行后,输出结果是()
A、
count1=9 count2=9
B、
count1=10 count2=9
C、 count1=10 count2=10
D、
count1=9 count2=10
答案: B
42、在java中,以下程序的输出结果是()
class Point {
int x;
boolean y;
void output() {
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) {
Point pt =new Point();
pt.output();
}
}
A、
运行错误
B、
0 ture
C、
0 false
D、 0 0
答案: C
43、阅读下列代码:
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}
上述代码的运行结果为()
A、 6
B、 3 4
C、 8
D、 7
答案: D
44、编译运行下面的代码会发生什么情况()
public class MyClass{
static int i;
public static void main(String[] args){
System.out.println(i);
}
}
A、 错误,变量i没有被初始化
B、 输出null
C、 输出1
D、
输出0
答案: D
45、阅读下列代码:
public class Test{
static int i;
public int aMethod( ){
i++;
return i;
}
public static void main(String [] args){
Test test = new Test( );
test.aMethod( );
System.out.println(test.aMethod( ));
}
}
程序编译运行后,输出结果是()
A、 0
B、 1
C、 2
D、 3
答案: C
46、阅读下列代码:
class Parent{
protected void eat(){}
}
class Child extends Parent {
_______ void eat(){}
}
可以填入下划线处的访问控制修饰符为( )
A、 protected
B、 private
C、
什么也不填 //及默认修饰符
D、 public
答案: AD
47、一个类中可以定义多个构造方法,只要每个构造方法的【】或【】不同,即可实现重载。
答案: 参数;参数个数;
48、
请阅读下面的程序,程序的运行结果是()。
class Person {
String name;
int age;
public Person() {}
public Person(String n, int a) {
name = n;
age = a;
}
public void show() {
System.out.print(name + "---" + age +" ");
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
Person p2 = new Person("周星驰", 27);
p2.show();
}
}
A、 null---0 周星驰---27
B、 null---27 周星驰---27
C、 周星驰---0 null---27
D、 周星驰---27 null ---27
答案: A
解析:p1对象由无参构造函数创建,String类型初始值为null,int类型初始值为0。p2对象由有参构造函数创建,初始化时,传入name值为周星驰,age值为27。
49、
Bank bank = new Bank("小梦", "654321", 100.0);的作用是将Bank类实例化,并传入参数。
答案: 正确
50、
在Java中,对象是通过【】创建出来的。
答案:
类
;
51、
static String bankName; 用于定义静态变量银行名称。
答案: 正确
52、
新用户到达银行之后,银行会表示欢迎,所以应该在银行类中定义欢迎方法。欢迎的语句都是一样的,所以此方法可定义为静态方法。
答案: 正确
53、
在Java中使用【】类型的实例对象表示一个字符串。
答案:
String
;
54、
构造方法的名称必须和【】保持一致。
答案:
类名
;
解析:在一个类中定义的方法如果同时满足以下三个条件,该方法称为构造方法,具体如下:
1、 方法名与类名相同
2、 在方法名的前面没有返回值类型的声明
3、 在方法中不能使用retur
55、
this关键字可以访问一个类的【】变量,解决与局部变量名称冲突的问题。
答案:
成员
;
解析:通过this关键字可以明确地去访问一个类的成员变量,解决与局部变量名称冲突问题。
56、
静态变量可以被类和对象调用。
答案: 正确
解析:静态变量指的是被static关键字修饰的变量,它可以被类和对象调用,并且是通过类名调用的。
57、
下列程序的运行结果是
class Demo{
private String name;
Demo(String name){this.name = name;}
private static void show(){
System.out.println(name);
}
public static void main(String[] args){
Demo d = new Demo("lisa");
d.show();
}
}
A、 输出lisa
B、 输出null
C、 输出name
D、 编译失败,无法从静态上下文中引用非静态变量name
答案: D
解析:静态不能直接访问非静态。
58、
请简要说明静态变量有哪些特点。
答案:
静态变量可以使用“类名.变量名”的方式调用;
静态变量会被类的实例对象所共享;
静态变量随着类的加载而加载到内存静态区;
静态变量随着类的消失而消失。
59、
下列关于静态代码块的描述中,正确的是( )
A、 静态代码块指的是被static关键字修饰的代码块
B、 静态代码块随着类的加载而加载
C、 使用静态代码块可以实现类的初始化
D、 每次创建对象时,类中的静态代码块都会被执行一次
答案: ABC
解析:静态代码块中的代码只会给执行一次。
60、
成员内部类可以直接访问其所在的外部类中的成员,不用创建对象。
答案: 正确
解析:因为成员内部类中能获取到外部类的引用是外部类.this。
61、
在成员方法中可以使用“this([参数1,参数2…])”来调用其它的构造方法。
答案: 错误
解析:this()这样的形式只能在构造方法中使用,并且只能出现一次。
62、
静态方法运行时,在哪个内存区域中( )
A、 栈内存
B、 堆内存
C、 方法区
D、 寄存器
答案: A
解析:访问运行都在栈内存。
63、
在有多个静态代码块的情况下,虚拟机会随机运行。
答案: 错误
解析:多个静态代码,按编写的顺序执行。
64、
在垃圾回收机制中,可以通过调用【】方法来通知Java虚拟机立即进行垃圾回收。
答案:
System.gc()
;
解析:在垃圾回收机制中,除了等待Java虚拟机进行自动垃圾回收,也可以通过调用System.gc()方法来通知Java虚拟机立即进行垃圾回收。
65、
下列关于静态方法的描述中,错误的是( )
A、 静态方法指的是被static关键字修饰的方法
B、 静态方法不占用对象的内存空间,而非静态方法占有对象的内容空间
C、 静态方法内可以使用this关键字
D、 静态方法内部只能访问被static修饰的成员
答案: C
解析:静态方法内部不可以使用this、super等关键字。
66、
使用this调用类的构造方法,下面的说法中错误的是( )
A、 使用this调用构造方法的格式为this([参数1,参数2…])
B、 只能在构造方法中使用this调用其它的构造方法
C、 使用this调用其它构造方法的语句必须放在第一行
D、 在一个类的两个构造方法中可以使用this互相调用
答案: D
解析:在一个类的两个构造方法中使用this互相调用,会造成内存溢出,程序报错。
67、
Java中可以通过this关键字解决成员变量与局部变量名称冲突问题。
答案: 正确
解析:通过this关键字可以明确地去访问一个类的成员变量,解决与局部变量名称冲突问题。
68、
当一个类中局部变量与成员变量同名时,“this.变量名”访问的是局部变量。
答案: 错误
解析:通过this关键字可以明确地去访问一个类的成员变量,解决与局部变量名称冲突问题。
69、
当一个类中成员变量和局部变量重名时,可以使用哪个关键字进行区分( )
A、 super
B、 this
C、 public
D、 true
答案: B
解析:通过this关键字可以明确地去访问一个类的成员变量,解决与局部变量名称冲突问题。
70、下列关于静态方法的描述中,错误的是( )
A、 静态方法属于类的共享成员
B、 静态方法是通过"类名.方法名"的方式来调用
C、 静态方法只能被类调用,不能被对象调用
D、 静态方法中可以访问静态变量
答案: C
解析:静态方法可以被类调用,也可以被对象调用。
71、
静态方法必须使用【】关键字来修饰。
答案:
static
;
解析:被static关键字修饰的方法被称为静态,态方法可以使用“类名.方法名”的方式来访问,也可以通过类的实例对象来访问。
72、
垃圾回收机制保证了Java程序不会出现内存溢出。
答案: 错误
解析:垃圾回收机制只是回收不再使用的JVM内存,如果程序有严重BUG,还会出现内存溢出的情况。
73、
请阅读下面的程序,选择正确的运行结果。()
class Demo{
private static int x ;
public static void main(String[] args){
System.out.println(x++);
}
}
A、 0
B、 1
C、 无结果
D、 编译失败
答案: A
74、下列修饰符中,成员内部类被( )修饰后,可以被外界访问。
A、 default
B、 protected
C、 public
D、 private
答案: C
解析:成员内部类被public修饰后可以被外界访问,如果内部类被声明为私有,外界将无法访问。
75、
下列关于this的说法中,错误的是( )
A、 只能在构造方法中使用this调用其它的构造方法,不能在成员方法中使用
B、 在构造方法中,使用this调用构造方法的语句必须位于第一行,且只能出现一次
C、 this关键字可以用于区分成员变量与局部变量
D、 this可以出现在任何方法中
答案: D
76、
编写一个类,类中定义一个静态方法,用于求两个整数的和。
请按照以下要求设计一个测试类Demo,并进行测试。
要求如下:
1)Demo类中有一个静态方法get(int a,int b)该方法用户返回参数a、b两个整数的和;
2)在main()方法中调用get方法并输出计算结果。
答案:
public class Demo {
public static int getSum(int a","int b){
return a + b;
}
public static void main(String[] args) {
int result = Demo. getSum(2","3);
System.out.println(result);
}
}
解析:定义静态方法,类名直接调用。
77、
下面关于静态变量的描述,正确的是( )
A、 静态变量可以定义在类中的任意位置
B、 静态变量一但被赋值不能被修改
C、 静态变量可以被类直接调用,因此可以说静态变量的生命周期与实例无关
D、 以上都不对
答案: C
解析:static关键字只能修饰类的成员,不能随意使用。
静态变量的值可以被修改。
78、
下面关于静态变量的描述正确的是( )
A、 静态变量可以通过类名直接调用,因此也称类变量
B、 静态变量可以在非静态方法中使用
C、 静态变量在成员变量加载之后被加载
D、 成员变量就是静态变量
答案: AB
解析:静态变量在类加载时加载,成员变量是在静态变量之后加载。
成员变量并不是静态变量,只有使用static关键字修饰的成员变量才是静态变量。
79、
class Person {
int age;
public Person(int age) {
______________//让局部变量的age给成员变量的age赋值
}
public int getAge() {
return this.age;
}
}
在横线处填入正确的代码,可以让局部变量的age给成员变量的age赋值。
答案:
this.age = age;
;
解析:通过this关键字可以区分成员变量和局部变量重名,this.调用的是局部变量横线处应该填写的代码为this.age = age;,this.age就是成员变量,age就是局部变量,因此就可以完成局部变量age给成员变量age赋值的功能。
80、
垃圾回收器会随时将垃圾对象从内存中释放。
- 对
- 错
答案: 错误
解析:垃圾回收并不是马上运行
一个对象在成为垃圾后会暂时地保留在内存中,当这样的垃圾堆积到一定程度时,Java虚拟机就会启动垃圾回收器将这些垃圾对象从内存中释放,从而使程序获得更多可用的内存空间。
81、
静态代码块不会优先于构造代码块运行。
答案: 错误
解析:静态代码块:最早执行,类被载入内存时执行,只执行一次。没有名字、参数和返回值,有关键字static。
构造代码块:执行时间比静态代码块晚,比构造函数早,和构造函数一样,只在对象
82、静态变量只能在静态方法中使用。
答案: 错误
解析:静态变量可以被类直接调用也可以被其他静态和非静态成员调用。
静态变量可以在静态和非静态方法中使用。静态变量被所有实例共享,可以使用“类名.变量名”的形式来访问。
83、
this关键字可以在所有的方法中使用。
答案: 错误
解析:this关键字只能在成员方法、构造方法中使用,不能在静态方法中使用。
84、
阅读下列的程序
class Person{
static{
System.out.println("static");
}
Person(){
System.out.println("构造");
}
}
class Demo{
public static void main(String[] args){
Person p = new Person();
}
}
下列选项中,程序的运行结果是()
A、 输出:构造
B、 输出:static构造
C、 输出:static
D、 没有输出结果
答案: B
解析:静态代码块优先于构造方法运行。
85、
static关键字可以修饰成员变量,也可以修饰局部变量。
答案: 错误
解析:static关键字只能修饰成员变量,不能修饰局部变量。
86、
静态代码块优先于【】代码块运行。
答案:
构造
;
解析:静态代码块优先于构造代码块运行。
87、
静态方法随着类的加载而加载,随着类的消失而消失。
答案: 正确
解析:静态方法是随着类的加载而加载,随着类的消失而消失。
88、
静态代码块中可以对静态成员变量进行赋值。
答案: 正确
解析:静态代码块中可以对静态成员变量进行赋值。
89、
请阅读下面的程序
class Test {
private static String name;
static {
name = "World";
System.out.print (name);
}
public static void main(String[] args) {
System.out.print("Hello");
Test test = new Test();
}
}
下列选项中,程序运行结果是( )
A、 HelloWorld
B、 WorldHello
C、 Hello
D、 World
答案: B
解析:静态代码块是随着类的加载而加载。
90、
下列关于静态变量的描述中,错误的是( )
A、 静态变量指的是被static修饰的变量
B、 静态变量是随着类的加载而加载
C、 静态变量可以被所有的实例对象共享
D、 静态变量同成员变量一样,都需要通过实例对象来调用
答案: D
解析:静态变量是通过“类名.变量名”“方式调用的。
91、
在Java中解决成员变量与局部变量名称冲突时,可以使用【】关键字。
答案:
this
;
解析:在Java中,通过this关键字可以明确地去访问一个类的成员变量,解决与局部变量名称冲突问题。
92、
成员内部类,就是将一个类定义在另一个类的成员的位置。
答案: 正确
解析:成员内部类,就是将一个类定义在另一个类的成员的位置。
93、
public class Person {
String name = "小芳";
public Person(String name) {
name ="小兰";
}
public void show() {
this.name = "小翠";
}
public static void main(String[] args) {
Person p = new Person("小凤");
System.out.print(p.name);
p.show();
System.out.print(p.name);
}
}
A、 小兰小翠
B、 小凤小翠
C、 小芳小翠
D、 程序编码失败
答案: C
94、
与普通方法一样,构造方法也可以重载。
答案: 正确
解析:构造方法的重载,只要每个构造方法的参数类型或参数个数不同即可。
95、
阅读下面的程序,分析代码是否能够编译通过,如果能编译通过,请列出运行的结果。否则请说明编译失败的原因。
Class Dog{
private String name;
private int age;
Dog(){}
Dog(int age){
this("哈士奇",5);
}
Dog(String name,int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println("狗的名字是"+name+"年龄是"+age);
}
}
class Demo{
public static void main(String[] args){
new Dog(10).show();
}
}
答案:
狗的名字是哈士奇年龄是5
;
96、class Demo{
Demo(){
}
}
上述代码中定义了一个Demo类,下列构造方法可以存在于Demo类中的是 ( )
A、 public Demo(){}
B、 private Demo(){}
C、 Demo(int age,String name)(){}
D、 Demo(){}
答案: C
解析:构造方法可以重载。
97、
下列关于构造方法和普通方法的描述中,正确的是( )
A、 构造方法不能指定返回值类型,普通方法可以指定返回值类型
B、 构造方法中不能指定参数,而普通方法可以指定参数
C、 在同一个类中,构造方法必须位于普通方法之前
D、 构造方法能够在实例对象的同时进行初始化
答案: AD
解析:与普通方法相比,构造方法的目的是在实例对象的同时进行初始化工作,它具有如下特点:
1、 方法名与类名相同
2、 在方法名的前面没有返回值类型的声明
3、&n
98、
请阅读下面的程序,写出程序的运行结果。
Class Person {
String name;
int age;
public Person() {
}
public Person(String n) {
name = n;
}
public Person(String n, int a) {
name = n;
age = a;
}
public void show() {
System.out.println(name + “---“ + age);
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person("林青霞");
Person p3 = new Person("林青霞", 27);
p1.show();
p2.show();
p3.show();
}
}
答案:
null---0
林青霞---0
林青霞---27
;
99、
在Demo类中
public class Demo{
public Demo(){}
public void Demo(int x){}
}
构造方法Demo重载了。
答案: 错误
解析:没有重载,构造方法不能写返回值类型。
100、
定义类,实现this在构造方法之间的调用
请按照以下要求设计一个学生类Student,并进行测试。
要求如下:
1) Person类中定义一个成员变量name;
2) Person类中创建两个构造方法,其中一个构造方法是无参的,该方法中使用this关键字调用有参的构造方法,在有参的构造方法Person(String name)中使用this关键字为成员变量赋值,并输出成员变量name的值;
3) 在main()方法中创建Person对象,调用无参的构造方法。
答案:
public class Person{
private String name;
public Person(){
this(“小红”);
}
public Person(String name){
this.name = name;
System.out.println(name);
}
public static void main(String[] args) {
Person p=new Person ();
}
}
101、
下列关于构造方法的描述,错误的是( )
A、 一个类中只能定义一个空参数的构造方法
B、 一个类中可以定义多个构造方法
C、 如果在一个类中定义有参的构造方法,jvm就不会提供默认的无参构造方法
D、 构造方法的作用是用来给属性进行初始化的
答案: A
解析:在一个类中可以定义多个构造方法,只要每个构造方法的参数类型或参数个数不同即可。
102、
请阅读下面的程序,在空白处填写正确的代码,完成构造方法重载,并为成员变量赋值。
public class Person {
String name;
int age;
public Person() {
}
public ____(String n, int a) {
____ = ____;
____ = ____;
}
}
答案:
Person
;
name
;
n
;
age
;
a
;
解析:在一个类中可以定义多个构造方法,只要每个构造方法的参数类型或参
数个数不同即可。在创建对象时,可以通过调用不同的构造方法来为不同
的属性进行赋值。
103、
下面关于构造方法的调用,正确的是( )
A、 构造方法在类定义的时候被调用
B、 构造方法在创建对象的时候被调用
C、 构造方法在调用对象方法时被调用
D、 构造方法在使用对象的变量时被调用
答案: B
解析:调用构造方法创建对象
构造方法的作用是为对象中的属性赋值,在创建对象时,构造方法就会被调用。
104、
请编写一个Person类,该类有一个成员变量name,请提供无参构造方法,以及带参构造方法对name变量进行赋值。
答案:
class Person {
String name;
public Person() {
}
public Person(String n) {
name = n;
}
}
解析:Person类的无参和有参构造方法构成重载,在有参的构造方法中为全局变量name赋值。
105、
请阅读下面的程序,程序的运行结果是()。
class Person {
String name;
int age;
public Person() {}
public Person(String n, int a) {
name = n;
age = a;
}
public void show() {
System.out.print(name + "---" + age +" ");
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
Person p2 = new Person("周星驰", 27);
p2.show();
}
}
A、 null---0周星驰---27
B、 null---27周星驰---27
C、 周星驰---0null---27
D、 周星驰---27null---27
答案: A
解析:p1对象由无参构造函数创建,String类型初始值为null,int类型初始值为0。p2对象由有参构造函数创建,初始化时,传入name值为周星驰,age值为27。
106、
如果类中定义了构造方法,则系统不会自动创建默认的构造方法。
答案: 正确
解析:只要定义构造方法,默认的就不存在了
如果类中定义了构造方法,则系统不会自动创建默认的构造方法。
107、
构造方法重载后,在构造方法中可以使用this语句进行构造方法之间的调用,在重载的两个构造方法中可以使用this语句相互调用。
答案: 错误
解析:构造方法重载,不能在一个类的两个构造方法中使用this互相调用。
108、
构造方法没有返回值类型,因此不能使用【】语句。
答案:
return
;
解析:构造方法没有返回值类型,因此不能使用return语句。
109、
阅读下面的程序,分析代码是否能够编译通过,如果能编译通过,请列出运行的结果。否则请说明编译失败的原因。
Class Person{
Person(){
this.show(10);
}
public void show(){
int x = 0 ;
System.out.println(x++);
}
public void show(int x){
System.out.println(++x);
}
}
class Demo{
public static void main(String[] args){
new Person();
}
}
答案:
输出11
解析:this调用有参数成员方法。
110、
下列选项中,哪些可以定义在类中( )
A、 类
B、 成员方法
C、 构造方法
D、 成员变量
答案: ABCD
解析:类中可以定义成员变量、成员方法和构造方法,除此之外,在类中还可以定义类,在类中被定义的类是内部类。
111、
在定义一个类时,可以使用private关键字修饰该类,以防止其被外部直接访问。
答案: 错误
解析:private关键字不能修改类,会报编译错误,将一个类私有化没有任何意义。
112、
请阅读下面的程序,在空白处填写正确的代码,把Person类的所有属性全部封装起来。
public class Person{
_______ String name;
public String _______(){
return name;
}
public void _______(String n){
name = n;
}
}
答案:
private
;
getName
;
setName
;
解析:所谓类的封装是指在定义一个类时,将类中的属性私有化,即使用private关键字来修饰,私有属性只能在它所在类中被访问,为了能让外界访问私有属性,需要提供一些使用public修饰的公有方法,其中包括用于获取属性值的getXxx方法和设置属性值的setXxx方法。
113、
阅读下面的程序,分析代码是否能够编译通过,如果能编译通过,请列出运行的结果。否则请说明编译失败的原因。
Class Member{
private String name; //名字
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Demo{
public static void main(String[] args){
Member m = new Member();
m.name="张三";
System.out.println("姓名:"+m.name);
}
}
答案:
编译报错
解析:private修饰的成员只能在本类中访问,如果要设置或者获取name的属性值,必须调用setName与getName方法。
114、
Person p1 = new Person();Person p2 = p1;这两句代码创建了【】个对象。
答案:
2
;
115、
被声明为private,protected 及public 的类成员,在类外部可以被访问的成员是:()
A、 只能访问到声明为public的成员
B、 只可能访问到声明为protected和public的成员
C、 都可以访问
D、 都不能访问
答案: A
解析:声明为protected的类既能被同一包下的其它类访问,也能被不同包下该类的子类访问,声明为public的类可以被任意类访问。
116、
请阅读下面的程序代码,选择正确的运行结果( )
class Person{
void say(){
System.out.println("hello");
}
}
class Example{
public static void main(String[] args){
Person p2 = new Person();
Person p1 = new Person();
p2.say();
p1.say();
p2=null;
p2.say();
}
}
A、 输出1个hello
B、 输出2个hello后会抛出异常
C、 输出3个hello后会抛出异常
D、 不会输出hello,直接抛出异常
答案: B
解析:程序中创建了2个Person对象p1、p2,并分别调用了say()方法输出两个hello,然后将p2对象置为null,使p2对象失去了引用,因此再次使用p2对象调用say()方法时,会抛出异常。
117、
下面哪个关键字用于将类中的属性私有化( )
A、 default
B、 public
C、 private
D、 protected
答案: C
解析:将类中的属性私有化,即使用private关键字来修饰。
118、
使用等号可以为对象赋值。
答案: 错误
解析:对象是不能被赋值的,只有对象中的属性才能被赋值。
119、当系统创建该类的实例时,系统自动为成员变量分配内存空间,并在分配内存空间后,自动为成员变量指定初始值。
答案: 正确
120、
在Java语言中,String类型的成员变量的默认初始值是( )
A、 false
B、 ""
C、 0
D、 null
答案: D
解析:String类型属于引用类型,引用类型的默认初始值为null。
121、
使用java类一个计算器,计算机具备操作数1,、操作数2、操作符三个属性,还具备计算功能。要求创建计算器对象的时候不能直接对计算器的属性赋值,要把属性都封装起来。
请按照以下要求设计一个计算器类Calculator。
要求如下:
1) 计算器类有三个属性,分别是操作数1(num1)、操作数2(num2)、操作符(option)。
2) 使用封装的思想将所有属性私有化,并对外界提供共有的访问getter和setter方法。
3) 计算器类中有一个计算的方法count(),用于执行加减乘除运算。
4) 在main()方法中,创建Calculator的实例对象,并为num1和num2赋值,然后调用count()方法执行相应的运算。
答案:
public class Calculator {
private int num1;
private int num2;
private char option;
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
public char getOption() {
return option;
}
public void setOption(char option) {
this.option = option;
}
public void count(char option) {
switch (option) {
case ‘+’:
System.out.println(“num1+num2=” + (num1 + num2));
break;
case ‘-‘:
System.out.println(“num1-num2=” + (num1 – num2));
break;
case ‘*’:
System.out.println(“num1*num2=” + (num1 * num2));
break;
case ‘/’:
System.out.println(“num1/num2” + (num1 / num2));
break;
}
}
public static void main(String[] args) {
Calculator c=new Calculator();
c.setNum1(2);
c.setNum2(4);
c.count(‘*’);
}
}
解析:封装的步骤:
1.私有化私有的成员变量。
2.提供公共的方法设置与访问成员变量。
注意:提供的公共方法不
122、
在Java语言中,类是对某一类事物个体的具体描述。
答案: 错误
解析:类是对某一类事物的抽象描述、对象才是对某一类事物个体的具体描述。
123、
只有private修饰成员变量才是类的封装体现。
答案: 错误
解析:private修饰成员变量,仅仅是封装的一种体现。方法和类本身的设计其实也体现了封装的思想。
124、请阅读下面的代码
String s1=new String("abc");
String s2=s1.intern();
String s3="abc";
System.out.println(s1==s2);
System.out.println(s2==s3);
System.out.println(s1==s3);
下列选项中,程序的输出结果为()
A、 falsetruefalse
B、 falsefalsefalse
C、 falsetruetrue
D、 falsefalsetrue
答案: A
解析:intern()返回字符串对象的规范化表示形式。
125、
私有属性只能在它所在类中被访问,为了能让外界访问私有属性,需要提供一些使用public修饰的公有方法。
答案: 正确
解析:私有属性只能在它所在类中被访问,为了能让外界访问私有属性,需要提供一些使用public修饰的公有方法。
126、
下列关键字中,用于创建类的实例对象的是( )
A、 class
B、 new
C、 private
D、 void
答案: B
解析:Java中使用new关键字创建对象,class用于定义一个类,private是权限修饰符,表示表示只能在本类中访问,void表示无返回值。
127、
float类型成员变量的默认初始化值是( )
A、 0
B、 false
C、 null
D、 0.0F
答案: D
解析:实例化对象时 ,Java虚拟机会自动为成员变量进行初始化,针对不同类型的成员变量,Java虚拟机会赋予不同的初始值。float类型的默认初始值是0.0F。
128、
在Java程序中,定义类必须使用class关键字。
答案: 正确
129、
下列关于封装的描述中,正确的是( )
A、 方法和类都可以称为封装体
B、 封装隐藏了程序的实现细节,同时对外提供了特定的访问方式
C、 封装能提高代码的复用性
D、 以上说法均错误
答案: ABC
解析:根据封装的特点和作用,可以知道ABC的说法均正确。
130、
int类型的成员变量初始化值为【】。
答案:
0
;
解析:int类型的成员变量默认值为0
Java虚拟机会自动为成员变量进行初始化,针对不同类型的成员变量,Java虚拟机会赋予不同的初始值,如int类型的成员变量初始值为0,long类型的成员变量初始值为0L。
131、
请编写一个程序,该程序由两个类组成,一个Person类,一个Test类。在Person类中定义一个无参构造方法,里面输出一句话:”无参的构造方法被调用了...”。并在测试类中进行测试。
答案:
class Person {
public Person() {
System.out.println("无参的构造方法被调用了...");
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
}
}
132、
当一个对象没有任何变量引用时,它将变成垃圾对象。
答案: 正确
133、
请阅读下面的程序,在空白处填写正确的代码, 使getInstance()方法返回一个Person对象.。
public class Person{
public static _______ getInstance(){
return _____________;
}
}
答案:
Person
;
new Person();
;
解析:该方法返回的是一个Person对象,所以返回值类型应该是Person,使用类创建对象时使用“new 类名()”。
134、
下列关于类和对象的描述,错误的是( )
A、 对象是类的实例
B、 一个类只能有一个实例化对象
C、 类是对象的抽象
D、 类用于描述一组对象的共同特征和行为
答案: B
解析:类是对象的模板,对象是类的实例,一个类可以创建多个对象。
135、
请阅读下面的程序,在空白处填写正确的代码,定义一个无参构造方法。
public class Person {
public ____() {}
}
答案:
Person
;
解析:在一个类中定义的方法如果同时满足以下三个条件,该方法称为构造方法,具体如下:
构造方法的定义需要同时满足三个条件,具体如下:
1:方法名与类名相同
2:在方法名的前面没有返回值
136、
一个实例对象只能被一个变量引用。
答案: 错误
解析:一个实例对象可以被多个成员引用
137、
类与对象的关系中,【】用于描述多个对象的共同特征,它是对象的模板。【】用于描述现实中的个体,它是类的实例。
答案:
类
;
对象
;
解析:类用于描述多个对象的共同特征,它是对象的模板。对象用于描述现实中的个体,它是类的实例。
138、
请阅读下面的代码
class A{
int x;
static int y;
void fac(String s){
System.out.println(“字符串:”+s);
}
}
下列选项中描述正确的是( )
A、 x,y和s都是成员变量
B、 x是实例变量,y是类变量,s是局部变量
C、 x和y是实例变量,s是参数
D、 x,y和s都是实例变量
答案: B
解析:在方法中声明的s是局部变量,使用static关键字修饰的y是类变量,在类中定义的x是实例变量。
139、
下面选项中不是面向对象的特征的是( )
A、 封装
B、 继承
C、 多态
D、 重构
答案: D
解析:面向对象的特点主要可以概括为封装性、继承性和多态性。
140、
在类中声明的变量称为成员变量,在方法中声明的变量称为局部变量。
答案: 正确
141、
以下关于类的描述中,错误的是( )
A、 在面向对象的思想中最核心就是对象,为了在程序中创建对象,首先需要定义一个类
B、 定义类的关键字是Interface
C、 类中的方法叫成员方法,成员方法又分为实例方法与类方法
D、 类中的属性叫成员属性,成员属性又分为实例属性与类属性
答案: B
解析:定义类的关键字是class。
142、
请说一说成员变量与局部变量的区别。
答案:
1. 定义位置的区别:
1)成员变量是定义在方法之外类之内的变量","称作为成员变量(成员属性).
2)局部变量是定义在方法之内的变量。
2.生命周期的区别:
1)成员变量是随着对象的创建而存在","随着对象的消失而消失。
2)局部变量随着方法的调用执行到了创建局部变量的语句的时候存在","局部变量一旦出了自己的作用域马上从内存中消失。
3.存储位置的区别:
1)成员变量是存储于堆内存中的。
2)局部变量是存储于栈内存中的。
4. 初始值的区别:
1)成员变量有默认的初始值:
int 0
double 0.0
float 0.0f;
char ' '
String null
boolean false
2)局部变量没有默认的初始值","要先初始化才能使用。
143、
在类中定义的【】用于描述对象的行为。
答案:
方法
;
解析:类中可以定义成员变量和成员方法,其中成员变量用于描述对象的特征,也被称作属性,成员方法用于描述对象的行为,可简称为方法。
144、
Java中成员变量用于描述对象的特征,也被称作【】。
答案:
属性
;
解析:类中可以定义成员变量和成员方法,其中成员变量用于描述对象的特征,也被称作属性,成员方法用于描述对象的行为,可简称为方法。
145、
下列关于面向对象的说法中,错误的是( )
A、 面向对象思想编程,不仅增强代码了复用性,提供了开发效率,而且为程序的修改补充提供了便利。
B、 面向对象就是分析解决问题所需要的步骤,然后用函数把这些步骤一一实现,使用的时候一个一个依次调用。
C、 面向对象是把解决的问题按照一定规则划分为多个独立的对象,然后通过调用对象的方法来解决问题。
D、 面向对象虽然使程序的开发效率提高了,但是程序的处理效率相对面向过程程序要低。
答案: B
解析:面向对象是把解决的问题按照一定规则划分为多个独立的对象,然后通过调用对象的方法来解决问题,具有易维护性、质量高、效率高、易扩展性等特点。
146、
成员变量在整个类中有效,而局部变量只在定义它的方法内有效。
答案: 正确
解析:成员变量在整个类中有效,而局部变量只在定义它的方法内有效。
147、下面选项中,类的声明方式正确的是()
A、 public void AA{…}
B、 public class Move(){…}
C、 public class void number{…}
D、 public class Car{…}
答案: D
148、在Java中,提供了4种访问级别,以下访问控制级别由小到大顺序排列正确的是()
A、 private、default、protected、public
B、 default、public、protected、private
C、 private、default、public、protected
D、 protected、public、private、default
答案: A
149、在Java接口中,下列选项中属于有效的方法声明的是()
A、 public void aMethod();
B、 final void aMethod();
C、 void aMethod(){}
D、 private void aMethod();
答案: A
150、关于封装的描述,下面说法错误的是()。
A、 封装将变化隔离
B、 封装提高重用性
C、 封装提高安全性
D、 只有被private修饰才叫做封装
答案: D
151、在Java中,下面对于构造函数的描述正确的是()
A、 类必须显式定义构造函数
B、 构造函数的返回类型是void
C、 构造函数和类有相同的名称,并且不能带任何参数
D、 一个类可以定义多个构造函数
答案: D
解析:A:类可以不定义构造函数,类会自动生成一个默认的无参构造函数。 B:构造函数没有返回值类型。 C:构造函数可以有零个、一个和多个参数。
152、下面对static的描述正确的是()
A、 静态修饰的成员变量和成员方法随着类的加载而加载
B、 静态修饰的成员方法可以访问非静态成员变量
C、 静态修饰的成员可以被整个类对象所共享
D、 静态修饰的成员变量和成员方法随着类的消失而消失
答案: ACD
153、以下关于static关键字的说法正确的是()
A、 static关键字可以修饰类
B、 static关键字可以修饰成员
C、 static关键字可以修饰所有的变量
D、 static关键字可以修饰代码块
答案: BD
154、在定义一个类的时候,如果类的成员被private所修饰,该成员不能在类的外部被直接访问。
答案: 正确
解析:如果类的成员被private访问控制符修饰,则这个成员只能被该类的其它成员访问,其它类无法直接访问。类的良好封装就是通过private关键字实现的。
155、Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。
答案: 正确
解析:Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。
156、构造方法不可以被继承。
答案: 正确
解析:构造方法不可以被继承,因为如果子类继承了父类的构造方法,父类的构造在子类中不符合构造方法的规则,也不符合一般方法的规则。父类的构造在子类中没有返回类型,方法名也与子类的类名不相同。不符合java语法规范。
157、类中static修饰的变量或方法,可以使用类名或对象的引用变量访问。
答案: 正确
158、在静态方法内可以调用非静态方法。
答案: 错误
159、静态代码块会随着类对象的创建而创建。
答案: 错误
160、在非静态成员方法中,可以使用关键字【】访问其他非静态成员。
答案:
this
;
161、面向对象的三大特征是【】、【】和【】。
答案:
封装性
;
继承性
;
多态性
;
162、类与对象的关系中,【】用于描述多个对象的共同特征,它是对象的模板。
答案:
类
;
163、在类中定义的【】用于描述对象的行为。
答案:
方法
;
164、【】是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体。
答案:
类
;
165、被static关键字修饰的成员变量被称为【】,它可以被该类所有的实例对象共享。
答案:
静态变量
;
166、Person p1 = new Person();Person p2 = p1;这两句代码创建了【】个对象。
答案:
2
;
167、一个类中可以定义多个构造方法,只要每个构造方法的【】或【】不同,即可实现重载。
答案:
参数
;
参数个数
;
168、在Java中,针对类、成员方法和属性提供了四种访问级别,分别是public、【】、【】和【】。
答案:
private
;
default
;
protected
;
169、所谓类的封装是指在定义一个类时,将类中的属性私有化,即使用【】关键字来修饰。
答案:
private
;
170、在一个类的内部嵌套定义的类称为【】。
答案:
内部类
;
171、类的封装是指在定义一个类时,将类中的属性私有化,即使用【】关键字来修饰。
答案:
private
;
172、构造方法的名称必须和【】保持一致。
答案:
类名
;
173、如果一个方法没有返回任何值,则该方法的返回值类型为【】。
答案:
void
;
174、this关键字可以访问一个类的【】变量,解决与局部变量名称冲突的问题。
答案:
成员
;