3、

以下选项中关于Java跨平台原理的说法正确的是（AC  ）。（选择二项）

A

Java源程序要先编译成与平台无关的字节码文件(.class)，然后字节码文件再被解释成机器码运行

B.

Java的跨平台原理决定了其性能比C/C++高

C.

Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的，但它们都提供了相同的接口

D.

Java语言具有一次编译，到处运行的特点，可以在所有的平台上运行

4、

在Java中，源文件Test.java中包含如下代码，则程序编译运行的结果是（  B  ）。（选择一项）

public class Test {

public static void main(String[ ] args) {

system.out.println("Hello!");

}

}

A

输出：Hello！

B.

编译出错，提示“无法解析system”

C.

运行正常，但没有输出任何内容

D.

运行时出现异常

3、

下面的赋值语句中错误的是（ A   ）。（选择一项）

A

float f = 11.1;

B.

double d = 5.3E12;

C.

double d = 3.14159;

D.

double d = 3.14D;

4、

如下写法哪些是不对的（BD ）（选择二项）

A

byte b = 30;

B.

byte c = 500;

C.

long d = 2343223;

D.

float f = 3.14;

2、

以下代码的执行结果是（ B   ）。（选择一项）  ???

boolean m = false;

if(m = false){

System.out.println("false");

}else{

System.out.println("true");

}

A.

false

B.

true

C.

编译错误

D.

无结果

3.

阅读下列文件定入的Java代码，其执行结果是（  D   ）。（选择一项）

public class Test {

public static void main(String[] args) {

char ch = 'c';

switch (ch) {

case 'a':

System.out.print("a"); break;

case 'b':

System.out.print("ab");

case 'c':

System.out.print("c");

default:

System.out.print("d");

}

}

}

A

a

B.

b

C.

c

D.

cd

4.

以下Java程序编译运行后的输出结果是（ B   ）。（选择一项）

public class Test {

public static void main(String[] args) {

int i = 0, sum = 0;

while (i <= 10) {

sum += i;

i++;

if (i % 2 == 0)

continue;

}

System.out.println(sum);

}

}

A

0

B.

55

C.

50

D.

36

5.

在Java中有如下代码，则编译运行该类的输出结果是（ D   ）。（选择一项）

public static void main(String[ ] args) {

for(int i=0;i<10;i++){

if (i%2!=0)

return;

System.out.print(i);

}

}

A

13578

B.

02468

C.

0123456789

D.

0

1.

分析下面的Java多重循环代码片段，编译运行后的输出结果是（D    ）。（选择一项）

for (int i = 0; i < 6; i++) {

int k = ++i;

while (k < 5) {

System.out.print(i);

break;

}

}

A.

024

B.

02

C.

123

D.

13

2.

给定如下Java代码，编译运行的结果是（b    ）。（选择一项）

public class Test {

public static void main(String[] args) {

int sum=0;

for(int i=1;i<10;i++){

do{

i++;

if(i%2!=0)

sum+=i;

}while(i<6);

}

System.out.println(sum);

}

}

A

8

B.

15

C.

24

D.

什么也不输出

3.

在Java的程序类中如下方法定义正确的是（  ad  ）。（选择两项）

A

public int ufTest(int num){

int sum=num+100;

return sum;

}

B.

public String ufTest(int num){

int sum=num+100;

return sum;

}

C.

public void ufTest(int num){

int sum=num+100;

return sum;

}

D.

public float ufTest(int num){

int sum=num+100;

return sum;

}

4.

以下关于方法调用的代码的执行结果是（ b   ）。（选择一项）

public class Test {

public static void main(String args[]) {

int i = 99;

mb_operate(i);

System.out.print(i + 100);

}

static void mb_operate(int i) { i += 100;   }

}

A.

99

B.

199

C.

299

D.

99100

2、

在Java中，以下程序段能正确为数组赋值的是（ AD    ）。（选择二项）

A

int a[]={1,2,3,4};

B.

int b[4]={1,2,3,4};

C.

int c[];c={1,2,3,4};

D.

int d[];d=new int[]{1,2,3,4};

3、

数组元素的索引可以是（D    ）。（选择一项）

A

整型常量

B.

整型变量

C.

整型表达式

D.

以上都可以

4、

在Java中，以下定义数组的语句正确的是（  Cd  ）。（选择二项）

A

int  t[10]=new int[ ];

B.

char [ ]a=”hello”;

C.

String [ ] s=new String [10];

D.

double[ ] d [ ]=new double [4][ ];

5、

以下选项中能够正确创建一个数组的是（ AD   ）。（选择二项）

A.

float []f[] = new float[6][6];

B.

float f[][] = new float[][];

C.

float [6][]f = new float[6][6];

D.

float [][]f = new float[6][];

6、

下面的数组定义哪些是正确的？（CD   ）。（选择二项）

A

int  a[][] = new int[3,3];

B.

int  a[3][3] = new int[][];

C.

int  a[][] = new int[3][3];

D.

int  []a[] = new int[3][3];

分析如下Java程序的代码所示，则编译运行后的输出结果是（C    ）。（选择一项）

public class Test {

int count=9;

public void count1(){

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;

4、

下列选项中关于Java中类方法的说法错误的是（  AC   ）。（选择二项）

A

在类方法中可用this来调用本类的类方法

B.

在类方法中调用本类的类方法时可直接调用

C.

在类方法中只能调用本类中的类方法

D.

在类方法中调用实例方法需要先创建对象

class Engine {

int speed;

int weight;

}

class Car {

static int tyreNum = 4;

Engine engine;

String color; // char sequence :字符序列

void changeColor(String c) {

color = c;

}

void showColor() {

System.out.println("我的颜色是：" + color);

}

}

//测试类和对象

public class TestObject {

public static void main(String[] args) {

Car c1 = new Car();

c1.changeColor("红色");

c1.showColor();

System.out.println(Car.tyreNum);

System.out.println(c1.tyreNum);

Car c2 = new Car();

Engine e = new Engine();

e.speed = 1000;

e.weight = 10;

c2.engine = e;

c2.color = "黑色";

c2.tyreNum = 10;

System.out.println(c1.tyreNum);

}

}

1.

使用权限修饰符（ C   ）修饰的类的成员变量和成员方法，可以被当前包中所有类访问，也可以被它的子类（同一个包以及不同包中的子类）访问。（选择一项）

A

public

B.

protected

C.

默认

D.

private

2.

给出如下代码，如何使成员变量m被方法fun()直接访问（  C  ）。（选择一项）

class Test {

private int m;

public static void 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

解析：此题考点-----成员变量如何在静态方法内访问

静态方法----优先在方法区开辟空间，非静态成员变量在本类对象创建时才会

在堆内存中开辟空间，一个是先开辟另一个是后开辟，所以不能直接访问。

静态方法内访问成员变量两种方式：

其一：成员变量前加static ,其二：创建对象进行调用。

1、

以下关于this和super关键字的说法错误的是（ BD   ）。（选择二项）

A.

this关键字指向当前对象自身，super关键字指向当前对象的直接父类

B.

在main方法中可以存在this或super关键字，但不能同时存在。

C.

this和super关键字都可以访问成员属性，成员方法和构造方法

D.

在一个类的构造方法中可以同时使用this和super来调用其他构造方法

解析：此题考点----this  super关键字

选项A：this代表本类对象的一个引用，super代表本类直接父类的一个引用

选项B：静态方法、静态代码块等，不允许使用this  super关键字。

因为：静态方法等优先开辟空间，在使用this时，对象可能还没有

创建，所以JVM不允许在静态方法、静态代码块中使用他们。

选项C：this  super代表的是一个引用，可以调用类的属性和方法。

选出D：类的构造方法，首行要么是使用this，要么使用super，只能是二选一

2、

以下Java程序编译运行后的输出结果是（  A  ）。（选择一项）

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( );

}

}

A

static A

static B

I'm A class

HelloA

I'm B class

HelloB

C.

static A

I'm A class

HelloA

static B

I'm B class

HelloB

B.

static A

static B

I'm A class

I'm B class

HelloA

HelloB

D

static A

static B

HelloA

HelloB

I'm A class

I'm B class

3、

下列选项中关于Java中super关键字的说法正确的是（  AD   ）。（选择二项）

A

super关键字是在子类对象内部指代其父类对象的引用

B.

super关键字不仅可以指代子类的直接父类，还可以指代父类的父类

C.

子类通过super关键字只能调用父类的方法，而不能调用父类的属性

D.

子类通过super关键字可以调用父类的构造方法

解析：此题考点-----super关键字

选项A： super作为子类直接父类对象的一个引用存在，正确；

选项B：super只能引用子类的直接父类对象，不能一次引用父类的父类。

选项C：为了区分父类和子类重复的属性或方法时，可以使用super进行分区

选项D：允许使用super调用父类的构造方法，则必须是在首行进行调用。

1.

编译运行如下Java代码，输出结果是（  D   ）。（选择一项）

class Base {

public void method(){

System.out.print ("Base method");

}

}

class Child extends Base{

public void methodB(){

System.out.print ("Child methodB");

}

}

class Sample {

public static void main(String[] args) {

Base base= new Child();

base.methodB();

}

}

A

Base method

B.

Child methodB

C.

Base method

Child methodB

D.

编译错误

解析：此题考点-----对象的多态和父类对象能否调用子类方法。

子类： 在父类中只要不是使用private修饰，子类都可以继承，子类

都可以调用。

父类： 父类对象只能调用自身的方法，子类的方法和属性无权调用；

如果父类的某个方法，被子类重写，那么父类对象调用这个方

法时，调用的是被子类重写之后的方法。

此种情况的前提： 使用对象的向上转型来创建父类对象。

通过发现，父类对象再调用子类的方法，明显的编译错误。

1.

Person类和Test类的代码如下所示，则代码中的错误语句是（ C   ）。（选择一项）

public class Person {

public String name;

public Person(String name) {

this.name = name;

}

}

public class Test {

public static void main(String[] args) {

final Person person = new Person("欧欧");

person.name = "美美";

person = new Person("亚亚");

}

}

A.

final Person person = new Person("欧欧");

B.

person.name = "美美";

C.

person = new Person("亚亚");

D.

没有错误

2.

如下Java代码运行的结果是（ B   ）。（选择一项）

public class Test {

final int age;

public Test(){

age=10;

}

public static void main(String[ ] args) {

System.out.println(new Test().age);

}

}

A

输出：0

B.

输出：10

C.

输出：null

D.

运行时出现异常

3.

以下代码中错误的语句是（  D   ）。（选择一项）

public class Something{

public static void main(String[] args){

final Other o=new Other();

new Something().addOne(o);//1

}

public void addOne( Other o){

o.i++;//2

o =  new Other();//3

}

}

class Other{

public int i;

}

A

1

B.

2

C.

3

D.

没有错误

2、

编译并运行如下Java程序，将输出（  D  ）。（选择一项）

public static void main(String[] args) {

try {

int num1 = 2; int num2 = 0;

int result = num1 / num2;

System.out.println(result);

throw new NumberFormatException( );

} catch (ArrayIndexOutOfBoundsException e) {

System.out.print("1");

} catch (NumberFormatException e) {

System.out.print("2");

} catch (Exception e) {

System.out.print("3");

} finally {

System.out.print("4");

}

System.out.print("5");

}

A

134

B.

2345

C.

1345

D.

345

解析：此题考点-----捕捉异常

从以上代码发现，int result = num1 / num2; 被除数为零，发生异常

ArithmeticException算术异常，后续的输出语句不再执行，进入到catch

代码块寻找匹配的异常类型，发现没有catch代码块中没有ArithmeticException算术异常，只要让父类异常类型代替子类接收，此处体现了对象的多态-----对象的向上转型；执行此catch块中的代码，打印输出3，

再进行分析，catch块进行匹配了之后，执行finally代码块，输出4，

还有最后一句System.out.print("5");它不再try catch finally中，最后执行它，

输出5，所以------最后结果：345

3、

阅读如下Java代码，在控制台输入"-1",执行结果是（B）。（选择一项）

public class Demo {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.print("请输入数字：");

try {

int num = input.nextInt();

if (num < 1 || num > 4) {

throw new Exception("必须在1-4之间！");

}

} catch (InputMismatchException e) {

System.out.println("InputMismatchException");

} catch (Exception e) {

System.out.println(e.getMessage());

}

}

}

A

输出：InputMismatchException

B.

输出：必须在1-4之间！

C.

什么也没输出

D.

编译错误

解析：此题考点-----try cath 中使用throw关键字

其一：只有try代码块中出现异常才会执行catch代码块。

其二：throw在代码块中出现，需要进行捕捉

其三：Exception当中的存在一个获取异常信息的方法---getMessage()方法

执行顺序：

第一步：在执行try代码块中，出现throw关键字，相当于出现异常。

第二步：和catch代码块中依次进行匹配，和最后一个catch块匹配上

执行此代码块中的执行语句-----调用getMessage()方法

输出结果："必须在1-4之间！"

4.

以下关于StringBuffer类的代码的执行结果是（ D   ）。（选择一项）

public class TestStringBuffer {

public static void main(String args[]) {

StringBuffer a = new StringBuffer("A");

StringBuffer b = new StringBuffer("B");

mb_operate(a, b);

System.out.println(a + "." + b);

}

static void mb_operate(StringBuffer x, StringBuffer y) {

x.append(y);

y = x;

}

}

A.

A.B

B.

A.A

C.

AB.AB

D.

AB.B

9.

分析下面的Java程序，编译运行后的输出结果是（ D   ）。（选择一项）

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");

System.out.print(ex.ch);

}

public void change(String str, char ch[]) {

str = "test ok";

ch[0] = 'g';

}

}

A

goodandabc

B.

goodandgbc

C.

test okandabc

D.

test okandgbc

2.

如下Java代码，输出的运行结果是（  A  ）。（选择一项）

public class Test {

public static void main(String[ ] args) {

List<String> list=new ArrayList<String>();

list.add("str1");

list.add(2, "str2");

String s=list.get(1);

System.out.println(s);

}

}

A

运行时出现异常

B.

正确运行，输出str1

C.

正确运行，输出str2

D.

编译时出现异常

解析：此题考点-----List集合中添加元素

add(int index,Object obj)方法指的是在指定位置添加元素。

执行到list.add("str1");之后，此集合中元素的size是1

但是执行list.add(2, "str2");的时候，向下标为2的位置，添加数据

发现：最大的下标值是1，怎么可能在下标值是2的位置添加元素

所以这会出现IndexOutOfBoundsException  下标越界异常。

3.

以下Java代码的作用是首先将一个数组的内容存入集合，然后判断集合中是否有指定的元素存在，其中共有（ D   ）处错误。（选择一项）

import java.util.List;

public class Test {

public int getIndexofArray(float[] f){

int rtn=-1;

float objf=3.4;  //此处小数后面应该加F或f

List list=null;   //此处数组只有声明，没有实例化

for(int i=0;i<f.size( );i++){//此处数组没有size()方法，只有length属性

list.add(f[i]);

}

for(int i=0;i<list.size( );i++){

float tmp=(float)list.get(i);

if(objf==tmp){

rtn=i;

}

}

return rtn;

}

}

A

0

B.

1

C.

2

D.

3

解析：同以上发现，有3个错误，具体看代码后面的注释。

4.

分析如下Java 代码，编译运行后将输出（  B  ）。（选择一项）

public class Test {

public Test() {

}

static void print(List<Integer> al) {

al.add(2);

al = new ArrayList<Integer>();

al.add(3);

al.add(4);

}

public static void main(String[] args) {

List<Integer> al = new ArrayList<Integer>();

al.add(1);

print(al);

System.out.println(al.get(1));

}

}

A

1

B.

2

C.

3

D.

4

解析：此题考点------List集合相关方法

1 add(Object  obj)添加元素的方法

2 get(int index) 根据索引值获取具体的对象

分析1.main方法中的a1是局部变量，同理print方法中的a1也是局部变量

2局部变量的作用域：只在当前方法或代码块中有效。

也就是main方法中的a1，a1.get(1)调用的是此方法中的List集合对象

对于print方法中的a1，它无能为力，鞭长莫及啊！

5.

给定如下Java代码，编译运行的结果是（  C  ）。（选择一项）

public class Test {

public static void main(String[] args) {

Map<String, String> map = new HashMap<String, String>();

String s = "code";

map.put(s, "1");

map.put(s, "2");

System.out.println(map.size());

}

}

A

编译时发生错误

B.

运行时引发异常

C.

正确运行，输出：1

D.

正确运行，输出：2

解析：此题考点----Map集合

Map集合特点： key—value键值对  映射关系

Key要求：无序，唯一

Value要求：无序，不唯一

如果发现，键相同----值不同的情况，那么以最后一个键值对为基准

添加到集合中，说白了发生了一次覆盖操作。

map.put(s, "1");

map.put(s, "2");

两行代码出现了上述情况，所以这次向集合中添加元素只能添加一个

也就是map.put(s, "2"); 所以，此时集合中元素的个数是1

2、

下列关于Thread类提供的线程控制方法的说法中，错误的是（C    ）。（选择一项）

A

线程A中执行线程B的join()方法，则线程A等待直到B执行完成

B.

线程A通过调用interrupt()方法来中断其阻塞状态

C.

若线程A调用方法isAlive()返回值为false，则说明A正在执行中，也可能是可运行状态

D.

currentThread()方法返回当前线程的引用

5、

以下说法中关于UDP协议的说法正确的是（  AD  ）。（选择二项）

A.

发送不管对方是否准备好，接收方收到也不确认

B.

面向连接

C.

占用系统资源多、效率低

D.

非常简单的协议，可以广播发送

解析： 此题考点-----UDP协议

TCP协议 一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议 。面向连接 、点到点的通信 、高可靠性 、占用系统资源多、效率低

UDP协议 ：一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务

6、

在基于TCP网络通信模式中，客户与服务器程序的主要任务是（BC ）。（选择二项）

A

客户程序在网络上找到一条到达服务器的路由

B.

客户程序发送请求，并接收服务器的响应

C.

服务器程序接收并处理客户请求，然后向客户发送响应结果

D.

如果客户程序和服务器都会保证发送的数据不会在传输途中丢失

解析：此题考点------客户端和服务器端

客户端：向服务器发送请求

服务器端：响应客户端

选项A：说法正确，但是不是主要任务

选项B：符合主要任务

选项C：符合主要任务

选项D：说法正确，但是不是主要任务