1.关于Java源代码文件，下列说法错误的是？
A.一个源文件最多只能包含一个顶层的public类定义
B.一个源文件可以不包含任何代码定义。即它是一个空文件，编译时不会产生编译错误，一个包含类定义的最小源文件内容仅为class classname{}
C.在一个原文件中，如果存在一个顶层的public类定义，则该源文件名必须与顶层的public类名一致，如果源文件中没有一个顶层的public类，则该源文件名可以随意命名，不需要与原文件中定义的任何类名一致，只要符合Java语言标示符规范即可
D.通过通配符*号引入的两个不同包中存在同名的类，当代码中不加包名直接使用时，使用的是先引入包中的类
答案 D
答案解析：
通过通配符*号引入的两个不同包中存在同名的类，当代码中不加包名直接使用时，会产生编译错误，使用时需要提供完整包路径
2.为了使一个名为MyClass的public类成功编译，需要满足一下哪个条件？
A.MyClass类中必须定义一个正确的main()方法
B.MyClass类必须定义在MyClass.java源文件中
C.MyClass类必须定义在MyClass包中
D.MyClass类必须被引入
答案：B
答案解析：
源代码文件名需与public类保持一致
3.一下哪个关键字不能用于顶层类？
A.public
B.private
C.abstract
D.final
答案：B
答案解析：
顶层类的访问修饰符关键字只有public
4.下列哪项不是int类型的字面量？
A.\u03A6
B.077
C.0xABBC
D.’20
答案：A
答案解析
\u为Java中Unicode编码前缀
5.执行下列语句后，变量i的值是：
byte i = 127;
i += 1;
A.128
B.0
C.-1
D.-128
答案：D
答案解析：
byte的长度为8位，表示的范围为-128~127，由于补码的特性，因此127加1后变成了-128
6、如下类Student，内省机制会认为该类有哪些属性（不考虑class属性）？（B）
public class Student{
private String stuName;
private double stuAge;
public void setStuAge(int stuAge){
this.stuAge=stuAge;
}
}
A、stuName
B、stuAge
C、stuName以及stuAge
D、没有属性
7.char类型的取值范围是？
A.0-2^16
B.0-2^16-1
C.-2^15-2^15
D.0-2^15-1
答案：B
答案解析：
char是唯一一种无符号整数类型
8.以下哪个是10进制数123的正确的十六进制表示？
A.0x67
B.0x123
C.0x7B
D.67
答案：C
答案解析：
十六进制以0x为前缀
9.以下哪个是10进制数124的正确的八进制表示？
A.0173
B.0185
C.0x185
D.0x173
答案：A
答案解析：八进制以0为前缀
10.以下给出代码运行后的结果是？
public class Example {
public static void main(String[] args) {
int[] refToArray = { 10, 11 };
int var = 1;
refToArray[var - 1] = var = 2;
System.out.println(refToArray[0] + " " + refToArray[1]);
}
}
A.编译失败
B.编译通过，但运行时提示异常
C.2 11
D.10 2
答案：C
答案解析：
运算顺序从左至右，赋值顺序从右至左
11.以下给出代码运行后的结果是？
public class Example {
public static void main(String[] args) {
int x=1;
int y=~x+1;
System.out.println(x+" "+y);
}
}
A.打印输出-1 1
B.打印输出1 1
C.打印输出1 -1
D.打印输出-1 -1
C
12.表达式(short)10/10.2*2运算后结果是什么类型？
A.short
B.int
C.double
D.float
C
13.一下代码运行输出结果是？
public class Example {
public static void main(String[] args) {
System.out.println(3.0/0);
}
A.编译失败
B.运行时抛出异常
C.0
D.打印输出Infinity
答案：D
答案解析：
浮点数有无限值和NaN的概念，因此非法表达式3.0/0并不会抛出算术异常，而是输出Infinity(无穷大)常量
14.对以下两个代码片段说法正确的是？
代码片段1：
int a = 3;
int b = 0;
int c = a / b;
代码片段2：
float a = 3.0f;
float b = 0.0f;
float c = a / b;
A.执行两端代码都会抛出异常
B.执行两段代码都无异常抛出
C.执行两段代码，只有代码片段1抛出异常
D.执行两段代码，只有代码片段2抛出异常
答案：C
15.下面的代码段中，执行之后i 和j 的值是什么?
int i = 1;
int j;
j = i++;
A.1，1
B.1，2
C.2，1
D.2，2
答案：C
16.以下代码的执行结果是：
public class Example {
public static void main(String[] args) {
byte x = -64;
byte y = -6;
System.out.println(x / y + " " + x % y);
}
}
A.编译失败
B.运行时抛出异常
C.10 4
D.10 -4
答案：D
解析：取模运算结果符号完全取决于表达式中的左操作数（和左操作数的正负符号保持一致）
17.下列代码执行后的结果是？
public class Example {
public static void main(String[] args) {
try {
double x = 64.0;
double y = 0.0;
System.out.println(x % y);
} catch (Exception e) {
System.out.println("Exception");
}
}
}
A.编译失败
B.输出Exception
C.输出Infinity
D.输出NaN
答案：D
答案解析：取模运算中，如果除数为0，整数取模运算会抛出算数异常，而浮点取模运算则输出NaN值
18.下列代码执行后的结果是？
public class Example {
public static void main(String[] args) {
try {
double x = 64.0;
double y = 0.0;
System.out.println(x % y == x % y);
} catch (Exception e) {
System.out.println("Exception");
}
}
}
A.编译失败
B.运行时抛出异常
C.打印输出true
D.打印输出false
答案：D
答案解析：NaN值是一个封装在Float和Double类中的一个代表非正常数字结果的常量，用于逻辑运算中和任何值（包括自身）比较的结果都为false
19.下列代码执行后的结果是？
public class Example {
public static void main(String[] args) {
try {
System.out.println(Float.NaN == Float.NaN);
System.out.println(Float.POSITIVE_INFINITY==Float.POSITIVE_INFINITY);
} catch (Exception e) {
System.out.println("Exception");
}
}
}
A.输出+G20:J20false false
B.输出Exception
C.输出true true
D.输出false true
答案：D
答案解析：Infinity和NaN不同，是一个特定的特殊数值，可以进行正常的比较运算
20.下列代码执行结果是？
public class Example {
public static void main(String[] args) {
String str = "123";
String str1 = new String("123");
String str2 = "123";
System.out.println(str == str1);
System.out.println(str == str2);
}
}
A.输出true true
B.输出true false
C.输出false false
D.输出false true
答案：D
答案解析：字符串存在常量池，但是new运算符会忽略常量池操作
21.下列代码在JDK1.5以上版本执行的结果是？
public class Example {
public static void main(String[] args) {
Integer i = 10;
Integer j = 10;
System.out.println(i == j);
i = 210;
j = 210;
System.out.println(i == j);
}
}
A.抛出异常
B.输出true false
C.输出true true
D.输出false false
答案：B
答案解析：128以内的数进行自动封箱会激发对象池操作
22.给出以下代码，假设arr数组中只包含正整数值，请问下列代码段实现了什么功能？
public int guessWhat(int arr[]) {
int x = 0;
for (int i = 0; i < arr.length; i++) {
x = x < arr[i] ? arr[i] : x;
}
return x;
}
A.获取数组的最大索引值
B.判断数组中是否存在重复元素
C.获取数组中元素个数
D.获取数组中的最大元素
答案：D
23.以下代码执行后，x的值为
public class Example {
public static void main(String[] args) {
int x = 0;
boolean b1, b2, b3, b4;
b1 = b2 = b3 = b4 = true;
x = (b1 | b2 & b3 ^ b4) ? x++ : -x;
System.out.println(x);
}
}
A.-1
B.0
C.1
D.编译出错
答案：B
24.有int变量i的值为16384，1>>33的结果为？
A.运算数不符合运算符要求
B.0
C.8192
D.-1
答案：C
25.以下程序运行的结果是：
public class Example {
public static void main(String[] args) {
System.out.println("String".replace('g', 'G') == "String".replace('g','G'));
System.out.println("String".replace('t', 't') == "String".replace('t','t'));
}
}
A.输出true true
B.输出true false
C.输出false false
D.输出false true
答案：D
答案解析：字符串替换了文字后变成了新的对象，没有内容替换操作，对象保持不变
26.如果有int变量i和j，i的值为0xFFFFFFF1,j=~I,则j的值为？
A.0
B.1
C.14
D.-15
答案：C
答案：解析
27.下列给出代码的运行结果是？
public class Example {
public static void main(String[] args) {
int m = 2;
int p = 1;
int i = 0;
for (; p < 5; p++) {
if (i++ > m) {
m = p + i;
}
}
System.out.println("i equals " + i);
}
}
A.i equals 2
B.i equals 4
C.i equals 6
D.i equals 7
答案：B
28.下列说法正确的是？
A.Java循环使用continue和break语句控制循环执行，使用goto语句和语句标签跳出多层循环
B.for循环中初始化条件和循环迭代都可以省略，循环条件需要始终提供一个boolean值
C.语句标签不是变量，所以不用遵循Java标识符命名规则
D.在while循环中使用continue可能会导致死循环
答案：D
29.1) 设有程序如下
public class Delta
{
static boolean foo(char c)
{
System.out.print(c);
return true;
}
public static void main(String[] argv)
{
int i = 0;
for (foo('A'); foo('B') && (i < 2); foo('C'))
{
i++;
foo('D');
}
}
}
则程序运行结果是？
A.ABDCBDCB
B.ABCDABCD
C.程序编译时出错
D.程序运行时产生运行时异常
答案：A
30.对于以下说法，哪些是正确的？
A.如果package语句存在，则必须出现在源文件的非空白首行
B.如果import语句存在，则必须出现在源文件的非空白首行
C.如果main()方法存在，则必须出现在源文件的非空白首行
D.如果在原文件中声明了一个public接口，则其名称必须和源文件名一致
答案：A，D
答案解析：在存在package顶层元素时，import语句必须位于package顶层元素之后
31.以下哪些是Java中的关键字？
A.run
B.default
C.implement
D.import
答案：B、D
答案解析：Java中未定义run关键字，implement的正确形式应该为implements
32.下面哪个赋值语句是合法的
A.float a = 2.0
B.double b = 2.0
C.int c = 2
D.long d = 2
答案：B、C、D
33.现有3个变量boolean a，boolean b，int c，请问以下哪些表达式合法
A.（a|b）
B.（a||b）
C.（a^b）|c
D.(a&c)||(a&&c)
答案：A、B
34.如果有String s=null,以下代码哪些选项会产生异常？
A.（s!=null）&(s.length()>0)
B.(s!=null)&&(s.length()>0)
C.(s==null)|(s.length==0)
D.(s==null)||(s.length()==0)
答案：A、C
答案解析：短路逻辑运算
35.下面的表达式哪个是正确的
A.String s="你好";int i=3; s+=i;
B.String s="你好";int i=3; if(i==s){ s+=i};
C.String s="你好";int i=3; s=i+s;
D.String s=null; int i=(s!=null)&&(s.length>0)?s.length():0;
答案：A、C
36.以下哪些赋值表达式合法？（变量S为一个字符串）
A.s>>=2
B.int i=s.length()
C.s+=3
D.char c=s[3]
答案：B、C
37.以下代码错误在何处？
public class Example {
public static void main(String[] args) {
for(int i=0;j=0,i<10;++i,j+=i){
j+=i*i+j*j;
}
}
}
A.在语句块中应超过一条以上语句
B.在i=0和j=0之间应使用逗号
C.使用了两个循环变量
D.在j=0和i<10之间应使用分号
答案：B、D
38.对于switch/case语句以下说法正确的有
A.default语句是可选的，但是如果出现default则必须位于所有的case后面
B.case子句后面的值必须是常量，且不可重复
C.switch后面的表达式的值如果是数值型，则必须是可精确匹配的整数值，如int\long，而不能是浮点数
D.case后面的break是可选的，若省略break，程序将继续往下执行，直到switch语句结束或遇到其他的break
答案：B、D
39.方法与参数
1. 指出下列程序运行的结果
public class Example{
String str=new String("good");
char[]ch={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
for(int i=0;i<ex.ch.length;i++){
System.out.print(ex.ch[i]);
}
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='g';
}
}
A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc
答案：D
40.下列说法错误的是？
A.尽管现行的Java语言版本不允许类的多继承，但是我们仍然可以在extends关键字后面放置一个列表
B.在实现多态后，利用父类引用（声明时类型）调用父类子类均声明了的变量和方法，均调用在子类中声明的版本
C.Java中代码重用中的has a关系通过定义类属性方式实现，is a通过类继承来实现
D.this关键字代表当前对象，即this引用的是当前创建的类实例对象的句柄
答案：B
答案解析：利用声明时类型调用父类和子类同时声明的属性时，调用方法是子类（运行时类型）声明的，而变量则是调用父类（声明时类型）声明的
41.以下哪个是有关封装优点的正确描述？
A.只需要一个public方法
B.从任何方法中没有异常抛出
C.可以不需要改变接口来改变实现，以达到外部使用代码无需变动
D.可以不需要改变实现来改变接口，已达到外部使用代码无需变动
答案：C
答案解析：封装把实现细节隐藏起来了，因此封装可以实现对类内部的改变不会影响到其他代码
42.以下说法错误的是？
A.Java中接口不能被private或Protected修饰符修饰
B.Java中一个类可以实现多个接口，但是只能继承一个父类
C.接口中定义的成员变量，即使不说明，默认均是public\static\final的
D.final\static\native关键字不能修饰接口，
答案：D
答案解析：内部接口可以用static修饰
43.给出以下代码，请问以下哪个描述是正确的？Public XXXX extends something1,something2
A.如果XXXX是一个接口，something1和something2取消掉，则代码段合法
B.如果XXXX是一个类，something1和something2均是接口，则代码段合法
C.如果XXXX、something1和something2均是接口，则代码段合法
D.因为Java语言不支持多继承机制，所以代码段不合法
答案：C
44.请问以下哪个程序代码体现了对象之间的is a关系？
A.public interface Color {
}
public class Shape {
private Color color;
}
B.public interface Component {
}
public class Cpmtaomer implements Component {
private Component[] children;
}
C.public class Species{
}
public class Animal{
private Species species;
}
D.public class Animal{
public interface Species{
}
private Species species;
}
答案：B
45.给出以下代码，改程序的执行结果是？
interface Base {
int k = 0;
}
public class Example implements Base {
public static void main(String[] args) {
int i;
Example exm = new Example();
i = exm.k;
i = Example.k;
i = Base.k;
System.out.println(i);
}
}
A.无内容输出
B.代码编译失败
C.代码运行时输出异常信息
D.打印输出0
答案：D
答案解析：变量K为接口中定义的一个静态常量，可以使用类名调用，也可以使用实例名调用
46.给出下面代码，请问该程序的运行结果是什么？
interface A{
int x=0;
A(){
x=5;
}
A(int s){
x=s;
}
}
A.编译不通过，因为接口中的构造器必须用public修饰
B.编译不通过，因为接口中不能超过一个以上的构造器
C.编译不通过，因为接口中不能存在构造器
D.编译不通过，因为接口名必须超过1个字符
答案：C
47.以下代码的执行结果是：
public class Example {
String s = "Outer";
public static void main(String[] args) {
S2 s2 = new S2();
s2.display();
}
}
class S1 {
String s = "S1";
void display() {
System.out.println(s);
}
}
class S2 extends S1 {
String s = "S2";
}
A.S1
B.S2
C.null
D.Outer
答案：A
答案解析：本题中，由于子类S2中未定义display方法，因此在子类S2实例上调用的display方法是继承自父类的S1中的，由于display方法只能对同类上的成员变量s进行访问，因此打印输出S1
48.关于构造器说法错误的是
A.构造器不属于类成员方法，因此构造器不能被继承
B.只有构造器才能拥有和类名相同的方法名
C.一个类可以拥有多个重载的构造器
D.在子类中调用父类的非默认构造器，必须使用super（...）语句，而且该语句必须位于子类构造器的第一行
答案：B
答案解析：普通类成员方法也可以和类同名，但是会造成隐患，不建议这么命名
49.以下哪个针对默认无参构造器描述是正确的？
A.均是public构造器
B.均无访问修饰符
C.均与所属类访问修饰符一致
D.由编译器决定
答案：C
50.当一个类的所有构造器均为私有的，以下哪个描述是正确的？
A.不能被其他类实例化
B.不能被其他类继承
C.既不能被其他类实例化，也不能被其他类继承
D.该类必须被final修饰
答案：C
答案解析：当一个类的所有构造器均为私有，这意味着其他类无法通过new语句实例化该类，并且该类不能被继承，如果子类可以继承该类，在实例化子类时，必须首先调用该类的构造器，但由于构造器是私有的，不能调用，因此使得子类无法实例化。
51.以下哪些修饰符可以用于构造器？
A.final
B.static
C.synchronized
D.以上选项均不行
答案：D
52.关于重载和覆盖，以下说法错误的是
A.重载方法的返回值、访问修饰符以及抛出的异常都不是重载方法判断的决定因素
B.一个静态方法既可以被重载为一个静态方法，也可以被重载为一个非静态方法
C.一个静态方法既可以被覆盖为一个静态方法，也可以被覆盖为一个非静态方法
D.覆盖的方法返回值必须和源方法返回值类型保持赋值兼容，访问权限不能小于源方法，只能抛出源方法异常或源方法异常的子类
答案：C
答案解析：静态方法只能覆盖为静态方法
53.现有基类中的一个方法：void method(){},请问以下哪些是子类中覆盖该方法的正确形式？
A.void method(){}
B.int method(){return 0;}
C.void method(int i)
D.private void method()
答案：A
54.现有如下代码：
class Super {
public float getNum() {
return 3.0f;
}
}
class Sub extends Super {
// 空白处
}
请问以下哪个语句放置在注释的空白处会引起编译错误？
A.public float getNum(){return 4.0f;}
B.public void getNum(){}
C.public void getNum(double d){}
D.public double getNum(float d){return 4.0;}
答案：B
55.以下代码的执行结果是什么？
public class Example {
int i = 100;
public void print() {
System.out.println(50);
}
public static void main(String[] args) {
Example a = new A();
System.out.println(a.i);
a.print();
}
}
class A extends Example {
int i = 200;
public void print() {
System.out.println(300);
}
}
A.100
300
B.200
300
C.100
50
D.200
50
答案：A
答案解析：多态环境下利用父类引用调用属性，调用变量使用的是父类声明的，调用方法则因为动态绑定使用的是子类声明的
56.在下面代码中，在插入代码处插入什么语句可以实现在A中的amethod()方法中直接调用类C的test()方法，而不需要创建一个类C的实例？
class C{
public void test(){
System.out.println("C");
}
}
class B extends C{
public void test(){
System.out.println("B");
}
}
class A extends B{
public void test(){
System.out.println("A");
}
public void amethod(){
//插入代码处
}
}
A.test()
B.super.test()
C.super.super.test()
D.不能实现该要求
答案：D
答案解析：super只能访问直接父类被覆盖的方法，不能跨级使用
57.现有以下代码：
class Base {
}
class Sub extends Base {
public String getFields() {
String name = "Sub";
return name;
}
}
class DoSub {
public static void main(String[] args) {
Base b = new Sub();
// 插入语句处
}
}
在插入语句处插入那条代码能够输出Sub？
A.System.out.println(b.getFields());
B.System.out.println(b.name);
C.System.out.println((Base)b.getFields());
D.System.out.println(((Sub)h).getFields());
答案：D
58.欲构造ArrayList类继承了List接口，下列哪个方法是正确的
A.ArrayList myList=new Object()
B. List myList=new ArrayList()
C.ArrayList myList=new List()
D.List myList=new List()
答案：D
59.以下关于abstract的说法，正确的是
A.abstract只能修饰类
B. abstract只能修饰方法
C.abstract类中必须有abstract方法
D.abstarct方法所在的类必须用abstract修饰
答案：D
60.关于类继承的说法，正确的是
A.Java 类允许多继承
B.Java接口允许多继承
C.接口和类都允许多继承
D.接口和类都不允许多继承
答案：B
61.关于接口的说法，正确的是
A.接口中的方法只能在接口的实现类中实现
B.接口中可定义变量成员
C.接口中不能定义常量
D.以上都不对
答案：A
答案解析：接口中的方法都是抽象方法
62.如果类中的成员变量只可以被同一包访问，则使用如下哪个约束符?
A. private
B.public
C.protected
D.no modifier
答案：D
63.以下哪个约束符可用于定义成员常量
A.static
B.final
C.abstract
D.const
答案：B
64.给出如下代码:
class Test{
private int m;
public static void fun() {
// some code...
}
}
如何使成员变量m 被函数fun()直接访问?
A.将private int m 改为protected int m
B.将private int m 改为 public int m
C.将private int m 改为 static int m
D.将private int m 改为 int m
答案：B
答案解析：静态方法中只能访问临时变量或类的static成员
65.下列代码能否正常运行，如果能够正常运行，输出结果是什么
public class TestClass {
public static void main(String[] args) {
int num1=5;
int num2=5;
class InnerClass{
public int add(){
return num1+num2;
}
};
InnerClass in=new InnerClass();
System.out.println(in.add());
}
}
A.输出10
B.输出0
C.运行时输出异常信息
D.编译不能通过
答案：D
答案解析：内部内中访问外部类中的非成员属性，要求该属性为final
66.以下代码的执行结果是什么？
public class Example {
public static void main(String[] args) {
Base b = new Base();
Subclass1 S1 = new Subclass1();
Subclass2 s2 = new Subclass2();
s1 = (Subclass1) s2;
}
}
class Base {
}
class Subclass1 extends Base {
}
class Subclass2 extends Base {
}
A.代码编译成功，运行期间没有异常抛出
B.代码编译失败，赋值语句s1 = （Subclass1）s2非法
C.代码编译成功，但运行时ClassCastException对象造型异常被抛出
D.代码编译失败，因为一个基类不能被多个子类继承
答案：B
67.以下代码的执行结果是：
public class Example {
static int i = 1, j = 2;
static {
display(i);
i = i + j;
}
static void display(int n) {
System.out.println(n);
}
public static void main(String[] args) {
display(i);
}
}
A.1
2
B.0
1
C.1
3
D.1
1
答案：C
68.对于内部类，以下说法错误的是
A.匿名内部类可以实现接口或继承其他类，但不能同时即实现接口又继承类
B.匿名内部类不能有任何明确的构造器
C.内部类可以定义在外部类类体中，也可以定义在外部类的方法体中，和外部类不同，内部类均能使用访问修饰符，并能使用static修饰
D.在Java中，对内部类的嵌套层次没有限制
答案：C
答案解析：定义在方法体中的内部类不能使用访问控制符和static修饰
69.对于以下代码，请问插入哪个语句可以访问到内部类InsideOne?
public class Example {
public static void main(String[] args) {
EnclosingOne eo=new EnclosingOne();
//插入语句处
}
}
class EnclosingOne{
public class InsideOne{
}
}
A.InsideOne ei=new eo.InsideOne();
B.InsideOne ei=EnclosingOne.new InsideOne();
C.InsideOne ei=new EnclosingOne.InsideOne();
D.EnclosingOne.InsideOne ei=eo.new InsideOne();
答案：D
70.以下哪些是关于完全封装的正确描述？
A.所有的变量都是私有的
B.所有的方法都是私有的
C.只有通过提供的方法才能访问类属性
D.通过方法和变量名均可访问属性
答案：A、C
71.请选择所有的正确答案
A.在接口中定义的方法默认为private方法
B.在接口中定义的变量默认为public、static、final的
C.一个接口可以继承多个接口
D.关键字implements代表接口的继承关系
答案：B、C
72.以下哪些描述是正确的？
A.native关键字表明修饰的方法是由其他非Java语言编写的
B.能够出现在Java源文件中import语句前的只有注释语句
C.接口中定义的方法默认是public和abstract的，不能被private或protected修饰
D.构造器只能被public或protected修饰
答案：A、C
73.以下哪些关于构造器的描述是正确的？
A.子类可以继承父类的构造器
B.如果没有编写构造器，编译器会自动为类提供一个无参的默认构造器
C.构造器都没有返回值
D.构造器可以抛出异常
答案：B、C、D
74.给出下面的代码段:
public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;
z=c;
}
}
在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（ ）
A.Base(a,b);
B.x=a, y=b;
C.x=a; y=b;
D.this(a,b)
答案：C、D
75.以下关于方法覆盖描述正确的有
A.覆盖的方法和被覆盖的方法必须具有相同的方法名、参数列表和返回类型
B.覆盖的方法的访问范围不能比被覆盖的方法访问范围小
C.覆盖的方法不能抛出被覆盖方法不能抛出的异常
D.被覆盖的方法不能被private修饰符修饰
答案：B、C、D
答案解析：重载方法的返回值类型可以不一致，但要保证类型是和被重载方法返回值赋值兼容
76.现有一下代码：protected void method(int x){...}，以下哪些有关覆盖该方法的描述是正确的？
A.覆盖的方法必须采用int型作为唯一个一个参数
B.覆盖的方法必须返回类型为void
C.覆盖的方法可以被private修饰符修饰
D.覆盖的方法可以返回任何类型的值
答案：A、B
77.现有以下代码：
public class MethodOver{
public void setVar(int a,int b,float c){
}
}
以下哪些是满足setVar方法的正确重载形式？
A.private void setVar(int a,float c,int b){}
B.protected void setVar(int a,int b,float d){}
C.public int setVar(int a,float c,int b){return a;}
D.public int setVar(int a,float c){return a;}
答案：A、C、D
78.现有以下代码，请问该程序的运行结果是什么？
class A {
protected int method(){
return 0;
}
}
class B extends A{
int method(){
return 0;
}
}
A.编译失败，因为覆盖方法的访问范围不能比被覆盖的方法更窄
B.编译失败，因为类A中的method()方法声明为protected,因此对其子类都是不可见的
C.编译失败，如果将第7行加上public修饰符，可编译通过
D.编译失败，如果将第7行加上pritected修饰符，可编译通过
答案：A、C、D
79.现有以下代码：
interface W {
}
class Z implements W {
}
class X extends Z {
}
class Y extends Z {
}
下列哪些代码段是正确的？
A.X x=new X();
Y y=new Y();
Z z=new Z();
y=(Y)x;
B.X x=new X();
Y y=new Y();
Z z=new Z();
x=(X)y;
C.X x=new X();
Y y=new Y();
Z z=new Z();
Z=(Z)x;
D.X x=new X();
Y y=new Y();
Z z=new Z();
W w=(W)x;
答案：C、D
80.有关匿名内部类描述正确的有
A.匿名内部类没有显式构造器
B.匿名内部类可以实现接口
C.匿名内部类可以继承非final类
D.匿名内部类可以同时实现接口和继承非final类
答案：A、B、C
81.以下哪些类型的变量可以被一个内部类访问？
A.所有static变量
B.所有final变量
C.所有的实例成员变量
D.只有final静态变量
答案：A、B、C
82.以下关于内部类的描述哪些是正确的？
A.定义在内部类中的变量不能被static修饰符修饰，除非内部类本身是静态的
B.定义在类中非方法中的内部类，可以访问外部类的所有变量，而不管变量的访问控制声明
C.一个内部类实际上是外部类的子类
D.内部类可以被private修饰符修饰
答案：A、B、D
83、下面哪个类能够动态创建数组？（B）
A、Arrays
B、Array
C、Constructor
D、Class
84、请简单描述Java反射机制的概念及其作用。
Java反射机制指的是程序在运行状态中，对于任意一个类，都能够获取这个类的所有属性和方法；对于任意一个对象，
都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的机制称为Java语言的反射机制。Java的
反射机制是很多框架技术的基础，例如Spring框架的IoC容器就使用到了反射机制。
85、Class类位于哪个包中？（A）
A、java.lang
B、java.util
C、java.io
D、java.lang.reflect
86、getClass方法的返回值类型是什么？（B）
A、Object
B、Class
C、调用该方法的对象的类型
D、不确定
87、getClass方法定义在哪个类中？（A）
A、Object
B、Class
C、Array
D、Runtime
88、下面哪个选项能正确返回一个Class类型对象？（D）
A、Class.getName(“java.lang.String”);
B、Class.byName(“java.lang.String”);
C、Class.createByName(“java.lang.String”);
D、Class.forName(“java.lang.String”);
89、下面哪个选项能正确返回一个Class类型对象？（A）
A、java.lang.String.class
B、java.lang.String.class
C、java.lang.String.class
D、java.lang.String.class
90、自定义类Account，创建此类对象account，哪个选项不能正确返回Class对象？（A）
A、account.class
B、Account.class
C、account.getClass()
D、Class.forName(“Account”)
91、Class类中的哪个方法可以动态创建对象？（D）
A、getInstance()
B、createInstance()
C、instance()
D、newInstance()
92、反射API中，哪个类用来封装构造方法？（A）
A、Constructor
B、Constructors
C、Construct
D、Constructs
93、如果Account.class.getConstructor(String.class,String.class,Double.class);编译运行正常，请问Account类中必须有哪个构造方法？（C）
A、public Account(){}
B、public Account(String id){}
C、public Account(String id, String pwd, Double balance){}
D、public Account(String id, String pwd,double balance){}
94、如果Account类中存在构造方法public Account(String id, String pwd, Double balance){}，则下列哪个选项能够正确使用该构造方法实例化对象？（A）
A、newInstance(new Object[]{"7222 2221 1343 35325","832112",new Double(3908)});
B、newInstance(new Object[]{"7222 2221 1343 35325","832112",3908});
C、newInstance("7222 2221 1343 35325","832112",new Double(3908));
D、A、B均可
95、反射API中，使用哪个类封装方法？（B）
A、Methods
B、Method
C、Constructors
D、Constructor
96、Method类中的哪个方法可以返回方法名字？（C）
A、getMethod
B、getMethodName
C、getName
D、getDescriptor
97、Method类中的哪个方法可以动态调用方法？（A）
A、invoke
B、run
C、make
D、main
98、如下类Student，内省机制会认为该类有哪些属性？（A）
public class Student{
}
A、没有属性
B、class
C、this
D、不确定
99、如下类Student，内省机制会认为该类有哪些属性（不考虑class属性）？（D）
public class Student{
private String stuName;
private int stuAge;
}
A、stuName
B、stuAge
C、stuName以及stuAge
D、没有属性
100、如下类Student，内省机制会认为该类有哪些属性（不考虑class属性）？（A）
public class Student{
private String stuName;
private int stuAge;
public String getStuName(){
return stuName;
}
}
A、stuName
B、stuAge
C、stuName以及stuAge
D、没有属性
