- 下列不属于Java运行环境要执行的工作是（ A ）
A． 从Java源文件编译成字节码文件
B． 字节码校验
C． 解释执行
D． 类加载
编译是在运行环境外执行的
- 在JDK1.8中，switch（expr1）中，expr1不可以是如下哪个类型（D ）
- byteB. short C. char D. long E. int F. String
Switch中只能填整形和字符、字符串，long转换为int会丢失精度
- 下面哪一个是合法的自定义Java标识符（B）
- –hello B._String$123 C. return D. 38Test
自定义标识符只能由字母、数字、美元符、下划线组成，不能以数字开头，不能是关键字或true、false、null
4、以下不属于Java基本数据类型的有（C）
A. long B. float C. String D. char E. double
String是引用数据类型
5、有一个Hello.java的文件，内容如下（D ）
| class Test{ publicstaticvoid main(String[] args){ System.out.println("abc"); } } |
正确编译并执行的命令是（）
- javac Hello.java
java Hello
- javac Hello.java
java Hello.class
- javac Hello.java
java Test.class
D. javac Hello.java
java Test
编译用javac+文件名.java，编译文件。一个文件中可以有多个类，只有public修饰的类名才和文件名相同。
执行用java +类名，执行的是类
6. 下列的哪个赋值语句是不正确的（ C）。
A. long x = 90;
float f = x;
B. int x = 9/7;
C. byte b1 = 7,b2 = 8;
b1 = b1+b2;
D. double y = 4*2.3;
int类型不能转换为byte类型
7.以下代码执行结果为（D）
| publicclass A{ publicstaticchar c ='A'; publicstaticvoid main(String[] args){ for(int j =0;j<2&& test(c);){ j++; } } publicstaticboolean test(char c){ c +=1; System.out.print(c+" "); returntrue; } } |
A.B C D B.B B B
C.B C D.B B
1.&&会短路
2.传的参数char c是传值进去，本身不会改变
3. ‘A’的ASICC码是65
8、以下代码执行结果是（C ）
| publicstaticvoid main(String[] args){ int a =8; switch(a/4){ case1: System.out.print("1 "); case2: System.out.print("2 "); case3: System.out.print("3 "); default: System.out.print("default "); } } |
A. 1 2 3defaultB. 2
C. 23 defaultD. 2 3
a/4等于2满足case2，输出“2”，没有break，继续执行下面的代码，输出“3”，输出“default”
9、表达式5<6?4:3执行的结果是（ A ）。
A. 4 B. 3C. true D. false
三目运算符，5<6为真，执行4
10、以下循环，哪个是死循环（A）
A. boolean x = false;
while(x = true){
System.out.println(x);
}
X被赋值为true，while循环条件永远为真，死循环
B. int x = 0;
do{
System.out.println(x);
x++;
}while(x>10);
C. int x = 8;
while(x > 10){
System.out.println(x);
}
D. for(int i=0;;i++){
System.out.println(i);
if(i > 5) break;
}
11、以下代码执行结果为（B）
| int a=1,b=10; do{ b-=a; a++; }while(b--<0); System.out.println(b); |
- 0 B. 8 C. 9D. 10
b为9，b<0不成立，不执行循环体，b变量自减1为8，输出b为8
12、至少执行一次的循环是（C）
A. while B. for C. do……while D. continue
13、在java中，真和假以什么方式表示（ A ）。
A. true为真，false为假
B. 真只能用1表示，假用0表示；
C. 所有的非0都表示真，假用0表示；
D. 以上都不对
14、以下代码输出结果是：( A )
| publicclass A{ publicstaticvoid main(String[] args){ int i =6; System.out.print(test(i)); } publicstaticvoid test(int i){ System.out.print(i++); } } |
A. 编译错误B. 运行错误
C. 打印6 7 D. 打印6 6
test的返回类型为void，打印没有返回类型为空的方法，编译错误
15、下面不属于数组特点的是（C）
A. 数组是一段连续的空间
B. 数组元素通过下标进行访问。
C. 数组创建后，长度可以变化。
D. 数组元素在创建后会完成初始化。
数组的定长性，java是高级语言，数组在创建的时候，随机在内存中找了三块连续的空间，如果增加数组长度，有可能会覆盖已经被占用的内存。
16、以下代码输出结果是( B )
| publicclass A{ publicstaticvoid main(String[] args){ int i =6; int[] array ={1,2,3}; test(i,array); System.out.print(i+" "+array[0]); } publicstaticvoid test(int i,int[] array){ i +=3; array[0]+=3; } } |
A. 9 4 B. 6 4
C. 6 1 D. 9 1
传参数的时候，i是将值传给了形参，array是将数组的首地址传给了形参，在main方法中，i没有改变，数组array的第一项改变为4.所以输出6 4
17、生成doc帮助文档，需要使用什么命令（D）。
A. java B. javac C. jar D. javadoc
18、以下代码执行结果是( B )：
| publicclass A{ publicstaticvoid main(String[] args){ int x =10; if(x >3){ System.out.print("***"); } elseif(x >5){ System.out.print("&&&"); } } } |
- *** &&&B.*** C.&&&D. 没有输出
elseif中，x=10满足x>3的条件，输出***就不会进入后面的判断了。
19、下面程序的运行结果是（D）
| int[] my_Array; my_Array =newint[5]; for(int count =0; count <=5; count++){ System.out.println(my_Array[count]); } |
A．将1,2,3,4,5输出到屏幕
B．将0,1,2,3,4输出到屏幕
C．将0,1,2,3,4,5输出到屏幕
D．运行错误
循环到最后一次时，count为5下标越界了
20. 假如方法的定义形式为：
public static void fun(int a,char b){……}
那么下面哪种调用是正确的（C ）
A. fun(5, “A”); B. fun(5, '65'); 字符只能是单个的
C. fun('A',65); D. fun(5.2,65);
21、不属于面向对象特点的是（A）
A. 垃圾回收B. 多态C. 继承D. 封装
| 22、 |
下面关于对象说法不正确的是（B） |
|
| A. |
万物皆对象 |
|
| B. |
对象一定是看得见，摸得着的 |
|
| C. |
对象因关注产生（关注对象什么属性，就给它什么属性） |
|
| D. |
对象包含属性和行为。 |
|
23、当编译和运行下面程序时会发生什么事情（B）。
| publicclass Program { publicstaticvoid main(String args[]){ int i; System.out.println(i); } } |
A. 通过编译并输出0 B. 产生编译错误
C. 通过编译并输出null D. 通过编译但出现运行异常
Int i是局部变量，需要赋值才能打印
24、下列说法正确的是（C）
A. class中的构造方法不可省略
B.构造方法必须与class同名，但普通方法不能与class同名
C.构造方法在一个对象被new时执行
D. 一个class只能定义一个构造方法
25、关于抽象类描述不正确的是（C）
A. 有abstract关键字修饰，允许包含未实现方法的类被称为抽象类
B. 在抽象类中可以不包含抽象方法
C. 抽象类可以实例化
D. 抽象类可以被继承
26、有以下代码
| package pack1; class A{ void method1(){} staticvoid method2(){} privatevoid method3(){} protectedvoid method4(){} } package pack2; class B extends A{ public B(){ //here } } |
其中哪个方法可以放在here处？D
A. this.method1(); B. this.method2();
C. this.method3(); D. this.method4();
method1和method2访问修饰符是默认级，只能同包的访问，method3是私有的只能本类访问，method4是protected受保护的，可以被同包或不同包的子类访问。
27、给定Java代码如下，关于super的用法以下描述正确的是（C）。
| class C extends B { public C(){ super(); } } |
A、 用来调用类B中定义的super()方法
B、 用来调用类C中定义的super()方法
C、 用来调用类B中的无参数的构造方法
D、 用来调用类B中第一个出现的构造方法
| 28、 |
给定JAVA代码，如下，编译运行后，结果是( B ).
|
||
|
|
A. |
编译错误B. 运行错误 |
|
|
|
C. |
正常运行，输出trueD. 正常运行，输出false |
|
S为null，调用equals方法会报空指针异常
29. 以下代码执行结果是（ D）
| publicclass MyClass { publicvoid MyClass(){ System.out.print("MyClass"); } publicvoid method(){ System.out.print("method"); } publicstaticvoid main(String[] args){ MyClass m =new MyClass(); m.method(); } } |
A.编译错误B.MyClassmethod
C.MyClassD. method
30、以下代码，执行结果是( A )
| publicclass Father{ public Father(int x){ System.out.println("XXX"); } } class Child extends Father{ public Child(){ System.out.println("yyy"); } publicstaticvoid main(String[] args){ new Child(); } } |
- 编译错误 B. 运行错误 C. 输出XXXyyy D. 输出yyyXXX
在new一个child对象时，调用child的无参构造，首先默认调用父类的无参构造，父类中只写了有参构造，所以产生编译错误。父类中必须写一个无参构造！
31、给定Java代码如下，编译运行结果是（A）。
| publicclass Test{ publicint count(){ return1%9; } publicstaticvoid main(String[] args){ System.out.println(count()); } } |
- 编译错误 B. 运行异常 C. 正常运行，输出1 D. 正常运行，输出0
静态方法不能访问非静态成员，非静态方法能访问静态成员。
Count为非静态方法，main方法为静态方法。
32、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要由子类重写，应该使用（C）关键字来声明父类的这些方法。
A. final B. static C. abstract D. void
33、 以下代码执行结果是（C）
| publicclass Student { publicint code; } publicclass Test { publicstaticvoid main(String[] args){ int x =4; Student s1 =new Student(); s1.code =8; test(s1,x); System.out.println(s1.code+" "+x); } publicstaticvoid test(Student s1,int x){ s1.code =2; s1 =new Student(); s1.code =10; x =1; } } |
A. 10 1 B. 8 4
C. 2 4 D. 10 4
34、以下关于final关键字说法错误的是（C）
A. final不能修饰抽象类
B. final修饰的类不能被继承
C. final修饰的方法不能被重载 （final修饰的方法不能被重写，可以重载）
D. final修饰的变量不允许被再次赋值
35、有这样的定义( )
| class A{} class B extends A{} class C extends B{} interface IFly{} class D implements IFly{} class Imp{ publicvoid foo(B b,IFly fly){} publicstaticvoid main(String[] args){ Imp mp =new Imp(); //here } } |
下面哪个代码能插在here处（D）
A. mp.foo(new B(),new IFly());
B. mp.foo(new A(),new D());
C. mp.foo(new C(),new IFly());
D. mp.foo(new C(),new D());
多态：父类引用可以指向本类或它的子类；接口引用可以指向任何实现了该接口的类。
36、当试图编译并运行下面程序时会出现什么结果（C）。
| class A { publicint getNumber(int a){ return a +1; } } class B extends A { publicint getNumber(int a,int c){ return a +2; } publicstaticvoid main(String[] args){ B b =new B(); System.out.println(b.getNumber(0)); } } |
A. 编译错误 B. 运行异常 C. 1D. 2
方法的重载
37、 当编译并运行下面程序时会出现什么结果（B）。
| class Man{ publicint age; } publicclass Program { publicstaticvoid main(String args[]){ Man[] x =new Man[5]; x[0].age =2; System.out.println(x[0].age); } } |
- 编译错误 B. 运行异常C. 输出0D. 输出2
X[0]为null，调用X[0]的属性会报空指针异常
38、 下面关于抽象类和接口的说法哪个是正确的（C）。
A. 抽象类中只能包括抽象方法，必须写abstract关键字
B. 接口中的方法只能是抽象的，但不能写abstract关键字
C. 接口中的方法只能是public的
D. 抽象类不能被抽象类继承
39、 下面关于静态初始化块和实例初始化块说法正确的是（B）。
A、 静态初始化块只能被调用一次，是在第一次产生对象的时候（加载类的时候就调用了）
B、 每次产生对象的时候都会执行一次实例初始化块
C、 每次产生对象的时候都会执行一次静态初始化块
D、 实例初始化块是在执行构造方法之后马上被执行的。（构造方法中）
40、给定java代码，如下：
| abstractclass Shape{ abstractpublicvoid draw(); } |
要创建Shape类的子类Circle，以下代码正确的是（B）。
A. class Circle extends Shape{
public int draw( ){}
}
B. abstract class Circle extends Shape{}
C. class Circle extends Shape{
public void draw( );
}
- class Circle extends Shape{
protected void draw( ){}
}
要继承一个抽象类，子类要么也是一个抽象类，要么就实现父类中的所有抽象方法。
41、下面关于构造方法的说法错误的是（C）
A . 构造方法不能被继承
B. 构造方法不能被重写
C. 构造方法不能被重载
D. 构造方法可以被重载
42、在Java接口中，下列选项里有效的定义是（B）
A. public void method(){}
B.void method();
C. static void method();
D. protected void method();
43、使用（C）修饰符时，一个类能被同一包或不同包中的其他类访问。
A. private B. pretectedC. publicD. friendly
44、有以下定义：
| class MyClass{ publicint x; publicstaticvoid test(){} publicstaticvoid main(String[] args){ MyClass a =new MyClass(); //here } } |
下面哪个代码不能插在here处？( B )
A.MyClass.test(); B. MyClass.x = 2;
C. a.x = 2; D. a.test();
非静态成员只能用变量名访问。静态成员可以用类名访问，也可以用变量名访问
45、在Java语言中，下面关于构造器的描述正确的是（D）。
A. 类必须有显式构造器
B. 它的返回类型是void
C. 它和类有相同的名称,但它不能带任何参数
D. 以上皆非
46、下面哪行代码进行了垃圾回收( D )
| class MyObj{ public String name; publicstatic MyObj m; publicstaticvoid main(String[] args){ MyObj x =new MyObj();//1 MyObj a = x;//2 x = m;//3 a =new MyObj();//4 a.name ="mike";//5 } } |
- 1 B. 2 C. 3 D. 4 E. 5
47、下面的Java代码编译后生成的类文件的文件名不包括（ D）。
| publicclass One { publicclass Three {} } class Two { } |
A. One.class B. Two.class
C. One$Three.class D.One$Two.class
48、 以下代码执行结果是( B )
| class Man{ privateint age; public Man(int age){ this.age = age; } } publicclass Test{ publicstaticvoid main(String[] args){ Man m1 =new Man(5); Man m2 =new Man(5); System.out.print(m1 == m2); System.out.print(m1.equals(m2)); } } |
A. true true B.false false
C. true false D.false true
“==”用于值数据的比较，m1和m2的引用地址是不相同的，false
Man没有重写equals方法，所以这里调用的是object的equals方法，也是在比较引用地址。
49、在Java语言中，下面关于类的描述正确的是（B）。
A. 一个子类可以有多个父类
B. 一个超类可以有多个子类
C. 子类可以使用超类的所有方法
D. 子类一定比超类有更多的成员方法
50、执行以下代码结果是（C）
| publicclass Father{ publicint age; publicvoid test(){ System.out.println(this.age); } } class Child extends Father{ public String s; publicvoid speak(){ System.out.println(s); } } class Test{ publicstaticvoid main(String[] args){ Father f =new Child(); f.speak(); } } |
A. 0B. null
C.编译错误 D. 运行错误
父类对象只能调用父类中的方法，无法访问子类的方法。