Java错题集

Mid 囧

已于 2024-06-30 18:32:08 修改

阅读量963

点赞数 7

文章标签： java 开发语言

于 2024-06-30 15:43:39 首次发布

本文链接：https://blog.youkuaiyun.com/qq_53450702/article/details/140070423

版权

阿里初级开发认证

认证题目20个选择，单选加多选。

以下为两套题节选。

第一套（节选）

正确答案：B

这个题目有问题吧？（可能）

解析：在JSP中，out对象的作用是输出内容到客户端。这包括将HTML、文本、变量的值等内容发送到浏览器。

3.下列说法正确的一项是？

A. java.lang.Integer是接口

B. String定义在java.util包中

C. Double类在java.lang包中

D. Double类在java.lang.Object包中

答案：C

4.DDL是什么？

A. Data definition language

B. Data demand language

C. Data defense language

D. Database definition language

答案：D

5.下面的数据声明及赋值哪一个是正确的？

A. float f = 1.3;

B. char c =

C. byte b = 257

D. int i = 10

答案：D

解释：

选项 A 错误，因为在Java中，浮点数默认是 double 类型，要将其赋值给 float 变量，需要在数字后面加上 f，如 float f = 1.3f;。
选项 B 错误，因为没有为 char 变量赋值。char 类型的值需要用单引号括起来，如 char c = 'a';。
选项 C 错误，因为 byte 类型的范围是 -128 到 127，而 257 超出了这个范围。
选项 D 正确，声明了一个 int 类型的变量并赋值为 10。

6.下面代码存在什么问题？ public class MyClass {

public static void main(String arguments[]) {

amethod(arguments); }

public void amethod(String[] arguments){ System.out.println(arguments); System.out.println(arguments[1]);

} }

A. 错误，void amethod()不是static类型

B. 错误，main()方法不正确

C. 错误，数组必须导入参数

D. 方法amethod()必须用String类型描述

代码的问题是 amethod 方法不是静态方法，而它在静态上下文中被调用。这意味着 amethod 方法需要声明为静态方法，或者需要通过类的实例来调用。

正确答案是：A.

解决方案是将 amethod 方法声明为静态方法：

public class MyClass {
public static void main(String arguments[]) {
amethod(arguments);
}

public static void amethod(String[] arguments) {
System.out.println(arguments);
System.out.println(arguments[1]);
}
}
或者通过实例来调用 amethod 方法：

public class MyClass {
public static void main(String arguments[]) {
MyClass obj = new MyClass();
obj.amethod(arguments);
}

public void amethod(String[] arguments) {
System.out.println(arguments);
System.out.println(arguments[1]);
}
}

假设有如下程序：

public class Demo {

public static void main(String args[]) {

int x = 10 ;

double y = 20.2 ;

long z = 10L;

String str = "" + x + y * z ;

System.out.println(str) ;

} }

最终执行结果是什么？

A. 10202.0

B. 0212.0

C. 302

D. 1020.21

正确答案是：A.

让我们分析一下程序的执行步骤：

int x = 10; 声明一个整型变量 x 并赋值为 10。
double y = 20.2; 声明一个双精度浮点型变量 y 并赋值为 20.2。
long z = 10L; 声明一个长整型变量 z 并赋值为 10。
String str = "" + x + y * z; 中，首先计算 y * z，即 20.2 * 10，结果为 202.0。然后，"" + x + 202.0，由于字符串的连接特性，结果为 "10202.0"。
System.out.println(str); 打印 str，即 "10202.0"。

8.定义类时不可能用到的关键字是？

A. final

B. public

C. protected

D. static

正确答案是：C

9.servlet接口上传文件的对象是?

A. MultiRequest

B. PartRequest

C. MultiParRequest

D. MultiPartRequest

正确答案是：D。

10.XML是什么?

A. eXtensible Markup Language

B. 扩展标点语言

C. 扩展标记语言

D. 扩展标记清除语言

正确答案是：A. C

11.关于Servlet的Listener，下列说法正确的是？

A. 全称event listeners

B. 监听特殊的事件

C. 可以执行特殊的代码

D. 监听器定义在JSP中

正确答案是：B. C

解释：

A. 不完全正确。Listener 也可以称为事件监听器，但它们的全称更常见的是“Servlet Event Listeners”。
B. 正确，Listener 用于监听特殊的事件，例如会话创建和销毁、请求到达和离开等。
C. 正确，Listener 可以在捕获到特定事件时执行相应的代码。
D. 错误，Listener 通常定义在 Java 类中，并在 web.xml 中配置，而不是在 JSP 中定义。

12.Maven的仓库分为哪两大类（）

A. 本地仓库

B. 私服

C. 中央仓库

D. 远程仓库

正确答案是：B. D

13.下面那个父类或父接口是无法实现多线程子类定义的？

A. Serializable

B. Thread

C. Runnable

D. Callable

正确答案是：A

14.SQL如何创建一个表？

A. CREATE SQLTABLE table1 (c1 datatype,c2 datatyp;

B. CREATE MyTABLE table1 (c1 datatype,c2 datatyp;

C. CREATE DataTABLE table1 (c1 datatype,c2 datatyp;

D. CREATE TABLE table1 (c1 datatype,c2 datatyp;

正确答案是：D

15.假设有如下程序： public class Demo {
public static void main(String args[]) {
char c = 'A';
int num = 10;
switch(c) {
case 'B':
num++;
case 'A':
num++;
case 'Y':
num++;
break;
default:
num--;
}
System.out.println(num);
}
}

最终执行结果是什么？

A. 11

B. 13

C. 12

D. 10

正确答案是：B

char c = 'A'; 声明一个字符变量 c 并赋值为 'A'。
int num = 10; 声明一个整型变量 num 并赋值为 10。
switch(c) 语句根据 c 的值来决定执行哪个 case 块。这里 c 的值是 'A'，所以执行 case 'A': 之后的代码。

执行顺序如下：

case 'A': 匹配，因此执行 num++;，此时 num 变为 11。
执行下一个语句 num++;，此时 num 变为 12。
执行 case 'Y': 中的 num++;，此时 num 变为 13。
遇到 break; 语句，跳出 switch 语句块。

最终输出 num 的值，即 13。

第二套（节选）

1.JDBC使用哪个执行预编译SQL？

A. PreparedStatement

B. PreStatement

C. CallableStatement

D. CallStatement

正确答案是：A

2.finally块中的代码什么时候被执行？

A. 总是被执行

B. 如果try块后面没有catch块时，finally块中的代码才会执行

C. 异常发生时才被执行

D. 异常没有发生时才执行

正确答案是：A

假设有如下程序：

public class Demo {

public static void main(String args[]) {

int num = 2147483647 ;

long temp = num + 2L ;

System.out.println(temp) ;

} }

最终的执行结果是什么？

A. -2147483648

B. 2147483649

C. 2147483647

D. 2

正确答案是：B

int num = 2147483647; 声明一个整型变量 num 并赋值为 2147483647，这是 int 类型的最大值。
long temp = num + 2L; 中，由于 2L 是 long 类型，所以 num 会先被提升为 long 类型，然后进行加法操作。这避免了 int 类型的溢出问题。

计算过程如下：

num 是 2147483647，类型提升后变为 2147483647L。
2147483647L + 2L 计算结果为 2147483649L。

System.out.println(temp); 打印 temp 的值，即 2147483649L。

4.MyBatis用于操作数据库的核心对象是？

A. SqlStatement

B. SqlSessionFactory

C. SqlSession

D. Connetion

正确答案是：C

5.Spring中注解@Repository的作用表述准确的是？

A. 一个可以被Spring管理的Bean组件，用于控制器层

B. 一个可以被Spring管理的Bean组件，用于表现层

C. 一个可以被Spring管理的Bean组件，用于业务层

D. 一个可以被Spring管理的Bean组件，用于DAO层

正确答案是：D

6.如果要实现多线程编程下面那项描述是错误的？

A. 多线程处理类可以继承Thread类，同时覆写run()方法

B. 多线程处理类可以实现Runnable接口，同时覆写run()方法

C. 多线程处理类可以实现java.util.concurrent.Callable接口，同时覆写call()方法

D. 多线程处理类可以继承Synchronized类，同时覆写run()方法

正确答案是：D

7.class Happy {
public static void main(String args[]) {
int i = 1;
int j = i++; // j = 1, i = 2
if ((i == (++j)) && ((i++) == j)) {
i += j;
}
System.out.println("i = " + i);
}
}运行完上面代码之后输出i的值是多少？

A. 4

B. 5

C. 3

D. 6

正确答案：B

步骤解析：

初始化 i 为 1。
int j = i++;
- j 被赋值为 1（即 i 的初始值）。
- i 随后递增为 2。
条件判断 if ((i == (++j)) && ((i++) == j)):
- ++j 先自增 j，然后 j 变为 2，所以 (i == (++j)) 等价于 (2 == 2)，为 true。
- 由于逻辑 AND 运算符 && 的特性，如果第一个条件为 true，继续评估第二个条件。
- 第二个条件 ((i++) == j):
  - i++ 先使用 i 的当前值 2，然后 i 增加到 3。
  - 2 == 2，条件为 true。

由于两个条件都为 true，所以进入 if 块： 4. i += j:

i 的当前值为 3。
j 的当前值为 2。
i += j 等价于 i = i + j，即 3 + 2 = 5。

最后，输出 i 的值为 5。

因此，最终的输出是：

B. 5

8.Spring IOC常见的方式有哪些？

A. 构造函数

B. 接口注入

C. Setter器注入

D. 对象注入

答案：ABC

解析：

构造函数注入（Constructor Injection）：通过构造函数将依赖对象传递给类。构造函数注入在对象创建时进行依赖注入，因此具有较好的不可变性。

public class Example {
private final Dependency dependency;

public Example(Dependency dependency) {
this.dependency = dependency;
}
}
在Spring配置中：

2.接口注入（Interface Injection）：通过接口方法注入依赖。Spring官方不推荐这种方式，因为它会强制类实现特定的接口，从而增加了耦合度。

示例：

public interface DependencyInjector {
void injectDependency(Dependency dependency);
}

public class Example implements DependencyInjector {
private Dependency dependency;

@Override
public void injectDependency(Dependency dependency) {
this.dependency = dependency;
}
}

3. Setter方法注入（Setter Injection）：通过setter方法将依赖对象传递给类。这种方式比较灵活，允许在对象实例化后进行依赖注入。

示例：

public class Example {
private Dependency dependency;

public void setDependency(Dependency dependency) {
this.dependency = dependency;
}
}
在Spring配置中：

对象注入 不是标准的术语，可能指的是通过构造函数或setter方法注入具体的对象实例，因此它不算是一种单独的注入方式。

9.class super {
String name;

public super(String name) {
this.name = name;
}

public void fun1() {
System.out.println("this is class super !" + name);
}
}

class sub extends super {
public sub(String name) {
super(name);
}

public void fun1() {
System.out.println("this is class sub !" + name);
}
}

class Test {
public static void main(String args[]) {
super s = new sub("example");
s.fun1();
}
}运行上面的程序可能会出现的结果？

A. this is class super ! B. this is class sub ! C. 编译时出错 D. 运行时出错

答案：C

类名冲突：
- super 是 Java 的关键字，不能用作类名。这会导致编译错误。
子类构造函数：
- 子类 sub 没有调用父类 super 的构造函数。如果没有父类无参构造函数，编译时也会出错。

分析原始代码

原始代码中，子类 sub 没有显式调用父类的构造函数，这会导致编译错误，因为父类 super 没有无参构造函数。并且使用了关键字 super 作为类名也是错误的。

修正代码

将类名 super 改为 SuperClass，并在子类 SubClass 的构造函数中调用父类的构造函数。

- class SuperClass {
  String name;
  
  public SuperClass(String name) {
  this.name = name;
  }
  
  public void fun1() {
  System.out.println("this is class super !" + name);
  }
  }
  
  class SubClass extends SuperClass {
  public SubClass(String name) {
  super(name); // 调用父类的构造函数
  }
  
  public void fun1() {
  System.out.println("this is class sub !" + name);
  }
  }
  
  class Test {
  public static void main(String args[]) {
  SuperClass s = new SubClass("example");
  s.fun1();
  }
  }
- 详细解释
- 父类 SuperClass：
  - 包含一个带参数的构造函数 SuperClass(String name)。
  - 包含一个方法 fun1()，打印 name。
- 子类 SubClass：
  - 继承自 SuperClass。
  - 包含一个带参数的构造函数 SubClass(String name)，其中通过 super(name) 调用父类的构造函数。
  - 重写了 fun1() 方法，打印子类特定的消息。
- 测试类 Test：
  - 在 main 方法中，创建一个 SuperClass 类型的引用 s，指向 SubClass 的实例。
  - 调用 s.fun1()，因为 s 实际上是 SubClass 的实例，所以调用的是 SubClass 中重写的 fun1 方法。

运行结果

- 当运行上述修正后的代码时，输出结果是：this is class sub !example

10.Spring中注解@Qualifier的作用表述准确的是？

A. 此注解表示by name自动注入时，可以使用此注解显示配置

B. 此注解表示by Type自动注入时，可以使用此注解显示配置

C. 此注解表示无参自动注入时，可以使用此注解显示配置

D. 此注解表示构造函数自动注入时，可以使用此注解显示配置

运行结果

B. 此注解表示by Type自动注入时，可以使用此注解显示配置

详细解释

当Spring容器中有多个相同类型的bean时，使用 @Autowired 注解可能会导致Spring不知道该注入哪一个bean。这时，可以使用 @Qualifier 注解来指定具体的bean。

示例

假设有两个bean，类型相同但名称不同：

@Component("beanA")
public class MyBean implements MyInterface {
// ...
}

@Component("beanB")
public class MyBean implements MyInterface {
// ...
}
如果需要注入 beanA，可以使用 @Qualifier 注解指定：

@Component
public class MyService {

private final MyInterface myBean;

@Autowired
public MyService(@Qualifier("beanA") MyInterface myBean) {
this.myBean = myBean;
}
}
或者在字段注入时：

@Component
public class MyService {

@Autowired
@Qualifier("beanA")
private MyInterface myBean;

// ...
}

作用

解决歧义：当有多个相同类型的bean时，使用 @Qualifier 指定要注入的bean。
增强灵活性：结合 @Autowired 注解，可以灵活地选择具体的bean进行注入。

因此， @Qualifier 注解主要用于by Type自动注入时，显示地配置注入的bean。

11.Spring Bean @Autowired自动装配有哪几种方式?

A. no无需参数

B. byName根据bean名字

C. byType根据类型

D. constructor构造函数

E. autodetect自动装配

正确答案

B. byName根据bean名字 C. byType根据类型 D. constructor构造函数

详细解释

1.byName 根据bean名字：

Spring会根据属性名或参数名来匹配相应的bean并进行注入。
- 这种方式不需要额外的注解，只需确保bean的名称和属性或参数的名称一致。
byType 根据类型：
- Spring会根据属性的类型或构造函数参数的类型来匹配相应的bean并进行注入。
- 这是 @Autowired 的默认行为。
constructor 构造函数：
- 使用构造函数来进行依赖注入。Spring会自动匹配构造函数参数类型并注入相应的bean。
- 可以在构造函数上使用 @Autowired 注解，明确表示这是Spring要使用的构造函数。

@Component
public class MyService {

@Autowired
private MyRepository myRepository;

// ...
}

byName

假设有两个同类型的bean：

@Component("myRepository1")
public class MyRepository {
// ...
}

@Component("myRepository2")
public class MyRepository {
// ...
}
注入时指定bean名字：

@Component
public class MyService {

@Autowired
@Qualifier("myRepository1")
private MyRepository myRepository;

// ...
}
constructor

@Component
public class MyService {

private final MyRepository myRepository;

@Autowired
public MyService(MyRepository myRepository) {
this.myRepository = myRepository;
}

// ...
}

综上所述

在Spring中，@Autowired 自动装配主要有以下几种方式：