1.变量和数据类型:
下列代码的输出结果是（A ）。
int j=0;
for(int i=0;i<100;i++){
j=j++;
}
System.out.println(j);
A.0
B.99
C.100
D.101
选择
class Example{
public static void main(String args[])
{
int var1 = 10;
int var2 = 20;
System.out.println(var1 + var2++ + " " + var2);
}
}
请选择一个正确答案：（B）
(A). 打印输出：30 20
(B). 打印输出：30 21
(C). 打印输出：31 20
(D). 打印输出：31 21
执行下列语句：
int a = 0x9af700; //1001 1010 1111 0111 0000 0000
a <<= 2;
变量a的值为：（B）。
A. 0x26bdc00
B. 0xc6bdc00
C. 0x3fa0000
D. 0x7e02ffff
下列程序 test 类中的变量 c 的最后结果为 (D )
Public class test{
Public static void main（String args[]）{
Int a = 10;
Int b;
Int c;
If(a>50){
b=9;
}
c=b+a;
}
}
A.10
B.0
C.19
D.编译出错
存在使i + 1 < i的数吗（存在）
0.6332的数据类型是（B）
A float B double C Float D Double
分析下面这段Java代码，它的运行结果是( C )。
Import java.io.*;
Public class B{
Public static void main(string [] args){
int i=12;
System.out.println(i+=i-=i*=i);}}
A) 100
B) 0
C) -120
D) 程序无法编译
2.流程控制
如下程序段:
int total = 0;
for ( int i = 0; i < 4; i++ ){
if ( i == 1) continue;
if ( i == 2) break;
total += i;
}
则执行完该程序段后total的值为：（ A）。
A、0 B、1 C、3 D、6
给出以下代码，请问该程序的运行结果是什么？
|
class Example {
public static void main(String args[]){
boolean flag = false;
if (flag = true){
System.out.println("true");
}
else{
System.out.println("false");
}
}
}
|
请选择一个正确答案：(C)
(A) 代码编译失败，因为if语句错误。
(B) 代码编译成功，但在运行期时if语句处抛出异常。
(C) 打印输出：true
(D) 打印输出：false
有以下程序:
|
|
public static void main(String[] args)
{
int i;
for(i=0;i<3;i++)
switch(i)
{ case 1:
System.out.print(i);
case 2:
System.out.print(i);
default:
System.out.print(i);
}
}
|
|
执行后输出结果是__011122__。
如下结果选择哪个(B)
public class FooBar{
public static void main(String[] args){
int i=0,j=5;
tp: for(;;i++){
for(;;--j)
if(i>j)break tp;
}
System.out.println("i="+i+",j="+j);
}
}
what is the result?
A.i=1,j=-1 B. i=0,j=-1 C.i=1,j=4 D.i=0,j=4
E.compile error at line 4
编程题：
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少
public class Rabbit {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new littleRabbit());
for (int k = 1; k <= 20; k++) {
for (int j = 0; j < list.size(); j++) {
littleRabbit rabbit = (littleRabbit) list.get(j);
int age = rabbit.getAge();
if (age >= 3) {
list.add(new littleRabbit());
}
age++;
rabbit.setAge(age);
}
System.out.println("第" + k + "个月有" + list.size() + "对兔子，一共"+list.size()*2+"只。");
// System.out.print(list.size()+",");
}
}
}
class littleRabbit {
private int age = 1;
public void growUp() {
this.age++;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3.面向对象:
接口:接口是Java面向对象的实现机制之一，以下说法正确的是：（B）
A. Java支持多重继承，一个类可以实现多个接口；
B. Java只支持单重继承，一个类可以实现多个接口；
C. Java只支持单重继承，一个类只可以实现一个接口；
D. Java支持多重继承，但一个类只可以实现一个接口。
接口：
interface A{
String x = "A";
}
class B{
String x ="B";
}
public class C extends B implements A {
public void print(){
System.out.println(x);
}
public static void main(String[] args) {
new C().print();
}
}
下面的描述哪一个正确：(B)
A) 程序编译错误，因为extends和implements不能同时使用，因为java只支持单继承。
B) 程序编译错误，因为对象C中的x不能确定引用的源。
C) 程序编译正确，结果输出为A.
D) 程序编译正确，结果输出为B.
接口：
final class Test1 {}
abstract class Test2{}
interface Test3{}
下面的描述中哪一个是正确的：(C)
A) Test1，Test3可以被实例化；Test2不可以。
B) Test2，Test3可以被实例化；Test1不可以。
C) Test1可以被实例化；Test2，Test3不可以
D) 都不可被实例化。
this:下列说法那些是正确的？(C)
A. 类本身可以使用this表达。
B. 类对象本身可以使用this表达。
C. 使用this()可以在方法内部调用本类的其他方法。
D．在构造方法中使用this()可以使用多次
接口：
请看下列代码：
public interface A {
String DEFAULT_GREETING = “Hello World”;
public void method1();
}
现有接口B，是A接口的子接口，下列选择中B接口的声明正确的是：(A)
A. public interface B extends A { }
B. public interface B implements A {}
C. public interface B instanceOf A {}
D. public interface B inheritsFrom A { }
接口：下列那些说法是正确的? (B )
A：定义类时，final和abstract修饰符必须选择一个，不能同时都选。
B：abstract修饰的类，可以没有abstract方法。
C：abstract修饰的类，不能有父类。
D：abstract修饰的类，不能有子类。
E：abstract修饰的类，必须有abstract方法。
F：以上说法都不对。
重写：
以下程序的运行输出结果是________。
class Parent{
void display(){
System.out.println("parent");
}
}
class Child extends Parent{
void display(){
System.out.println("child");
}
}
class UseOverride {
public static void main(String args[]){
Parent p = new Child();
p.display();
}
}
child
继承
class A {
private int a = 100;
A() {
System.out.print(“A()”);
System.out.println(a);
}
}
class B extends A {
private int a = 200;
B() {
System.out.print(“B()”);
System.out.println(a);
}
}
运行下面的代码：
new B();
输出的结果是：（A）。
A. A() 100
B() 200
B. A() 200
B() 200
C. B() 200
A() 100
D. B() 200
A() 200
方法：
如下方法声明中，错误的是（ B）。
A.
public void say()
{ System.out.print(“Hi”); }
B.
public void say()
{ System.out.print(“Hi”); return; }
C.
public int say()
{ System.out.print(“Hi”); return; }
D.
public int say()
{ System.out.print(“Hi”); return 0; }
方法：
**下述程序的输出结果为 _____8___。**
public class Demo {
private static int i = 7;
private static int j = 10;
private static int firstMethod(int i, int j){
j = Demo.j % i;
return Demo.i + j;
}
public static void main(String[] args) {
int result = Demo.firstMethod(3, 10);
System.out.println(result);
}
}
方法：
下面给出的代码片断：
public class Test9 {
public void setVar(int a, int b, float c) {
}
}
下面的哪些方法可以在继承该类的子类中声明：（多选）AC
A. private void setVar (int a, float c, int b) { }
B. potected void setVar (int a, int b, float c) { }
C. public int setVar (int a, float c, int b) {return a；}
D. public int setVar (int a, int b, float c) {return a；}
类：
下列类的定义，错误的是（C）
A. public class Test extends Object{……}
B. final class Operators{……}
C. void class Point{……}
D.public static class Demo1{……}
方法：
public class Foo {
public void method(String str,int age){}
} 和Foo类中method方法重载的方法是: (CD)
A. public int method(String str,int age){}
B. public void method(String s,int year){} C. public void method(int year,String s){}
D. public int method(int year,String s){}
访问控制
在Java语言中，下列说法正确的是：（C）。
A. Java访问修饰符按照访问范围由低到高的排列顺序是public，default，protected，private
B. private可以用于外部类的声明
C. 一个Java源文件中声明为public的外部类只能有一个
D. protected声明的方法不可以被子类重写
对象：
给出以下代码，请问该程序的运行结果是什么？
1\. public class Example{
2\. private int i = giveMeJ();
3\. private int j = 10;
4\. private int giveMeJ(){
5\. return j;
6\. }
7\. public static void main(String args[]){
8\. System.out.println((new Example()).i);
9\. }
10\. }
请选择一个正确答案：C
(A) 第8行代码编译错误。
(B) 第2行代码编译错误。
(C) 打印输出：0
(D) 打印输出：10
对象：
在创建对象时必须 （C）
A.先声明对象，然后才能使用对象
B.先声明对象，为对象分配内存空间，然后才能使用对象
C.先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
D.上述说法都对
Static:
程序中 classDemo 中定义了一个静态变量 sum，分析程序段的输出结果 (C )
class ClassDemo{
public static int sum=1;
public ClassDemo（）{
sum=sum+5;
}
}
public class ClassDemoTest{
public static void main(String args[]){
ClassDemo demo1=new ClassDemo();
ClassDemo demo2=new ClassDemo();
System.out.pringln(demo1.sum);
}
}
A.0
B.6
C.11
D.2
下述程序的输出结果为___1977-8-16___。(C)
public class ParentConstructor {
public int year;//0
public int month;//0
public int day;//0
public static final int default_month = 2;
public static final int default_day = 16;
public ParentConstructor(int y, int m, int d) {
year = y; month = m; day = d;
}
public ParentConstructor(int y) {
this(y, default_month, default_day);
}
public ParentConstructor(int y, int m) {
this(y, m, default_day);
}
}
public class ChildConstructor extends ParentConstructor{
public ChildConstructor(int h) {
super(1977, 8);
}
public static void main(String[] args) {
ChildConstructor t = new ChildConstructor(12);
System.out.println(t.year + "-" + t.month + "-" + t.day);
}
}
继承
以下代码运行输出是()
public class Person{
private String name=”Person”;
int age=0;
}
public class Child extends Person{
public String grade;
public static void main(String[] args){
Person p = new Child();
System.out.println(p.name);
}
}
A) 输出：Person
B) 没有输出
C) 编译出错
D) 运行出错
Abstract:
以下描述错误的有(C)
A) abstract 可以修饰类、接口、方法
B) abstract修饰的类主要用于被继承
C) abstract 可以修饰变量
D) abstract修饰的类，其子类也可以是abstract修饰的
继承
以下程序运行结果是(A)
public class Test extends Father{
private String name=”test”;
public static void main(String[] args){
Test test = new Test();
System.out.println(test.getName());
}
}
class Father{
private String name=”father”;
public String getName() {
return name;
}
}
A) father
B) test
C) 编译出错
D) 运行出错，无输出
Static
程序是否能正常运行
public class NULL {
public static void haha(){
System.out.println("haha");
}
public static void main(String[] args) {
((NULL)null).haha();
}
}
答案：可以
Static
输出结果为：
class HelloA {
public HelloA() {
System.out.println("HelloA");
}
{ System.out.println("I'm A class"); }
static { System.out.println("static A"); }
}
public class HelloB extends HelloA {
public HelloB() {
System.out.println("HelloB");
}
{ System.out.println("I'm B class"); }
static { System.out.println("static B"); }
public static void main(String[] args) {
new HelloB();
}
}
运行结果是什么？
static A
static B
I'm A class
HelloA
I'm B class
HelloB
Static
1\. public class Test {
2. static boolean foo(char c) {
3. System.out.print(c);
4. return true;
5. }
6. public static void main( String[] argv ) {
7. int i =0;
8. for ( foo(‘A’); foo(‘B’)&&(i<2); foo(‘C’)){
9. i++ ;
10. foo(‘D’);
12. }
13. }
14. }
What is the result? 答案(A)
A. ABDCBDCB
B. ABCDABCD
C. Compilation fails.
D. An exception is thrown at runtime.
内部类
public class Outer{
2. public void someOuterMethod() {
3\. // Line 3
4\. }
5\. public class Inner{}
6\. public static void main( String[]argv ) {
7. Outer o = new Outer();
8. // Line 8
9\. }
10.}
Which instantiates an instance of Inner?(A)
A. new Inner(); // At line 3
B. new Inner(); // At line 8
C. new o.Inner(); // At line 8
D. new Outer.Inner(); // At line 8//new Outer().new Inner()
继承
运行结果为：(D)
class People {
String name;
public People() {
System.out.print(1);
}
public People(String name) {
System.out.print(2);
this.name = name;
}
}
class Child extends People {
People father;
public Child(String name) {
System.out.print(3);
this.name = name;
father = new People(name + ":F");
}
public Child() {
System.out.print(4);
}
}
A312 B 32 C 432 D 132
Super
在使用super 和this关键字时，以下描述正确的是（A）
A) 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B) super（）和this（）不一定要放在构造方法内第一行
C) this（）和super（）可以同时出现在一个构造函数中
D) this（）和super（）可以在static环境中使用，包括static方法和static语句块
super
(D)
class Person{
public Person(){
System.out.println(“this is a Person”);
}
}
public class Teacher extends Person{
private String name=”tom”;
public Teacher(){
System.out.println(“this is a teacher”);
super();
}
public static void main(String[] args){
Teacher teacher = new Teacher();
System.out.println(this.name);
}
}
A) this is a Person
this is a teacher
tom
B) this is a teacher
this is a Person
tom
C) 运行出错
D)编译有两处错误
4.数组
运行下列代码：
int[] oneArr = { 2, 11, 26, 27, 37, 44, 48, 60 };
int[] twoArr = { 19, 35, 49, 55, 58, 75, 83, 84, 91, 93 };
int[] threeArr = new int[oneArr.length + twoArr.length];
int p = 0, q = 0;
while (p < oneArr.length && q < twoArr.length) {
threeArr[p + q] =
oneArr[p] < twoArr[q] ? oneArr[p++] : twoArr[q++];
}
if (p < oneArr.length) {
System.arraycopy(oneArr, p, threeArr, p + q, oneArr.length – p);
}
else if (q < twoArr.length) {
System.arraycopy(twoArr, q, threeArr, p + q, twoArr.length – q);
}
System.out.println(Arrays.toString(threeArr));
输出的结果是：（B）。
A. [2,11,26,27,37,44,48,60,19,35,49,55,58,75,83,84,91,93];
B. [2,11,19,26,27,35,37,44,48,49,55,58,60,75,83,84,91,93];
C. [19,35,49,55,58,75,83,84,91,93,2,11,26,27,37,44,48,60];
D. [2,19,11,35,26,49,27,55,37,58,44,75,48,83,60,84,91,93];
已经定义了int类型的数组变量m，下列哪个为m进行初始化的语句是正确的？(B)
A.m=[1,2,3,4];
B.m=new int[]{1,2,3,4};
C.m=new int[4]{1,2,3,4};
D.m=new int(1,2,3,4)
String foo="blue";
boolean[] bar=new boolean[1];
if(bar[0]){
foo="green";
}
what is the value of foo? (C)
A."" B.null C.blue D.green
5.异常
Error和Exception的联系
继承结构：Error和Exception都是继承于Throwable，RuntimeException继承自Exception。
Error和RuntimeException及其子类称为未检查异常（Unchecked exception），其它异常成为受检查异常（Checked Exception）。
Error和Exception的区别
Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等。如java.lang.StackOverFlowError和Java.lang.OutOfMemoryError。对于这类错误，Java编译器不去检查他们。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和预防，遇到这样的错误，建议让程序终止。
Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
运行时异常和受检查的异常
Exception又分为运行时异常（Runtime Exception）和受检查的异常(Checked Exception )。
RuntimeException：其特点是Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try……catch捕获，也没有用throws抛出，还是会编译通过，如除数为零的ArithmeticException、错误的类型转换、数组越界访问和试图访问空指针等。处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。
受检查的异常（IOException等）：这类异常如果没有try……catch也没有throws抛出，编译是通不过的。这类异常一般是外部错误，例如文件找不到、试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
throw 和 throws两个关键字有什么不同
throw 是用来抛出任意异常的，你可以抛出任意 Throwable，包括自定义的异常类对象；throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。如果方法抛出了异常，那么调用这个方法的时候就需要处理这个异常。
已经定义数组：int[] m=new int[4], 当使用语句m[10]=10; 时可以捕获的异常类型是?
A. java.lang.ArrayIndexOutOfBoundException
B. java.lang.NullPointerException
C. java.io.IOException
D. java.sql.SQLException
这个方法的返回值是_ return 3_______。(3)
public int count() {
try{
return 5 / 0;
} catch(Exception e){
return 2*3;
} finally {
return 3;
}
}