JAVASETEST0814

JAVASE0814

使用 Java语言编写的源程序保存时的文件扩展名是（B）。 

A..class   **B..java**   C..cpp     D..txt

2.设有数组的定义 int[] a = new int[3] ，则下面对数组元素的引用错误的 是（C ）。

A.a[0];      B.a[a.length-1];  **C.a[3]; // 012**    D.int i=1； a[i];

3.在同一个类的定义中可以有两个同名函数，这种现象称为函数（D ）。 A.封装     B.继承C.覆盖     **D.重载**  

4. 在类的定义中构造函数的作用是（ D）。

A.保护成员变量     B.读取类的成员变量  C.描述类的特征     **D.初始化成员变量**

5.类与对象的关系是（ A）。**A.类是对象的抽象**     B.对象是类的抽象C.对象是类的子类      D.类是对象的具体实例 

6.下面哪一个是 Java中不合法的标识在（D ）。

A.$persons     B.twoNum C._myVar     D.*point

```java

 Java 中，标识符是用来命名变量、方法、类等的名称。合法的标识符必须遵循一些命名规则，而不合法的标识符则会导致编译错误。

 以下是一些不合法的标识符情况：

//以数字开头： 标识符不能以数字开头。

例如，2variable 是不合法的。

//包含空格或特殊字符： 标识符不能包含空格或特殊字符（除了下划线 _ 和美元符号 $）。

例如，my variable、hello-world 是不合法的。

//Java 关键字： 某些单词在 Java 中具有特殊含义，被称为关键字，不能用作标识符。

例如，class、public、while 是不合法的。

//与现有类名冲突： 标识符不能与 Java 类库中已有的类名相同。

例如，您不能将自己的类命名为 String、ArrayList 等。

//大小写敏感： 标识符是大小写敏感的，这意味着大写和小写字母被视为不同的字符。

例如，myVariable 和 myvariable 是两个不同的标识符。

//长度无限制： 理论上，标识符可以是任意长度，但出于可读性和规范性的考虑，通常会遵循一定的命名约定，如驼峰命名法。

示例合法标识符：

variableName

_underscore

myVariable

$variable

//示例不合法标识符：

*point

2variable

hello-world

class

String符

s

```

7.为 AB 类的一个无形式参数无返回值的方法 method 书写方法头， 使得

使用类名 AB作为前缀就可以调用它，该方法头的形式为 ( A)。

**A.static void method( )** B.public void method( )C.final void method( )     D.abstract void method( )

8.欲构造 ArrayList类的一个实例，此类继承了 List 接口，下列哪个方 法是正确的（B ）。

A.ArrayList myList=new Object( ) 

**B.List myList=new ArrayList( )** C.ArrayList myList=new List( )  D.List myList=new List( )

9.Java源文件和编译后的文件扩展名分别为（ B）

A. .class和 .java      **B..java 和 .class** C..class和 .class     D. .java 和 .java

10.对于一个 Java源文件， import, class 定义以及 package正确的顺序是：A C

**A.package,import,class**    B. (B) class,import,packageC.import,package,class      D.package,class,import 

11.下面哪个是非法的：A.int I = 32;      B.float f = 45; 强转 **C.float f = 45.0;** **45，0f**   D.double d = 45.0; B

 

12.如果一个类的成员变量只能在所在类中使用， 则该成员变量必须使用 的修饰是C

A.public  任意 最广    B.protected 同一包    **C. private  同一类**    D.static   

13.下面关于 main 方法说明正确的是 B

A.public main(String args[ ])     **B.public static void main(String args[ ])**

C.private static void main(String args[ ])    D.void main()

14.关于抽象方法的说法正确的是 ( C)

A.可以有方法体     B.可以出现在非抽象类中 **C.是没有方法体的方法**      D.抽象类中的方法都是抽象方法

15.Java application中的主类需包含 main 方法，以下哪项是 main 方法的 正确形参？（ B）

A.String args     **B.String args[]** C.Char arg     D.StringBuffer args[]

16.以下关于继承的叙述正确的是（A ）。

A.**在 Java中类只允许单一继承**   B.在 Java中一个类只能实现一个接口

C.在 Java中一个类不能同时继承一个类和实现一个接口D.在 Java中接口只允许单一继承

17.若有定义： byte[] x={11,22,33,-66};  

其中 0≤k≤3，则对 x 数组元素错误的引用是（ C）

A.x[5-3]     B.x[k]C.**x[k+5]**   D.x[0]

18.以下哪个不是 Java的原始数据类型（ B）A.int     **B.Boolean**  包装类   C.float     D.char

19.在 Java中，一个类可同时定义许多同名的方法，这些方法的形式参 数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对 象程序特性称为（C ）A.隐藏 B.重写**C.重载**D.Java不支持此特性

20.以下有关构造方法的说法，正确的是： （A ）

**A.一个类的构造方法可以有多个** B.构造方法在类定义时被调用

C.构造方法只能由对象中的其它方法调用。D.构造方法可以和类同名，也可以和类名不同  

21.给出下面代码，关于该程序以下哪个说法是正确的？（C ） public class Person{ 

static int arr[] = new int[5];

public static void main(String a[])

{

System.out.println(arr[0]); }

}

A.编译时将产生错误     B.编译时正确，运行时将产生错误 **C.输出零**    D.输出空 

22.下列类定义中哪些是合法的抽象类的定义？ （C ）

A.abstract Animal{abstract void growl();}    B.class abstract Animal{abstract void growl();}

C **.abstract class Animal{abstract void growl();}** 

D.abstract class Animal{abstract void growl(){System.out.println(“growl”);};} 

23.设有下面两个赋值语句： 

a = Integer.parseInt(“12”);

b = Integer.valueOf(“12”).intValue(); B A

A.a 是整数类型变量， b 是整数类对象。B.a是整数类对象， b 是整数 类型变量。

C.a 和 b 都是整数类对象并且值相等。      D.a 和 b 都是整数类型变量并 且值相等。

```java

Integer.parseInt() 是 Java 中用于将字符串转换为整数类型的方法。

public class ParseIntExample {

    public static void main(String[] args) {

        String numberStr = "123";

        int number = Integer.parseInt(numberStr);

        System.out.println("Parsed integer: " + number);

    }

}

在上面的示例中，我们将字符串 "123" 解析为整数并将其存储在变量 number 中，然后将其打印出来。

请注意，如果传递给 parseInt() 的字符串无法解析为整数，将会抛出 NumberFormatException 异常。因此，在使用该方法时，最好将其包装在适当的异常处理代码块中，以确保程序能够处理异常情况。

```

24.为了使包 ch4在当前程序中可见，可以使用的语句是（A ）。

**A.import ch4.*;**     B.package ch4.*;C.ch4 import;     D.ch4 package;

/*

import ch4.*; // 导入 ch4 包中的所有类

import ch4.ExampleClass; // 导入 ch4 包中的 ExampleClass 类

 

 

*/

# 12

25.如下哪个是 Java中的标识符 (A )**A.fieldname**     B.super   C.3number    D.#number

```

A. fieldname：这是一个有效的标识符，可以用于命名变量等。

B. super：super 是 Java 关键字，用于引用父类的成员或构造方法，不能作为标识符使用。

C. 3number：标识符不能以数字开头，因此 3number 不是有效的标识符。

D. #number：标识符不能包含特殊字符，例如 #，因此 #number 也不是有效的标识符。

```

26.下面的代码段执行之后 count 的值是什么 ( D) 

int count = 1;

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

count += i;

}

System. out .println(count);

A.5.0     B.1.0  C.15.0     **D.16.0**

```java

for 循环是 Java 中用于重复执行特定代码块的一种控制结构。它通常用于遍历数组、集合或执行一定次数的循环操作。for 循环的语法如下：

java

Copy code

for (初始化语句; 循环条件; 循环迭代语句) {

    // 循环体，需要重复执行的代码

}

```

27.为 AB类的一个无形式参数无返回值的方法 method 书写方法头，使 得使用类名 AB作为前缀就可以调用它，该方法头的形式为 (A)。

A **.static void method( )**     B.public void method( ) C.final void method( )      D.abstract void method( )

28.下列程序段执行后的结果是 ( )。 **adg**

String s = new String("abcdefg");

for (int i=0; i<s.length(); i+=3){ 

System.out.print(s.charAt(i));

}

A.aceg      B.ACEGC.abcdefg      D.abcd 

29.下面程序段执行后 b 的值是 ( B)。

Integer integ =new Integer(9)；

boolean b = integ instanceof Object;

A.9.0    **B.true**   C.1.0     D.0

//Integer integ = Integer.valueOf(9);。

30.关于 for 循环和 while 循环的说法哪个正确？ （D ）

A.while 循环先判断后执行， for 循环先执行后判断。

B.while 循环判断条件一般是程序结果， for 循环的判断条件一般

是非程序结果

C.两种循环任何时候都不可以替换

**D.两种循环结构中都必须有循环体，循环体不能为空**

```

A. 这个说法是不准确的。在 while 循环中，先判断条件，如果条件为真，则执行循环体；在 for 循环中，也是先判断条件，如果条件为真，则执行循环体。

B. 这个说法也是不准确的。while 循环和 for 循环的判断条件都可以是程序结果，也可以是非程序结果。

C. 这个说法是不准确的。在某些情况下，for 循环和 while 循环是可以互相替换的，取决于问题的要求和编码习惯。不过，并非所有情况都可以直接替换。

总结起来，正确的是选项 D，两种循环结构中都必须有循环体，循环体不能为空。

```

31.关于对象成员占用内存的说法哪个正确？ （B）

A.同一个类的对象共用同一段内存

**B.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间**

C.对象的方法不占用内存

D.以上都不对

32.关于继承的说法正确的是： （B ）

A.子类将继承父类所有的属性和方法。

**B.子类将继承父类的非私有属性和方法。**

C.子类只继承父类 public 方法和属性

D.子类只继承父类的方法，而不继承属性

33.覆盖与重载的关系是 （A ）无正确答案

**A.覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中**

B.覆盖方法可以不同名，而重载方法必须同名

C.final 修饰的方法可以被覆盖，但不能被重载

D.覆盖与重载是同一回事

A. 类：覆盖只有发生在父类与子类之间，而方法：重载可以发生在同一个类中。

这是覆盖（方法重写）和重载的关系。让我们解释一下每个术语的含义：

类 覆盖（方法重写）：在子类中重新定义一个与父类中具有**相同名称、参数列表和返回类型**的方法，以改变方法的实现。覆盖是用于 **实现多态性** 的关键机制，它发生在父类和子类之间。

方法 重载（方法重载）：在同一个类中，可以定义多个同名的方法，但参数列表必须不同。重载是指在同一个类中创建多个具有相同名称但不同参数的方法。

所以，选项 A 描述了覆盖和重载之间的关系，正确答案是 A。其他选项的描述不准确：

B. 覆盖方法和重载方法必须具有相同的名称，但覆盖方法必须具有相同的**参数列表和返回类型**，而**重载方法的参数列表必须不同**。

C. 使用 final 修饰的方法不能被覆盖（重写），但是可以被重载。覆盖要求子类方法能够改变父类方法的实现，而 final 方法不能被改变。

final 关键字可以用于修饰方法，这将具有一些特定的含义和行为。当一个方法被 final 修饰时，它表示该方法不能在子类中被覆盖（重写）。这意味着在**子类中无法改变这个方法的实现。**

具体来说：

使用 final 修饰的方法不能在子类中被覆盖，这是因为 final 关键字表示该方法的实现不能被改变，以确保方法的行为在继承层次中保持一致。

虽然子类无法覆盖 final 方法，但是子类仍然可以继承该方法。这意味着子类可以调用该方法，但不能改变其实现。

这个特性有助于确保某些核心行为在继承层次中不被改变。在某些情况下，将方法标记为 final 可以提高代码的可靠性和安全性，防止在子类中无意间修改重要的行为。

总之，final 修饰的方法虽然不能被子类覆盖，但是可以被继承，子类可以调用这些方法。

```java

class Parent {

    final void printMessage() {

        System.out.println("This is the Parent's message.");

    }

}

class Child extends Parent {

    /* 无法覆盖 final 方法

    void printMessage() {

        System.out.println("This is the Child's message.");

    }*/

}

public class Main {

    public static void main(String[] args) {

        Parent parent = new Parent();

        parent.printMessage(); // 调用 Parent 的方法

        Child child = new Child();

        child.printMessage(); // 调用继承的 Parent 的方法

    }

}

```

D. 覆盖与重载是不同的概念，它们涉及不同的方法定义和调用方式。

*** 

34.不属于类及类成员的访问控制符的是 ( C)。

A.public  公开   B.private  类 **C.static**  static 关键字用于表示静态成员，而不是控制访问权限。这些成员与类本身关联，而不是与对象实例关联。

   D.protected 包 

   

   

35.为 AB 类的一个无形式参数无返回值的方法 method 书写方法头，使 得使用类名 AB 作为前缀就可以调用它，该方法头的形式为 (A )。

**A.static void method( )**    B.public void method( )C.final void method( )     D.abstract void method( )

36.关于选择结构下列哪个说法正确？ （B ）

A.if 语句和 else 语句必须成对出现**B.if 语句可以没有 else 语句对应**

C.switch 结构中每个 case语句中必须用 break 语句D.switch 结构中必须有 default 语句

37.while 循环和 do⋯while循环的区别是： （D ）

A.没有区别，这两个结构任何情况下效果一样 B.while 循环比 do⋯while循环执行效率高

C.while 循环是先循环后判断，所以循环体至少被执行一次      **D.do⋯while循 环是先循环后判断，所以循环体至少被执行一次**

38.下列修饰符中与访问控制无关的是 （D ）A.Private     B.public C.protected     **D.Final**

39.void 的含义： （A ）A.方法没有返回值     B.方法体为空C.没有意义      D.定义方法时必须使用

```java

D. Final

final 是一个修饰符，用于表示不可改变的、最终的概念。它可以应用于类、方法和变量，但与访问控制无关。在访问控制方面，final 并不影响访问权限，而是指示某些东西是最终的，不能再被修改。

其他选项的解释：

A. private：表示成员（字段、方法）只能在类内部访问，与访问控制有关。

B. public：表示成员可以在任何地方访问，与访问控制有关。

C. protected：表示成员可以在同一个包内和子类中访问，与访问控制有关。

D. final： 与访问控制无关，表示最终、不可改变的概念。

```

40.return 语句： （C ）

A.只能让方法返回数值     B.方法都必须含有   **C.方法中可以有多句 return**    D.不能用来返回对象

```java

return 语句用于在方法中提前返回结果，并终止方法的执行。以下是关于选项的解释：

A. return 语句不仅可以用于返回数值，还可以用于返回任何类型的数据，包括 **数值、对象、布尔值** 等。

B. 方法不必一定包含 return 语句。例如，void 类型的方法不需要返回值，可以没有 return 语句。但对于有返回类型的方法，必须包含至少一条 return 语句，确保在所有情况下都有返回值。

C. 方法中可以有多句 return： 一个方法可以包含多个 return 语句，每个用于不同的条件分支。方法在执行到某个 return 语句时会立即返回，并不会执行后续的代码。

D. return 语句可以用来返回对象。您可以在方法中使用 return 语句返回引用类型（对象）的实例。

public class ReturnExample {

    public static void main(String[] args) {

        int result1 = calculateValue(5);

        int result2 = calculateValue(10);

        System.out.println("Result 1: " + result1);

        System.out.println("Result 2: " + result2);

    }

    public static int calculateValue(int x) {

        if (x < 5) {

            return x * 2;

        } else if (x < 10) {

            return x + 3;

        } else {

            return x - 5;

        }

    }

}

```

41.下列说法哪个正确？C

A.不需要定义类，就能创建对象 B.对象中必须有属性和方法

**C.属性可以是简单变量，也可以是一个对象** D.属性必须是简单变量

42.关于方法 main（）的说法哪个正确？（ C）

A.方法 main（）只能放在公共类中B.main()的头定义可以根据情况任意更改

**C.一个类中可以没有 main()方法

】**

D.所有对象的创建都必须放在 main()方法中

43.构造函数何时被调用？ **（ A）A.创建对象时**     B.类定义时C.使用对象的方法时     D.使用对象的属性时 

**构造函数用于在创建对象时进行初始化操作**

44.关于构造函数的说法哪个正确？ （C ）

A.一个类只能有一个构造函数 B.一个类可以有多个不同名的构造函数

**C.构造函数与类同名**D.构造函数必须自己定义，不能使用父类的构造函数

```java

构造函数的特点包括：

构造函数的名字必须与类的名字完全相同，包括大小写。

构造函数没有返回类型，甚至没有 void。它们的目的是初始化对象，而不是返回值。

如果你不显式地定义构造函数，Java 会提供一个默认的无参数构造函数，但如果你定义了任何构造函数，Java 将不会提供默认的构造函数。

如果你想要多个构造函数，可以定义多个，它们可以拥有不同的参数列表，这称为构造函数的重载。

public class MyClass {

    private int value;

    // 构造函数

    public MyClass() {

        value = 0; // 初始化 value

    }

    // 构造函数重载

    public MyClass(int initialValue) {

        value = initialValue; // 使用传入的参数初始化 value

    }

}

```

45.this 和 super：B

A.都可以用在 main()方法中B.都是指一个内存地址

**C.不能用在 main()方法中**D.意义相同

//在 main() 方法中，不能使用 .this 和 super 关键字。

46.关于 super 的说法正确的是：B

A.是指当前对象的内存地址**B.是指当前对象的最近父类对象的内存地址**

C.是指当前对象最近的父类D.可以用在 main()方法中

47.关于接口哪个正确？ （ A）

**A.实现一个接口必须实现接口的所有方法** 当一个类实现了一个接口时，它必须提供接口中定义的所有方法的具体实现，否则会导致编译错误。

B.一个类只能实现一个接口

C.接口间不能有继承关系D.接口和抽象类是同一回事

48.对于已经被定义过可能抛出异常的语句，在编程时： （A ）

**A.必须使用 try／catch 语句处理异常，或用 throws 将其抛出**

B.如果程序错误，必须使用 try／catch 语句处理异常

C.可以置之不理

D.只能使用 try／catch 语句处理

49.给出下列代码片段：（D ）

if(x>0){System.out.println("first");}

else if(x>-3){ System.out.println("second");}

else {System.out.println("third");}

请问 x 处于什么范围时将打印字符串“ second”?A.x>0    B.x>-3C.x<=-3   **D.x<=0 &&x>-3**

50.在 Java中，一个类可同时定义许多同名的方法， 这些方法的形式参数 的个数、类型 

或顺序各不相同，传回的值也可以不相同，这种面向对象程序特性称为：

（C ）A.A、隐藏B.B、覆盖C.**C、重载**D.D、Java不支持此特性

51.如要抛出异常，应用下列哪种子句？（C ）A.catch    B.throw    **C.throws**    D.finally

/*

A. catch：用于捕获并处理异常。在 try 块中，可以使用 catch 块来捕获特定类型的异常，并执行相应的处理代码。

B. throw：用于在代码中手动抛出异常。通过 throw 关键字，可以抛出自定义的异常或者标准库中的异常类的实例。

C. throws：用于在方法签名中声明可能会抛出的异常。当一个方法可能会抛出某种异常时，可以使用 throws 关键字在方法声明中列出可能的异常类型。

D. finally：用于定义一个 finally 块，该块中的代码无论是否发生异常都会执行。通常在 try 块中的代码执行后，无论是否发生异常，finally 块中的代码都会被执行，用于执行清理操作等。

*/

52.在使用 interface 声明一个接口时，只可以使用 ____修饰符修饰该接口。 （ D）

A.private   B.protectedC.private protected     **D.public**

53.下列代码的输出结果是 ： （A ）

class Parent{

void printMe() { 

System.out.println("parent");

}

}；

class Child extends Parent {

void printMe() { 

System.out.println("child");

}

void printall() { 

super.printMe();

this.printMe(); 

printMe();

}

}

public class Test_this {

public static void main(String args[]) {

Child myC=new Child(); 

myC.printall();

}

}

**A.parent

child 

child**

     B.parent

 child

parent 

C.parent

child 

     D.编译错误

     

     

     

     

54.

注释的基本原则不包括： （D ）A.注释应该增加代码的清晰度      B.注释要简洁

C.在写代码之前写注释 **D.尽量给每一条语句加注释**

55.下列不可作为java语言修饰符的是A. a1     B.1.0 **C.  _1**      D.11.0 C 

56.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是**A.a1.java 

//主类的名称与文件名保持一致**     B.a1.classC.a1       D.都对 A

57.整型数据类型中，需要内存空间最少的是A.short             B.long         C.int                  **D. byte** 

58.Java中 C

A.一个子类可以有多个父类，一个父类也可以有多个子类     B.一个子类可以有多个父类，但一个父类只可以有一个子类

**C.一个子类可以有一个父类，但一个父类可以有多个子类**     D.上述说法都不对

59.在创建对象时必须 C

A.先声明对象，然后才能使用对象     B.先声明对象，为对象分配内存空间，然后才能使用对象

**C.先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象**   D.上述说法都对 

60.在调用方法时，若要使方法改变实参的值，可以 B

A.用基本数据类型作为参数     **B.用对象作为参数**C.A和B都对     D.A和B都不对

在 Java 中，如果你想让方法改变实参的值，可以使用对象作为参数（选项 B）。基本数据类型作为参数传递给方法时，传递的是值的副本，而不是引用，所以无法在方法内部修改实参的值。但是，通过传递对象作为参数，方法可以修改对象的内部状态，从而影响实参。

61.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？B

A.安全性     **B.多线程**C.跨平台     D.可移植

62.以下声明合法的是 B BD

A.default  String  s；    **B.public  final  static  native  int  w( ) ;**

C.abstract  double  d；     D.abstract  final  double  hyperbolicCosine( );

. public final static native int w();：这是一个合法的声明，它表示一个 public 访问修饰符的、final 和 static 修饰符的、native 方法，返回类型为 int。

***

D. abstract final double hyperbolicCosine();：这也是一个合法的声明，尽管有点不寻常。这表示一个抽象的、final 修饰符的、返回类型为 double 的方法。

选项 A 和 C 都是不合法的：

A. default String s;：Java 中不允许使用 default 关键字来声明变量。

C. abstract double d;：抽象方法通常是在接口中声明的，而不是在类中。在类中声明抽象方法必须使用 abstract 关键字并提供方法体。

所以，选项 B 和 D 是合法的声明。

63.关于以下程序段，正确的说法是（  C  ）

 1．  String  s1=”abc”+”def”; 

2．  String  s2=new  String（s1）；

 3．  if（s1= =s2）  //false  new String(s1) 创建的一个新的字符串对象，内容与 s1 相同，但是它在堆内存中分配了新的内存空间。 s1 是通过字符串拼接得到的，因此它会指向字符串常量池中的 "abcdef"

4．     System.out.println(“= = succeeded”);  

5．  if (s1.equals(s2))  

6．     System.out.println(“.equals()  succeeded”); 

A.行4与行6都将执行      B.行4执行，行6不执行**C.行6执行，行4不执行**       D.行4、行6都不执行

64. Java application中的主类需包含main方法，main方法的返回类型是什么？D

A.int         B.float         C.double           **D.void**

65. 以下标识符中哪项是不合法的**A.final**     B.$double  C.hello             D.BigMeaninglessName A

 

66. 在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为A.隐藏     B.覆盖**C.重载**     D.Java不支持此特性 C

 

67. 以下关于构造函数的描述错误的是 A

**A.构造函数的返回类型只能是void型。**     B.构造函数是类的一种特殊函数，它的方法名必须与类名相同。

C.构造函数的主要作用是完成对类的对象的初始化工作。     D.一般在创建新对象时，系统会自动调用构造函数。

68. 下列哪些语句关于Java内存回收的说明是正确的? B

A.程序员必须创建一个线程来释放内存     B**内存回收程序负责释放无用内存**

C.内存回收程序允许程序员直接释放内存      D.内存回收程序可以在指定的时间释放内存对象

69.下面为应用程序入口的main方法的是? A

**A.public static void main(String[] args)**    B.public static int main(String[] args)

C.public void main(String[] args)     D.public int main(String[] args)

70.public class Test {

 public static void main() {

  System.out.print("aaa");

 }

}

下面说法正确的是? A

**A.程序无法通过编译，因为main方法声明方式不对**     B.程序可以通过编译，但运行程序行，会提示没有找到main方法的异常

C.程序正常运行，并输出aaa     D.程序可以编译，但无法运行，因为该文件没有public类

71.public class Test {

 static void main(String[] args) {

  System.out.print("aaa");

 }

}

下面说法正确的是? A

**A.程序无法通过编译，因为main方法声明方式不对 找不到 main 方法**    B.程序可以通过编译，但运行程序行，会提示"Main method not public"的异常

C.程序正常运行，并输出aaa     D.程序可以编译，但无法运行，因为该文件没有public类

72.不可以用作变量名的首字符是? C

A.字母     B.下划线**C.数**字     D.美元符号

73.下面哪个语句会产生编译错误?**A.float a = 2.0** //浮点数f    B.double b = 2.0  C.int c=2     D.long d=2 A

74.哪个语句不会出现编译错误?A.float f= 1.3 // 浮点数必须f。   B.char c = "a"  单引号  **C.byte b = 25**     D.boolean d = null 

75.哪个语句会出现编译错误? **A.byte b=1234** -127 128   B.long b=2C.int c=3     D.boolean d = true 

76.哪个语句会出现编译错误?A.byte b=12     B.long b=2 **C.char b = 'bc'**   D.boolean d = true 

77.下面哪句能通过编译?C  A.float a = 1  //int强转  B.float b =1.0  **C.char b = 'bc'**   D.boolean d = null A

78.执行完下面的程序，哪个结论是正确的?   133

 int a,b,c;

 a = 1; 

 b = 2;

 c = (a + b >3 ? a++ : ++ b)

A.a为2,b为3     **B.a为1,b为3**  C.a为1,b为2     D.c的值为false

79.执行完下面的程序，输出什么? D B

int a = 3;

 int b = 1;

 if(a=b)

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

A.a=1     B.a=3C.编译错误，没有输出     **D.正常运行，但没有输出**

80.下面哪个调用方法的结论是正确的? B

public void method(boolean a ,boolean b)

{

  if(a)

   System.out.println("A");

  else if(a && b)

  else{

    if(!b)

     System.out.println("notB");

    else

     System.out.println("ELSE");

  } 

} 

A.输出"A&&B"     B.**输出"notB"**

C.,输出"ELSE"     D.输出"ELSE"

81.可以用作switch表达式的基本数据类型是? C

A.char,byte,short,float     B.char,int,long,short

**C.char,short,int,byte**     D.float,double,int,byte

82. C A **实际D**

public class Test {

 public static void main(String[] args) {

  byte i=1;

  while(++i > 0)

   ;

  System.out.print("Loop");

 }

} 

A.运行程序会进入死循环，永远不会退出     B.程序有编译错误

C.每运行一次程序，会输出多次"Loop"     **D.每运行一次程序，会输出一次Loop，并退出**

```java

在给定的代码示例中，while 循环条件 ++i > 0 在每次循环迭代中将 i 增加 1，然后判断 i 是否大于 0。由于 byte 类型的范围是 -128 到 127，在循环执行过程中，i 的值会从 1 增加到 127，然后再自增 1，变为 -128。此时 -128 > 0 条件不满足，循环会退出。

因此，每次运行程序，会输出一次 "Loop"，然后退出循环。我之前的解释是错误的，对此混淆感到抱歉。

```

83.关于下面程序，哪个选项是正确的？**C**   A 报错

//会出现一个编译错误，因为 mb_isOdd 方法的返回类型是 int，而在 if 语句中需要一个布尔表达式。

public class Test {

 public static int mb_isOdd(int x){

  return (x % 2);

 }

 public static void main(String[] args) {

  if(mb_isOdd(3)){

   System.out.print("3 is odd.");

  }else{

   System.out.print("3 is even.");

  }

 }

} 

A.程序输出"3 is odd"     B.程序输出"3 is even"**C.程序无法通过编译**     D.程序可以编译，但无法运行

84.下面中哪两个可以在A的子类中使用：（D ）

class A {

protected int method1 (int a, int b) {

return 0;

}

}

A. public int method 1 (int a, int b) { return 0; }

B. private int method1 (int a, int b) { return 0; }

C. private int method1 (int a, long b) { return 0; }

A.AC     B.AB

C.AD     D.BC

85.下列关于修饰符混用的说法，错误的是（B ）：D

A.abstract不能与final并列修饰同一个类 

**B.abstract类中可以有private的成员**

抽象类的成员，包括字段和非抽象方法.在一个抽象类中，可以有 private 的成员，但是不能有 private 的抽象方法。

C.abstract方法必须在abstract类中D.static方法中能处理非static的属性

86.执行完以下代码int [ ] x = new int[25]；后，以下哪项说明是正确的（A）：

**A.x[24]为0**     B.x[24]未定义  C.x[25]为0     D.x[0]为空

87.编译运行以下程序后，关于输出结果的说明正确的是 （B ）：

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.编译错误

88.class HasStatic{

 private static int x=100;

 public static void main(String args[ ]){

  HasStatic hs1=new HasStatic( );

  hs1.x++;

  HasStatic hs2=new HasStatic( );

  hs2.x++;

  hs1=new HasStatic( );

  hs1.x++;

  HasStatic.x--;

  System.out.println("x="+x);

 }

} A B

在给定的代码示例中，静态变量 x 是在一个共享的内存地址上的。无论通过哪个实例或类来访问这个静态变量，都是在操作同一个内存地址上的值。这就是静态变量的特性，它在整个类的所有实例之间共享状态，而不是每个实例都有自己的副本。所以，无论通过哪个实例修改 x 的值，都会影响到所有其他实例和类对 x 的访问。

A. 程序通过编译，输出结果为：x=99     B. 程序通过编译，输出结果为：x=101 

C.程序通过编译，输出结果为：x=103    **D.程序通过编译，输出结果为：x=102**

89.下列说法正确的是（C）

A.class中的constructor不可省略     B.constructor必须与class同名，但方法不能与class同名

**C.constructor在一个对象被new时执行****造函数通常用于执行对象的初始化操作，为对象的成员变量设置初始值等。**     D.一个class只能定义一个constructor

90.下列哪一种叙述是正确的（ D）

A. abstract修饰符可修饰字段、方法和类     B.抽象方法的body部分必须用一对大括号{ }包住

C.声明抽象方法，大括号可有可无     **D.声明抽象方法不可写出大括号**

91.Java语言中，String类的IndexOf()方法返回的类型是？A.Int16     B.Int32**C.int**  D.long C

92.执行下列代码后,哪个结论是正确的 String[] s=new String[10]; A

**A. s[9] 为 null;**   B.s[10] 为 “”;C. s[0] 为 未定义     D.s.length 为9

93.以下关于面向对象概念的描述中，不正确的一项是（B）。

A.在现实生活中，对象是指客观世界的实体    **B.程序中的对象就是现实生活中的对象**

C.在程序中，对象是通过一种抽象数据类型来描述的，这种抽象数据类型称为类（class）     D.在程序中，对象是一组变量和相关方法的集合

94.属性的可见性没有哪个选项 C

A.公有的     B.私有的  **C.私有保护的**    D.保护的

95.在字符串前面加上_____符号，则字符串中的转义字符将不被处理B A

A.@     **B.\ 。** C.#     D.%

96.下列哪个语句关于内存回收的说明是正确的。 B

A.程序员必须创建一个线程来释放内存    **B.内存回收程序负责释放无用内存**

C.内存回收程序允许程序员直接释放内存     D.内存回收程序可以在指定的时间释放内存对象

97.在下面程序的第6行补充上下列哪个方法,会导致在编译过程中发生错误? A B

1) class Super{

2) public float getNum(){

3) return 3.0f;

4) }

}

5) public class Sub extends Super{

6)

7) }

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.0f ;} 

（重写）从父类继承的方法，以便子类可以根据自己的需求重新定义方法的行为。在覆盖过程中，子类必须保持方法签名（名称、参数列表和返回类型）与父类方法一致。通过覆盖，子类可以为继承的方法提供不同的实现，从而定制其行为，而不会影响父类或其他可能使用父类方法的类。

98.下面关于import, class和package的声明顺序哪个正确？( A) 

**A.package, import, class**   B.class, import, package

C.import, package, class     D.package, class, import

99.下面哪个是正确的？(D )

A.String temp [] = new String {“a” “b” “c”};     B.String temp [] = {“a” “b” “c”}

C.String temp = {“a”, “b”, “c”}     **D.String temp [] = {“a”, “b”, “c”}**

```java

使用new 创建一个包含字符串的数组

public class StringArrayExample {

    public static void main(String[] args) {

        // 创建一个包含字符串的数组

        String[] stringArray = new String[4];

        stringArray[0] = "apple";

        stringArray[1] = "banana";

        stringArray[2] = "orange";

        stringArray[3] = "grape";

        // 遍历并打印数组中的每个元素

        for (String fruit : stringArray) {

            System.out.println(fruit);

        }

    }

}

```

100.关于java.lang.String类，以下描述正确的一项是（A ）

**A.String类是final类故不可以继承；**     B.String类是final类故可以继承；

C.String类不是final类故不可以继承；     D.String类不是final类故可以继承；

**String 类被设计为 final 类，这意味着它不能被继承，无法作为其他类的父类。** 

101.接口是Java面向对象的实现机制之一，以下说法正确的是：(B )

A. Java支持多重继承，一个类可以实现多个接口；     **B.Java只支持单重继承，一个类可以实现多个接口；**

C.Java只支持单重继承，一个类只可以实现一个接口；     D.Java支持多重继承，但一个类只可以实现一个接口。

102.下列关于interface的说法正确的是：(D )

A.interface中可以有private方法     B.interface中可以有final方法

C.interface中可以有function实现      **D. interface可以继承其他interface**

```java

是关于 Java 接口的正确描述。让我解释其他选项的含义：

A. interface 中不能有 private 方法。在 Java 9 之后，接口中可以有 private 方法，但这些方法必须是静态的，而且只能在接口内部使用，不能被实现类实现或直接调用。

B. interface 中不能有 final 方法。**接口中的方法默认是抽象的，**不需要使用 abstract 或 final 关键字进行修饰。

C. interface 中可以有方法的声明，但实际的方法实现是在实现这个接口的类中完成的。Java 8 之后，接口中也可以有默认方法和静态方法的实现。

D. interface 可以继承其他 interface： Java 中的接口可以通过 extends 关键字继承其他接口。这使得接口之间可以建立继承关系，以便在子接口中扩展父接口的声明。

```

103.以下程序正确的输出是（A ）

package test;

public class FatherClass {

public FatherClass() {

System.out.println(“FatherClass Create”);

}

}

package test;

import test.FatherClass;

public class ChildClass extends FatherClass {

public ChildClass() {

System.out.println(“ChildClass Create”);

}

public static void main(String[] args) {

FatherClass fc = new FatherClass();

ChildClass cc = new ChildClass();

}

}

**A.FatherClass Create

FatherClass Create

ChildClass Create**

B.FatherClass Create

ChildClass Create

FatherClass Create

C.ChildClass Create

ChildClass Create

FatherClass Create     D.ChildClass Create

FatherClass Create

FatherClass Create

104.给定如下代码，下面哪个可以作为该类的构造函数 (B )

public class Test {

}

A.public void Test() {?}     **B. public Test() {?}** C.public static Test() {?}     D.public static void Test() {?}

105.提供Java存取数据库能力的包是（A）

A.java.sql     B.java.awt C.java.lang     D.java.swing

A. java.sql 是提供 Java 存取数据库能力的包。这个包包含了用于连接和操作数据库的类和接口，可以用于执行数据库查询、插入、更新等操作。

B. java.awt 是**用于创建图形用户界面（GUI**的抽象窗口工具包，与数据库操作无关。

C. java.lang 包含了 Java 语言的核心类，**如基本数据类型、异常类**等，也与数据库操作无关。

D. java.swing 是用于创建图形用户界面（GUI）的一种工具包，是 AWT（java.awt）的补充，也与数据库操作无关。