2021年09月07日 java1

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 5.4k 阅读时长 ≈ 5 分钟

考点1:java基础知识 boolean表达式

设有定义 int a=3 ,b=4,c=5; 则以下的表达式中 , 值为 false 的是 ()

  • A a < b && b < c
  • B a <= b
  • C a < ( b + c )
  • D ! ( a < b )

解析

显示答案/隐藏答案正确答案: D

拓展：单与和双与的区别

  • &和&&都是逻辑运算符，都是判断两边同时真则为真，否则为假;
    • 但是&&当第一个条件不成之后，后面的条件都不执行了，而&则还是继续执行，直到整个条件语句执行完为止。
  • ||和|都是逻辑或，只要两个数任意一个为真，条件就为真。
    • 同上，||也具有短路效果。

双与有短路功能，单与可以进行位运算

考点2:java基础知识 Object类

Java中所有类的父类是( )。

  • A Father
  • B Dang
  • C Exception
  • D Object

解析

显示答案/隐藏答案正确答案: D
  • java中Object是所有类的父亲,
  • 所有类的对象都是Class的实例。

考点3:实现多个接口的正确写法

在java中,已定义两个接口B和C,要定义一个实现这两个接口的类,以下语句正确的是()

  • A interface A extends B,C
  • B interface A eimplements B,C
  • C class A implements B,C
  • D class A implements B,implements C

解析

显示答案/隐藏答案正确答案: C

实现多个接口时只需要写一个implements

类实现多个接口的时候，只需要一个implements，多个接口通过逗号进行隔开，

先继承类,再实现接口

考点4:Servlet生命周期

J2EE中,当把来自客户机的HTTP请求委托给servlet时,会调用HttpServlet的( )方法

  • A service
  • B doget
  • C dopost
  • D init

解析

显示答案/隐藏答案正确答案: A

HttpServlet容器响应Web请求流程

HttpServlet容器响应Web客户请求流程如下：
1）Web客户向Servlet容器发出Http请求；
2）Servlet容器解析Web客户的Http请求；
3）Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息；
4）Servlet容器创建一个HttpResponse对象；
5）Servlet容器调用HttpServlet的service方法，这个方法中会根据request的Method来判断具体是执行doGet还是doPost，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象；
6）HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息；
7）HttpServlet调用HttpResponse的有关方法，生成响应数据；
8）Servlet容器把HttpServlet的响应结果传给Web客户。

doGet()
或
doPost()
是创建HttpServlet时需要覆盖的方法.

Servlet生命周期三个阶段

1.初始化阶段，调用init()方法
2.响应客户请求阶段，调用service()方法
3.终止阶段，调用destroy()方法

考点5:类的加载顺序 父类静态块 子类静态块 main方法 父类构造块 父类构造器 子类构造块 子类构造器

关于以下application,说法正确是什么？

1
2
3
4
5
6
7
8
9
public class Test {
    static int x=10;
    static {x+=5;}
    public static void main(String[] args) //4
        {
        System.out.println("x="+x);
    }
    static{x/=3;};
}//9
  • A 4行与9行不能通过编译,因为缺少方法名和返回类型
  • B 编译通过,执行结果是:x=5
  • C 编译通过,执行结果是:x=3
  • D 9行不能通过编译,因为只能有一个静态初始化器

解析

显示答案/隐藏答案正确答案: B

类的初始化顺序

G:\dev2\idea_workspace\MyJavaTools\RunableTools\src\base\test\B.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class A{
    static {
        System.out.println("父类 静态 代码块");
    }
    public A(){
        System.out.println("父类 构造 方法");
    }
    {
        System.out.println("父类 初始化 代码块");
    }
}
public class B extends A{
    static{
        System.out.println("子类 静态 代码块");
    }
    public B(){
        System.out.println("子类 构造 方法");
    }
    {
        System.out.println("子类 初始化 代码块");
    }
    public static void main(String[] args){
        System.out.println("main方法 执行");
        {
            System.out.println("main方法 代码块1");
        }
        new B();
        {
            System.out.println("main方法 代码块2");
        }
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
父类 静态 代码块
子类 静态 代码块
main方法 执行
main方法 代码块1
父类 初始化 代码块
父类 构造 方法
子类 初始化 代码块
子类 构造 方法
main方法 代码块2

静态代码块先于 主方法执行，静态代码块之间遵从代码顺序执行。
所以：先初始化静态变量

1
x=10；//x=10

执行第一个静态代码块，

1
x=x+5; //x=15

执行第二静态代码块 

1
x=x/3; //x=5

执行主方法： 输出x=5

拓展一下，在类中定义的{}之间被称为构造块，构造块相对于构造方法先执行，构造块之间按照代码编译顺序执行

此外还有普通代码块，存在于方法之中。
贴出参考文章：http://www.cnblogs.com/sophine/p/3531282.html

考点6:还没了解hibernate

下面关于hibernate核心接口说明错误的是？

  • A Configuration 接口:配置Hibernate,根据其启动hibernate,创建SessionFactory 对象
  • B SessionFactory 接口:负责保存、更新、删除、加载和查询对象,是线程不安全的,避免多个线程共享同一个session,是轻量级、一级缓存
  • C Query 和Criteria 接口:执行数据库的查询
  • D Transaction 接口:管理事务

解析

显示答案/隐藏答案正确答案: B

B选项中应该是Session接口而不是SessionFactory接口
1，Configuration接口：配置Hibernate，根据其启动Hibernate，创建SessionFactory对象；
2，SessionFactory接口：初始化Hibernate，充当数据存储源的，创建session对象，SessionFactory是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级二级缓存；
3，session接口：负责保存、更新、删除、加载和查询对象，是一个非线程安全的，避免多个线程共享一个session，是轻量级，一级缓存。
4，Transaction接口：管理事务。可以对事务进行提交和回滚；
5，Query和Criteria接口：执行数据库的查询。

考点7:堆外内存 off-heap 还没学到

off-heap是指那种内存()

  • A JVM GC能管理的内存
  • B JVM进程管理的内存
  • C 在JVM老年代内存区
  • D 在JVM新生代内存

解析

显示答案/隐藏答案正确答案: B

堆外内存

off-heap叫做堆外内存，将你的对象从堆中脱离出来序列化，然后存储在一大块内存中，这就像它存储到磁盘上一样，但它仍然在RAM中。对象在这种状态下不能直接使用，它们必须首先反序列化，也不受垃圾收集。
序列化和反序列化将会影响部分性能（所以可以考虑使用FST-serialization）使用堆外内存能够降低GC导致的暂停。
堆外内存不受垃圾收集器管理，也不属于老年代，新生代。

考点8:Servlet生命周期

servlet周期包含哪些:

  • A 初始化
  • B 销毁
  • C 请求处理
  • D 开始

解析

显示答案/隐藏答案正确答案: ABC

Servlet生命周期3个阶段

1）初始化阶段：调用init方法
2）响应客户请求：调用service
3）终止：调用destory方法

初始化阶段

在下列时刻servlet容器装载servlet
1 servlet容器启动时，自动装载某些servlet
2 在servlet容器启动后，客户首次向servlet发送请求
3 servlet类文件被更新之后，重新装载servlet

Servlet被装载之后，servlet容器创建一个servlet对象并调用servlet的init方法，在servlet生命周期内，init方法只能被调用一次。

servlet工作原理

客户端发起一个请求，servlet调用service方法时请求进行响应，service对请求的方式进行了匹配，选择调用doPost或者doGet等这些方法，然后进入对应方法中调用逻辑层的方法，实现对客户的响应。

响应客户请求

对于用户到达servlet的请求，servlet容器会创建特定于该请求的ServletRequest和ServletResponse对象，然后调用servlet的service方法，service方法从ServletRequest对象中获取客户请求的信息，处理该请求，并且通过ServletResponse对象向客户端返回响应信息。

终止

当web应用终止或者servlet容器终止或servlet容器重新装载servlet新实例时，servlet容器会调用servlet对象的destory方法，在destory方法中可以释放servlet占用的资源

考点9:类的加载顺序 静态块 main 构造块 构造器

关于以下代码的说明,正确的是( )

1
2
3
4
5
6
7
8
9
10
class StaticStuff
{
    static int x=10;
    static { x+=5;}
    public static void main(String args[ ])
    {
        System.out.println("x=" + x);
    }
    static { x/=3;}
}
  • A 4行与9行不能通过编译,因为缺少方法名和返回类型
  • B 9行不能通过编译,因为只能有一个静态初始化器
  • C 编译通过,执行结果为:x=5
  • D 编译通过,执行结果为:x=3

解析

显示答案/隐藏答案正确答案: C

同上第5题

考点10:JVM相关 还没学到

关于OutOfMemoryError,下面说法正确的是()？

  • A java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话,这个问题通常会得到解决。
  • B java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机允许的大小的数组时,这条错误将会出现
  • C java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增加堆的大小
  • D java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到

解析

显示答案/隐藏答案正确答案: ABC

关于此题，《深入理解java虚拟机》有关于OOM（OutOfMemory）问题的解释
A：属于运行时常量池导致的溢出，设置-XX：MaxPermSize可以解决这个问题，
B：属于堆空间不足导致的错误，问题比较少见，解决方式和C相同，
C：属于java堆内存问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存列楼，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以设置-Xmx解决问题
D：java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。