javaSE第一次测试——一个月后截止面向对象

JavaSE综合测试题
选择题: 322=64分
问答题: 133=39 分
编程题: 4*5=20 分
总分 123
及格分数 74
一:不定项选择题(每题2分)

1. 在JAVA中，下列哪些说法是正确的（ AC）
   A．java源文件的扩展名为.java
   B．写好的java源程序可以直接运行
   C．编写的源程序必须先编译后才能运行
   D．程序员可以读懂扩展名为.class的文件

2. 下列标识符哪个是合法的（BD）
   A．class
   B．$abc
   C．1234
   D．_name

3. 下面哪些赋值语句是正确的?(AC)
   A. long test = 012;
   B. int other = (int) true;
   C. double d = 0x12345678;
   D. byte b = 128;

4. 在Java中，下列语句不能通过编译的有( BD)
   A. String s= “join”+ 3;
   B. int a= “join”+3;
   C. int a= ‘a’+5;
   D. float f=5+5.5;

5. 下列代码运行的结果是( C)
   public static void main(String[] args) {
   int x = 4;
   int y = 5;
   if(x++>4 & ++y>5) { //X=5,Y=6
   x++;
   }
   System.out.println(“x=” + x + “,y=” + y);
   }
   A. x=4,y=5
   B. x=4,y=6
   C. x=5,y=6
   D. x=6,y=6

6. 尝试运行下面的代码会发生什么？( B)
   public class Test {
   public static void main(String[] args) {
   boolean m = true;
   if (m = false) {
   System.out.println(“true”);
   } else {
   System.out.println(“false”);
   }
   }
   }
   A. 输出字符串”true”
   B. 输出字符串”false”
   C. 编译时错误
   D. 运行时错误

7. 编译并运行以下代码将发生什么？ （A ）
   public static void main(String args[]){
   char digit = ‘a’;
   for (int i = 0; i < 10; i++){
   switch (digit)
   {
   case ‘x’ :
   {
   int j = 0;
   System.out.println(j);
   }
   default :
   {
   int j = 100;
   System.out.println(j);
   }
   }
   }
   int i = j;
   System.out.println(i);
   }
   A. 输出11次100
   B. 输出10次100，然后抛出运行期异常
   C. 编译错误，因为变量i不能在main() 方法中被声明2次
   D. 编译错误，因为变量j不能在main() 方法中被声明2次
   E. 以上都不对

8. 下面代码的输出结果是(B)
   class Demo
   {
   public static int fun(int c)
   {
   return c+=2;
   }
   public static void main(String[] args)
   {
   int temp = fun(2);
   System.out.println(temp);
   }
   }
   A. 2
   B. 4
   C. 6
   D. 8

9. 下面哪些函数是public void aMethod(){…}的重载函数?( BD)
   A. void aMethod( ){…}
   B. public int aMethod(int a, float b){…}
   C. public void aMethod (){…}
   D. public float aMethod (int m){…}

10. 在java中，关于数组描述正确的是（B D）
    A．数组中的索引下标从1开始
    B．存储在数组当中的数据都属于同一数据类型
    C．通过数组名.length()能获得数组的长度
    D．数组的最大索引下标是数组的长度减1

11. 下面程序的输出结果是什么(D )
    int[] arr = new int[10];
    System.out.println(arr[0]);
    A．编译不通过
    B．运行时出错
    C．输出null
    D．输出0

12. 下面哪个语句正确地声明一个整型的二维数组( C)
    A. int a[][] = new int[][];
    B. int b[10][10] = new int[][];
    C. int c[][] = new int[10][10];

13. 以下代码输出是（ D ）
    class Demo {
    public static void main(String[] args) {
    int i = 0;
    int sum = 0;
    while (i <= 10) {
    i++;
    if (i % 2 != 0)
    continue;
    sum += i;

}
System.out.println(sum);
}
}
A. 55
B. 45
C. 35
D. 30
14. 和下面代码能完成相同的选项是（B）
class Demo {
public static void main(String[] args) {
int i = 1;
int sum = 0;
while (i <= 100) {
if (i % 2 == 0) {
sum = sum + i;
}
i++;
}
System.out.println(sum);
}
}
A. for (int x =1; x<=100;x++){ sum=sum+x;}
B. for (int x =0; x<=100;x+=2){ sum=sum+x;}
C. for (int x =1; x<=100;x+=2){ sum=sum+x;}
D.上述全对
15. 下列有关类、对象和实例的叙述，正确的是哪一项？(D)
A．类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别
B．对象是类的抽象，类是对象的具体化，实例是对象的另一个名称
C．类是对象的抽象，对象是类的具体化，实例是类的另一个名称
D．类是对象的抽象，对象是类的具体化，实例是对象的另一个名称
16. 下面关于java中包的说法正确的是( ACD)
A. 在java中可以使用import语句导入包
B. 在java中可以使用package语句导入包
C. 位于同一个包中的类，不需要导包就可以直接访问
D. 不同的包中可以出现类名相同的类
17. 下列有关抽象类的叙述正确的是哪项？©
A．抽象类中一定含有抽象方法
B．抽象类既能被实例化也能被继承
C．抽象类的声明必须包含abstract关键字
D．抽象类中不能有构造方法
18. 下列有关接口的叙述错误的是哪项？(AD)
A．接口中只能包含抽象方法和常量 （注意JDK1.8有默认方法）
B．一个类可以实现多个接口
C．类实现接口时必须实现其中的方法
D．接口不能被继承

19. 下列关于类的继承的描述，正确的有（ BD ）
    A. 一个类可以同时继承多个父类
    B. 一个类可以具有多个子类
    C. 子类会自动拥有父类所有的方法
    D. 一个类继承另一个类需要使用 extends 关键字

20. 下列选项中关于java中this关键字的说法错误的有( C )
    A. this关键字是一个对象的引用
    B. this可用于构造函数中，调用类本身重载的构造函数，但是必须写在首行
    C. this可用于静态方法中

21. 下列关于构造函数的说法正确的是(A B )
    A. 方法名必须与类名相同
    B. 使用new关键字创建对象时，java虚拟机会自动调用构造函数
    C. 我们在定义一个类时，必须要声明至少一个构造函数
    D. 构造函数中不能使用return语句(这个是错的，可以rutrun;)

22. 编译并运行以下代码将发生什么？(D )
    class MyClass {
    int x;
    MyClass(int i) {
    x = i;
    }
    public static void main(String args[]) {
    MyClass m1 = new MyClass(100);
    MyClass m2 = new MyClass(100);
    if (m1.equals(m2)) {
    System.out.println(“Both are equal”);
    } else {
    System.out.println(“Both are not equal”);
    }
    }
    }
    A. 代码编译时报出错误提示信息“equals() 方法未定义”
    B. 编译通过，抛出运行期异常.
    C. 输出Both are equal.
    D. 输出Both are not equal

23. 运行以下的main()方法，结果是？（ C）
    1 public static void main(String[] args)
    2 {
    3 String myString;
    4 int x = 100;
    5
    6 if (x < 100) myString = “x is less than 100”;
    7 if (x > 100) myString = “x is greater than 100”;
    8 System.out.println(myString.length());
    9 }
    A． 编译时报出错误提示信息“变量myString没有被初始化”
    B． 编译通过
    C． 编译未能通过。但如果变量myString在第8行前的代码中被初始化，代码可以编译通过，运行时可以输出字符串myString的长度
    D． 以上都不对

24. 关于继承, 以下说法正确的是: (AD)
    A．Java中只支持单继承, 一个类只能继承一个类, 但是可以有多个子类
    B．一个类如果没有自己写无参构造方法, 那么子类将无法继承
    C．子类可以当父类用, 父类不可以当子类用
    D. 子类重写父类方法时访问权限不能更低
    25.下列关于修饰符混用的说法，错误的是（ D）：
    A．abstract不能与final并列修饰同一个类
    B．abstract类中可以有private的成员
    C．abstract方法必须在abstract类中
    D．static方法中能处理非static的属性

26.执行完以下代码int [ ] x = new int[25]；后，以下哪项说明是正确的（ A）：
A、 x[24]为0
B、 x[24]未定义
C、 x[25]为0
D、 x[0]为空
27.编译运行以下程序后，关于输出结果的说明正确的是 （ C）：
public class Conditional{
public static void main(String args[ ]){
int x=4;
System.out.println(“value is “+ ((x>4) ? 99.9 :9));
}
}
A、 输出结果为：value is 99.99
B、 输出结果为：value is 9
C、 输出结果为：value is 9.0
D、 编译错误
28.关于以下代码的说明，正确的是（C ）：
class StaticStuff {
static int x=10；
static {
x+=5；
}
public static void main（String args[ ]）{
System.out.println(“x=” + x);
}
static {
x/=3;
}
}
A、 4行与9行不能通过编译，因为缺少方法名和返回类型
B、 9行不能通过编译，因为只能有一个静态初始化器
C、 编译通过，执行结果为：x=5
D、编译通过，执行结果为：x=3
29.关于以下程序代码的说明正确的是（D ）：
1．class HasStatic{
2． private static int x=100；
3． public static void main(String args[ ]){
4． HasStatic hs1=new HasStatic( );
5． hs1.x++;
6． HasStatic hs2=new HasStatic( );
7． hs2.x++;
8． hs1=new HasStatic( );
9． hs1.x++;
10． HasStatic.x–;
11． System.out.println(“x=”+x);
12． }
13．}
A、5行不能通过编译，因为引用了私有静态变量
B、10行不能通过编译，因为x是私有静态变量
C、程序通过编译，输出结果为：x=103
D、程序通过编译，输出结果为：x=102
30.下列说法正确的有（C）
A． class中的constructor不可省略
B． constructor必须与class同名，但方法不能与class同名
C． constructor在一个对象被new时执行
D．一个class只能定义一个constructor
31.下列哪种说法是正确的（AD）
A．实例方法可直接调用超类的实例方法
B．实例方法可直接调用超类的类方法
C．实例方法可直接调用其他类的实例方法
D．实例方法可直接调用本类的类方法
32.下列哪一种叙述是正确的（D ）
A． abstract修饰符可修饰字段、方法和类
B． 抽象方法的body部分必须用一对大括号{ }包住
C． 声明抽象方法，大括号可有可无
D． 声明抽象方法不可写出大括号
二 问答题(每题3分)
1、 1.一个".java"源文件中是否可以包括多个类（不是内部
类）？有什么限制？
可以有多个类，但只能有一个 public 的类，并且 public 的类名必须与文件名相一致。
2、 Java 有没有 goto?
java 中的保留字，现在没有在 java 中使用。
3、说说&和&&的区别。
&和&&都可以用作逻辑与的运算符，表示逻辑与（ and），当运算符两边的表达式的结果都为 true 时，
整个运算结果才为 true，否则，只要有一方为 false，则结果为 false。
&&还具有短路的功能，即如果第一个表达式为 false，则不再计算第二个表达式，例如，对于 if(str != null
&& !str.equals(“”))表达式，当 str 为 null 时，后面的表达式不会执行，所以不会出现 NullPointerException
如果将&&改为&，则会抛出 NullPointerException 异常。 If(x33 & ++y>0) y 会增长， If(x33 && ++y>0)
不会增长
&还可以用作位运算符，当&操作符两边的表达式不是 boolean 类型时， &表示按位与操作，我们通常
使用 0x0f 来与一个整数进行&运算，来获取该整数的最低 4 个 bit 位，例如， 0x31 & 0x0f 的结果为 0x01。
备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解
透彻深入、实际经验丰富。
4、在 JAVA 中如何跳出当前的多重嵌套循环？
在 Java 中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中
使用带有标号的 break 语句，即可跳出外层循环。例如，
ok:
for(int i=0;i<10;i++) {
for(int j=0;j<10;j++) {
System.out.println(“i=” + i + “,j=” + j);
if(j == 5) break ok;
}
}
另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体
代码的控制，例如，要在二维数组中查找到某个数字。
int arr[][] = {{1,2,3},{4,5,6,7},{9}};
boolean found = false;
for(int i=0;i<arr.length && !found;i++) {
for(int j=0;j<arr[i].length;j++){
System.out.println(“i=” + i + “,j=” + j);
if(arr[i][j] == 5) {
found = true;
break;
}
}
}
5、 switch 语句能否作用在 byte 上，能否作用在 long 上，能
否作用在 String 上?
2、 String 类型可以 JDK1.7
在 switch（ expr1）中， expr1 只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是 int
基本类型或 Integer 包装类型，由于， byte,short,char 都可以隐含转换为 int，所以，这些类型以及这些类型
的包装类型也是可以的。显然， long 和并且不能被隐式转换成 int
类型，所以，它们不能作用于 swtich 语句中。

3、
6、 short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;
有什么错?
对于 short s1 = 1; s1 = s1 + 1; 由于 s1+1 运算时会自动提升表达式的类型，所以结果是 int 型，再赋值
给 short 类型 s1 时，编译器将报告需要强制转换类型的错误。
对于 short s1 = 1; s1 += 1;由于 += 是 java 语言规定的运算符， java 编译器会对它进行特殊处理，因此
可以正确编译。
7、 char 型变量中能不能存贮一个中文汉字?为什么?
char 型变量是用来存储 Unicode 编码的字符的， unicode 编码字符集中包含了汉字，所以， char 型变量
中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在 unicode 编码字符集中，那么，这个 char
型变量中就不能存储这个特殊汉字。补充说明： unicode 编码占用两个字节，所以， char 类型的变量也是占
用两个字节。
备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解
的透彻深入，可以回答一些相关的知识，做到知无不言， 言无不尽。
8、用最有效率的方法算出 2 乘以 8 等於几?
2 << 3，
因为将一个数左移 n 位，就相当于乘以了 2 的 n 次方，那么，一个数乘以 8 只要将其左移 3 位即可，
而位运算 cpu 直接支持的，效率最高，所以， 2 乘以 8 等於几的最效率的方法是 2 << 3。
9、使用 final 关键字修饰一个变量时，是引用不能变，还
是引用的对象不能变？
使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改
变的。例如，对于如下语句：
final StringBuffer a=new StringBuffer(“immutable”);
执行如下语句将报告编译期错误：
a=new StringBuffer("");
但是，执行如下语句则可以通过编译：
a.append(" broken!");
有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：
public void method(final StringBuffer param){
}
实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
param.append(“a”);
10、 ""和 equals 方法究竟有什么区别？
（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则
很难说清楚）
操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是
否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆
内存），变量也占用一块内存，例如 Objet obj = new Object();变量 obj 是一个内存， new Object()是另一个内
存，此时，变量 obj 所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的
变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这
时候就需要用操作符进行比较。
equals 方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较
的两个对象是独立的。例如，对于下面的代码：
String a=new String(“foo”);
String b=new String(“foo”);
两条 new 语句创建了两个对象，然后用 a,b 这两个变量分别指向了其中一个对象，这是两个不同的对
象，它们的首地址是不同的，即 a 和 b 中存储的数值是不相同的，所以，表达式 ab 将返回 false，而这
两个对象中的内容是相同的，所以，表达式 a.equals(b)将返回 true。
在 实 际 开 发 中 ， 我 们 经 常 要 比 较 传 递 进 行 来 的 字 符 串 内 容 是 否 等 ， 例 如 ， String input
= …;input.equals(“quit”)，许多人稍不注意就使用进行比较了，这是错误的，。记住，字符串的比较基本上都是使用 equals 方法。
如果一个类没有自己定义 equals 方法，那么它将继承 Object 类的 equals 方法， Object 类的 equals 方法
的实现代码如下：
boolean equals(Object o){
return thiso;
}
这说明，如果一个类没有自己定义 equals 方法，它默认的 equals 方法（从 Object 类继承的）就是使
用操作符， 也是在比较两个变量指向的对象是否是同一对象，这时候使用 equals 和使用==会得到同样的
结果，如果比较的是两个独立的对象则总返回 false。 如果你编写的类希望能够比较该类创建的两个实例对
象的内容是否相同，那么你必须覆盖 equals 方法， 由你自己写代码来决定在什么情况即可认为两个对象的
内容是相同的。
11静态变量和实例变量的区别？
在语法定义上的区别：静态变量前要加 static 关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被
分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只
要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个 staticVar 变量，并且每创建
一个实例对象，这个 staticVar 就会加 1；但是，每创建一个实例对象，就会分配一个 instanceVar，即可能
分配多个 instanceVar，并且每个 instanceVar 的值都只自加了 1 次。
public class VariantTest{
public static int staticVar = 0;
public int instanceVar = 0;
public VariantTest(){
staticVar++;
instanceVar++;
System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
}
}
备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了
自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！
12、是否可以从一个 static 方法内部发出对非 static 方法的
调用？
不可以。因为非 static 方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方
法调用，而 static 方法调用时不需要创建对象，可以直接调用。也就是说，当一个 static 方法被调用时，可
能还没有创建任何实例对象，如果从一个 static 方法中发出对非 static 方法的调用，那个非 static 方法是关
联到哪个对象上的呢？这个逻辑无法成立，所以，一个 static 方法内部发出对非 static 方法的调用。
13接口是否可继承接口? 抽象类是否可实现(implements)
接口? 抽象类是否可继承具体类(concrete class)? 抽象类中
是否可以有静态的 main 方法
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承具体类。抽象类中可以有静
态的 main 方法。
备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是 java 语言的
设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就
是肯定的了。
只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有 abstract 方法。
三: 编程题(共4道题每题5分)

1. 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问12个月后的兔子总数为多少？
   2 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是1岁。请问第五个人多大？
   public class lianxi23 {
   public static void main(String[] args) {
   int age = 1;
   for(int i=2; i<=5; i++) {
   age =age+2;
   }
   System.out.println(age);
   }
   }
   3题目:
   小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。
   int sum = 100;// 最终的目标
   double db = 2.5;// 每次存放的钱数
   int day = 1;// 天数
   double dsum = 0;// 每次存放的总数
   while (true) {
   dsum = dsum + db;// 返回每天都存放钱的总和
   if (day % 5 == 0) {// 判断是不是5的倍数
   dsum = dsum - 6;// 从总数中扣去6元
   System.out.println(“第” + day + “天花去6元，还剩” + dsum + “元！”);
   }
   boolean flag = dsum >= sum;// 求dsum是否大于sum的boolean值
   if (flag) { // 如果是true则输出最终的结果，并跳出循环
   System.out.println(“要经过连续存储” + day + “天，才能存上100元！”);
   break;
   } else {// 否则天数加1，也就是继续存钱
   day++;
   }
   }

题目4:
求 s=a+aa+aaa+aaaa+aa…a 的和,其中a是一个数字,例如
2+22+222+2222+2…2 最大有几个2由键盘录入得到
例如提示用户 请输入你要求和的数字
用户输入的是3
请输入你要的最大的数字个数
用户输入的是5
那么就是求 3+33+333+3333+33333 的和
请编写程序实现
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入你要求和的数字”);
int a = scanner.nextInt();
System.out.println(“请输入你要的数字的最大个数”);
int n = scanner.nextInt();
int sum=0;
int b=0;
for (int i = 0; i <n; i++) {
b+=a;
sum+=b;
a=a*10;
}
System.out.println(sum);
}