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关键字可以访问一个类的【】变量，解决与局部变量名称冲突的问题。
答案：
成员
；
497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
