java笔试练习题笔记（5）

梦影666

已于 2024-11-16 15:22:00 修改

阅读量1k

点赞数 14

分类专栏： java笔试练习题笔记文章标签： java 开发语言 spring boot 笔记 spring servlet

于 2024-11-10 18:28:00 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_62526393/article/details/143662856

版权

java笔试练习题笔记专栏收录该内容

11 篇文章

订阅专栏


下列关于一个类的静态成员的描述中，不正确的是
A.该类的对象共享其静态成员变量的值
B.静态成员变量可被该类的所有方法访问
C.该类的静态方法能访问该类的静态成员变量
D.该类的静态数据成员变量的值不可修改

答案解析：静态方法里只能访问本类方法中的静态成员，不能直接访问非静态的属性和方法。这是因为静态方法不依赖于对象，所以当类加载成功后，静态方法就可以访问了。而此时的对象不一定存在，非静态成员自然也不一定存在。而且即使存在非静态成员，静态方法也不知道访问哪一个对象的成员。静态方法中也不能出现this关键字，因为this是针对对象而言的。本类中的非静态方法可以访问本类的静态属性，也可以调用静态方法。类的静态成员变量只有在类加载的时候，初始化一次，但可以修改。

一个文件中的数据要在控制台上显示，首先需要（ ）。

A.System.out.print (buffer[i]);
B.FileOutputStream fout = new FileOutputStream(this.filename);
C.FileInputStream fin = new FileInputStream(this.filename);。
D.System.in.read(buffer)。

答案解析：inputStream是读取出文件内容 outputStream是向文件写入内容， out和in从程序的角度看，out是从程序里出去的数据，in是进入到程序的数据。这是对FileOutputStream和FileInputStream的区分记忆。要输出需要先输入。

当我们需要所有线程都执行到某一处，才进行后面的的代码执行我们可以使用？
A.CountDownLatch
B.CyclicBarrier
C.Semaphore
D.Future

答案解析：

AB：在百米赛跑的比赛中若使用 countDownLatch的话冲过终点线一个人就给评委发送一个人的成绩，10个人比赛发送10次，如果用CyclicBarrier，则只在最后一个人冲过终点线的时候发送所有人的数据，仅仅发送一次，这就是区别。
C.Semaphore 通常我们叫它信号量，可以用来控制同时访问特定资源的线程数量，通过协调各个线程，以保证合理的使用资源。

D.future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。

正则表达式中，表示匹配非数字字符的字符是（）
A.\b
B.\d
C.\B
D.\D

答案解析：需要记几个常见的，实际工作时百度就行。

Java 多线程有几种实现方法？（ ）

A.继承Thread类
B.实现Runnable接口
C.实现Thread接口
D.以上都不正确

答案解析：

在Java中实现多线程主要有以下几种方式：

1. 继承Thread类：

通过创建一个新的类继承`Thread`类，并重写其`run()`方法来定义线程执行的操作。

public class MyThread extends Thread {
       @Override
       public void run() {
           // 线程执行的代码
       }
   }

   // 在其他地方创建并启动线程
   MyThread myThread = new MyThread();
   myThread.start();

2. 实现Runnable接口：

创建一个类实现`Runnable`接口，并实现其`run()`方法。然后可以将`Runnable`的实例传递给`Thread`的构造器，并启动线程。

   public class MyRunnable implements Runnable {
       @Override
       public void run() {
           // 线程执行的代码
       }
   }

   // 在其他地方创建Runnable实例和Thread实例，并启动线程
   MyRunnable myRunnable = new MyRunnable();
   Thread thread = new Thread(myRunnable);
   thread.start();

3.实现Callable接口：

`Callable`接口与`Runnable`类似，但它可以返回值，并且可以抛出异常。实现`Callable`的类需要被提交给`ExecutorService`，它将返回一个`Future`对象，可以通过这个对象获取Callable任务的返回值。

public class MyCallable implements Callable<Integer> {
       @Override
       public Integer call() throws Exception {
           // 线程执行的代码
           return 123;
       }
   }

   // 在其他地方创建Callable实例，提交给ExecutorService，并获取Future对象
   ExecutorService executorService = Executors.newFixedThreadPool(1);
   Future<Integer> future = executorService.submit(new MyCallable());
   // 获取Callable任务的返回值
   Integer result = future.get();

4.使用线程池：

通过`Executor`框架来管理线程池，这是推荐的方式，因为它可以有效地管理线程的创建和销毁，以及提高性能。

 ExecutorService executorService = Executors.newFixedThreadPool(10);
   executorService.execute(new MyRunnable());
   // 或者
   Future<?> future = executorService.submit(new MyCallable());
   executorService.shutdown();

关于抽象类与最终类，下列说法错误的是？

A.抽象类能被继承，最终类只能被实例化。
B.抽象类和最终类都可以被声明使用
C.抽象类中可以没有抽象方法，最终类中可以没有最终方法
D.抽象类和最终类被继承时，方法可以被子类覆盖

答案解析：

抽象类中可以有抽象方法，也可以没有抽象方法。

抽象类当然可以被继承，因为它就是用来继承的，

继承抽象类，若有抽象方法，则子类必须将其抽象方法实现，

抽象类中的非抽象方法可以被重写。

最终类和抽象类正好相反

加上final的类就叫最终类，加上final的方法就叫最终方法，

最终类中可以有最终方法也可以没有

最终类不能有子类，最终方法不能被重写

JDK1.8版本之前，抽象类和接口的区别，以下说法错误的是
A.接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
B.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
C.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
D.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"has-a"关系，interface表示的是"is-a"关系。

答案解析：is-a:继承关系 has-a:从属关系 like-a:组合关系，这题容易被jdk1.8吸引注意力。

下面字段声明中哪一个在interface主体内是合法的? （）

A.private final static int answer = 42;
B.public static int answer = 42;
C.final static answer = 42;
D.int answer;

答案解析：在接口中，属性都是默认public static final修饰的，这题不仔细看了也容易错。

public boolean returnTest()
{
    try
    {
        return true;
    }
    catch (Exception e)
    {
 
    }
    finally
    {
        return false;
    }
}
以上代码返回值是什么？
A.true
B.false

答案解析：一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效。

默认RMI采用的是什么通信协议？
A.HTTP
B.UDP/IP
C.TCP/IP
D.Multicast

答案解析：RMI(Remote Method Invocation)远程方法调用是一种计算机之间利用远程对象互相调用实现双方通讯的一种通讯机制。而TCP/IP是远程通讯的主要手段。

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);
上述代码返回结果为：
A.true、true
B.true、false
C.false、true
D.false、false

答案解析：Integer类型在-128-->127范围之间是被缓存了的，也就是每个对象的内存地址是相同的，赋值就直接从缓存中取，不会有新的对象产生，而大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了，太容易错了这个题。

下面代码的运行结果为：（）
import java.io.*;
import java.util.*;
public class foo{
    public static void main (String[] args){
        String s;
        System.out.println("s=" + s);
    }
}

A.代码得到编译，并输出“s=”
B.代码得到编译，并输出“s=null”
C.由于String s没有初始化，代码不能编译通过
D.代码得到编译，但捕获到 NullPointException异常

答案解析：局部变量，没有像成员变量那样类加载时会有初始化赋值，所以要使用局部变量时，一定要显式的给它赋值，也就是定义时就给它数值。

下列流当中，属于处理流的是：（）     
A.FilelnputStream
B.lnputStream
C.DatalnputStream
D.BufferedlnputStream

节点流：从一个节点读取数据

处理流：对一个已存在的流进行封装

注意：

节点流（Node Stream）：
- 节点流是直接连接到数据源的流，如文件、内存等。它们通常以File、String、Array、Piped等开头。
- 节点流可以直接从数据源读取数据或向数据源写入数据。
处理流（Processing Stream）：
- 处理流是对已存在流的连接和封装，通过所封装的流的功能调用实现数据读写。处理流的构造方法通常需要一个其他的流对象作为参数。
- 处理流可以对数据进行加工处理，如缓冲、转换、数据操作等。
Java常用的节点流：
- FileInputStream、FileOutputStream、FileReader、FileWriter：用于文件操作的节点流。
- StringReader、StringWriter：用于字符串操作的节点流。
- ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter：用于数组操作的节点流。
- PipedInputStream、PipedOutputStream、PipedReader、PipedWriter：用于管道操作的节点流。
常用处理流：
- 缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter：增加缓冲功能，避免频繁读写硬盘。
- 转换流：InputStreamReader、OutputStreamWriter：实现字节流和字符流之间的转换。
- 数据流：DataInputStream、DataOutputStream：提供将基础数据类型写入到文件中，或者从文件中读取出来的功能。
流的关闭顺序：
- 通常情况下，应该先关闭后打开的流，再关闭先打开的流。
- 如果流之间存在依赖关系，应该先关闭依赖的流，再关闭被依赖的流。例如，如果处理流依赖于节点流，应该先关闭处理流，再关闭节点流。
- 处理流在关闭时，通常会调用其封装的节点流的关闭方法，因此有时可以只关闭处理流，而不直接关闭节点流。但是，这取决于具体的流实现，最安全的做法是显式地关闭所有打开的流。

下列哪个类的声明是正确的？

A.abstract final class HI{}
B.abstract private move(){}
C.protected private number;
D.public abstract class Car

答案解析：A只能有final和abstract的一个，因为final是最终类，不能继承，必须可以创建实例，而abstract是抽象类，只能继承，不有实例。冲突了，所以不对。 B是抽象方法，不能有方法体。所以末尾不是{}而是；才对 C中访问修饰符只能有一个，而且对象没有类型。

对下面Spring声明式事务的配置含义的说明错误的是（）
<bean id="txProxyTemplate" abstract="true"
class=
"org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="myTransactionManager" />
<property name="transactionAttributes">      
 <props>
        <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
         <prop key="*">PROPAGATION_REQUIRED</prop>
     </props>
</property> 
</bean>

A.定义了声明式事务的配置模板
B.对get方法采用只读事务
C.缺少sessionFactory属性的注入
D.配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：
<bean id="petBiz" parent="txProxyTemplate">
         <property name="target" ref="petTarget"/>
</bean>

答案解析：

1.Spring本身并不直接管理事务，而是提供了事务管理器接口，对于不同的框架或者数据源则用不同的事务管理器；而对于事务，它把相关的属性都封装到一个实体里边去，有以下的属性:

    int propagationBehavior;    /*事务的传播行为*/
    int isolationLevel;                /*事务隔离级别*/
    int timeout;                            /*事务完成的最短时间*/
    boolean readOnly;                /*是否只读*/

Spring提供了对编程式事务和声明式事务的支持，编程式事务是嵌在业务代码中的，而声明式事务是基于xml文件配置。

2. readOnly -- 事务隔离级别，表示只读数据，不更新数据

3.PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。 
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。

关于Java内存区域下列说法不正确的有哪些
A.程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器，每个线程都需要一个独立的程序计数器.
B.Java虚拟机栈描述的是java方法执行的内存模型，每个方法被执行的时候都会创建一个栈帧，用于存储局部变量表、类信息、动态链接等信息
C.Java堆是java虚拟机所管理的内存中最大的一块，每个线程都拥有一块内存区域，所有的对象实例以及数组都在这里分配内存。
D.方法区是各个线程共享的内存区域，它用于存储已经被虚拟机加载的常量、即时编译器编译后的代码、静态变量等数据。

答案解析：

A.程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器（偏移地址），Java编译过程中产生的字节码有点类似编译原理的指令，程序计数器的内存空间存储的是当前执行的字节码的偏移地址，每一个线程都有一个独立的程序计数器（程序计数器的内存空间是线程私有的），因为当执行语句时，改变的是程序计数器的内存空间，因此它不会发生内存溢出，并且程序计数器是jvm虚拟机规范中唯一一个没有规定 OutOfMemoryError 异常的区域；

B.java虚拟机栈：线程私有，生命周期和线程一致。描述的是 Java 方法执行的内存模型：每个方法在执行时都会床创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行结束，就对应着一个栈帧从虚拟机栈中入栈到出栈的过程。 没有类信息，类信息是在方法区中

C.java堆：对于绝大多数应用来说，这块区域是 JVM 所管理的内存中最大的一块。线程共享，主要是存放对象实例和数组

D.方法区：属于共享内存区域，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。