面试经验总结

妖狐艹你老母 2023-05-31 15:28 139阅读 0赞

# 面试经验总结 #

### 文章目录 ###

*  面试经验总结
 *   *   *  中电一面
         *  （1）、项目问题
         *   *  （2）、IOC和Aop
         *  我的答案
         *  网上找的答案
     *  广义的 IOC
     *  Spring 的 IoC
     *  总结
     *   *  （二）AOP
     *  我的答案：
     *   *  网上答案
         *  主要功能
         *  主要意图
     *  AOP/OOP
     *   *  区分
         *  关系
     *  应用举例
     *   *  （三）集合的遍历方式
         *   *  我的回答
             *  网上答案
         *  （四）Vue的生命周期
         *  （五）Vue常用的属性
         *  （六）Vue中的事件
         *  （七）说一下设计模型
         *  （九）jvm的内存和垃圾回收机制
     *  （十）谈一下接口
     *   *  （十一）log4J的使用
         *   *   *  （十二）JDBC的步骤
             *  总结：

### 中电一面 ###

### （1）、项目问题 ###

由于之前没有做项目呢这个问题回答的不是很好

#### （2）、IOC和Aop ####

这个问题刚好在我学完Spring之后所以回的出来

### 我的答案 ###

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法\*\*，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

\*\*控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现、

### 网上找的答案 ###

## 广义的 IOC ##

*  IoC(Inversion of Control) 控制反转，即“不用打电话过来，我们会打给你”。

两种实现： 依赖查找（DL）和依赖注入（DI）。

IOC 和 DI 、DL 的关系（这个 DL，Avalon 和 EJB 就是使用的这种方式实现的 IoC）：

![img][]

*  DL 已经被抛弃，因为他需要用户自己去是使用 API 进行查找资源和组装对象。即有侵入性。
 *  DI 是 Spring 使用的方式，容器负责组件的装配。

注意：Java 使用 DI 方式实现 IoC 的不止 Spring，包括 Google 的 Guice，还有一个冷门的 PicoContainer（极度轻量，但只提供 IoC）。

## Spring 的 IoC ##

Spring 的 IoC 设计支持以下功能：

*  依赖注入
 *  依赖检查
 *  自动装配
 *  支持集合
 *  指定初始化方法和销毁方法
 *  支持回调某些方法（但是需要实现 Spring 接口，略有侵入）

其中，最重要的就是依赖注入，从 XML 的配置上说， 即 ref 标签。对应 Spring RuntimeBeanReference 对象。

对于 IoC 来说，最重要的就是容器。容器管理着 Bean 的生命周期，控制着 Bean 的依赖注入。

那么， Spring 如何设计容器的呢？

Spring 作者 Rod Johnson 设计了两个接口用以表示容器。

*  BeanFactory
 *  ApplicationContext

BeanFactory 粗暴简单，可以理解为就是个 HashMap，Key 是 BeanName，Value 是 Bean 实例。通常只提供注册（put），获取（get）这两个功能。我们可以称之为 **“低级容器”**。

ApplicationContext 可以称之为 **“高级容器”**。因为他比 BeanFactory 多了更多的功能。他继承了多个接口。因此具备了更多的功能。例如资源的获取，支持多种消息（例如 JSP tag 的支持），对 BeanFactory 多了工具级别的支持等待。所以你看他的名字，已经不是 BeanFactory 之类的工厂了，而是 “应用上下文”， 代表着整个大容器的所有功能。该接口定义了一个 refresh 方法，此方法是所有阅读 Spring 源码的人的最熟悉的方法，用于刷新整个容器，即重新加载/刷新所有的 bean。

当然，除了这两个大接口，还有其他的辅助接口，但我今天不会花太多篇幅介绍他们。

为了更直观的展示 “低级容器” 和 “高级容器” 的关系，我这里通过常用的 ClassPathXmlApplicationContext 类，来展示整个容器的层级 UML 关系。

![img][img 1]

有点复杂？ 先不要慌，我来解释一下。

最上面的 BeanFactory 知道吧？我就不讲了。

下面的 3 个绿色的，都是功能扩展接口，这里就不展开讲。

看下面的隶属 ApplicationContext 粉红色的 “高级容器”，依赖着 “低级容器”，这里说的是依赖，不是继承哦。他依赖着 “低级容器” 的 getBean 功能。而高级容器有更多的功能：支持不同的信息源头，可以访问文件资源，支持应用事件（Observer 模式）。

通常用户看到的就是 “高级容器”。 但 BeanFactory 也非常够用啦！

左边灰色区域的是 “低级容器”， 只负载加载 Bean，获取 Bean。容器其他的高级功能是没有的。例如上图画的 refresh 刷新 Bean 工厂所有配置。生命周期事件回调等。

好，解释了低级容器和高级容器，我们可以看看一个 IoC 启动过程是什么样子的。说白了，就是 ClassPathXmlApplicationContext 这个类，在启动时，都做了啥。（由于我这是 interface21 的代码，肯定和你的 Spring 4.x 系列不同）。

下图是 ClassPathXmlApplicationContext 的构造过程，**实际就是 Spring IoC 的初始化过程**。

![img][img 2]

注意，这里为了理解方便，有所简化。

这里再用文字来描述这个过程：

1.  用户构造 ClassPathXmlApplicationContext（简称 CPAC）
2.  CPAC 首先访问了 “抽象高级容器” 的 final 的 refresh 方法，这个方法是模板方法。所以要回调子类（低级容器）的 refreshBeanFactory 方法，这个方法的作用是使用低级容器加载所有 BeanDefinition 和 Properties 到容器中。
3.  低级容器加载成功后，高级容器开始处理一些回调，例如 Bean 后置处理器。回调 setBeanFactory 方法。或者注册监听器等，发布事件，实例化单例 Bean 等等功能，这些功能，随着 Spring 的不断升级，功能越来越多，很多人在这里迷失了方向 ：）。

简单说就是：

1.  低级容器 加载配置文件（从 XML，数据库，Applet），并解析成 BeanDefinition 到低级容器中。
2.  加载成功后，高级容器启动高级功能，例如接口回调，监听器，自动实例化单例，发布事件等等功能。

所以，一定要把 “低级容器” 和“高级容器” 的区别弄清楚。不能一叶障目不见泰山。

好，当我们创建好容器，就会使用 getBean 方法，获取 Bean，而 getBean 的流程如下：

![img][img 3]

从图中可以看出，getBean 的操作都是在低级容器里操作的。其中有个递归操作，这个是什么意思呢？

假设 ： 当 Bean\_A 依赖着 Bean\_B，而这个 Bean\_A 在加载的时候，其配置的 ref = “Bean\_B” 在解析的时候只是一个占位符，被放入了 Bean\_A 的属性集合中，当调用 getBean 时，需要真正 Bean\_B 注入到 Bean\_A 内部时，就需要从容器中获取这个 Bean\_B，因此产生了递归。

为什么不是在加载的时候，就直接注入呢？因为加载的顺序不同，很可能 Bean\_A 依赖的 Bean\_B 还没有加载好，也就无法从容器中获取，你不能要求用户把 Bean 的加载顺序排列好，这是不人道的。

所以，Spring 将其分为了 2 个步骤：

1.  加载所有的 Bean 配置成 BeanDefinition 到容器中，如果 Bean 有依赖关系，则使用占位符暂时代替。
2.  然后，在调用 getBean 的时候，进行真正的依赖注入，即如果碰到了属性是 ref 的（占位符），那么就从容器里获取这个 Bean，然后注入到实例中 —— 称之为依赖注入。

可以看到，依赖注入实际上，只需要 “低级容器” 就可以实现。

**这就是 IoC。**

所以 ApplicationContext refresh 方法里面的操作不只是 IoC，是高级容器的所有功能（包括 IoC），IoC 的功能在低级容器里就可以实现。

## 总结 ##

说了这么多，不知道你有没有理解Spring IoC？ 这里小结一下：IoC 在 Spring 里，只需要低级容器就可以实现，2 个步骤：

a. 加载配置文件，解析成 BeanDefinition 放在 Map 里。

b. 调用 getBean 的时候，从 BeanDefinition 所属的 Map 里，拿出 Class 对象进行实例化，同时，如果有依赖关系，将递归调用 getBean 方法 —— 完成依赖注入。

上面就是 Spring 低级容器（BeanFactory）的 IoC。

至于高级容器 ApplicationContext，他包含了低级容器的功能，当他执行 refresh 模板方法的时候，将刷新整个容器的 Bean。同时其作为高级容器，包含了太多的功能。一句话，他不仅仅是 IoC。他支持不同信息源头，支持 BeanFactory 工具类，支持层级容器，支持访问文件资源，支持事件发布通知，支持接口回调等等。

可以预见，随着 Spring 的不断发展，高级容器的功能会越来越多。

诚然，了解 IoC 的过程，实际上为了了解 Spring 初始化时，各个接口的回调时机。例如 InitializingBean，BeanFactoryAware，ApplicationListener 等等接口，这些接口的作用，笔者之前写过一篇文章进行介绍，有兴趣可以看一下，关键字：[Spring 必知必会 扩展接口][Spring _]。

但是请注意，实现 Spring 接口代表着你这个应用就绑定死 Spring 了！代表 Spring 具有侵入性！要知道，Spring 发布时，无侵入性就是他最大的宣传点之一 —— 即 IoC 容器可以随便更换，代码无需变动。而现如今，Spring 已然成为 J2EE 社区准官方解决方案，也没有了所谓的侵入性这个说法。因为他就是标准，和 Servlet 一样，你能不实现 Servlet 的接口吗？: -)

### （二）AOP ###

## 我的答案： ##

面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

Aop在Spring中的作用

*  横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
 *  切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
 *  通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
 *  目标（Target）：被通知对象。
 *  代理（Proxy）：向目标对象应用通知之后创建的对象。
 *  切入点（PointCut）：切面通知 执行的 “地点”的定义。
 *  连接点（JointPoint）：与切入点匹配的执行点。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjU4NDU0NQ_size_16_color_FFFFFF_t_70]

### 网上答案 ###

（AOP）是较为热门的一个话题。AOP，国内大致译作“[面向切面编程][Link 1]”。

“面向切面编程”,这样的名字并不是非常容易理解，且容易产生一些误导。有些人认为“OOP/OOD11即将落伍，AOP是新一代软件开发方式”。显然，发言者并没有理解AOP的含义。Aspect，的确是“方面”的意思。不过，汉语传统语义中的“方面”，大多数情况下指的是一件事情的不同维度、或者说不同角度上的特性，比如我们常说：“这件事情要从几个方面来看待”，往往意思是：需要从不同的角度来看待同一个事物。这里的“方面”，指的是事物的外在特性在不同观察角度下的体现。而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。

可以通过[预编译][Link 2]方式和运行期动态代理实现在不修改[源代码][Link 3]的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性，AOP可以说也是这种目标的一种实现。

在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和[事务][Link 4]（transaction）管理）进行[内聚性][Link 5]的开发。[应用对象][Link 6]只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如[日志][Link 7]或事务支持。

### 主要功能 ###

日志记录，性能统计，安全控制，事务处理，[异常处理][Link 8]等等。

### 主要意图 ###

将日志记录，性能统计，安全控制，事务处理，[异常处理][Link 8]等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

## AOP/OOP ##

编辑

### 区分 ###

AOP、OOP在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP（[面向对象编程][Link 9]）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的[逻辑单元][Link 10]划分。

而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低[耦合性][Link 11]的隔离效果。这两种设计思想在目标上有着本质的差异。

上面的陈述可能过于理论化，举个简单的例子，对于“雇员”这样一个[业务实体][Link 12]进行封装，自然是OOP/OOD的任务，我们可以为其建立一个“Employee”类，并将“雇员”相关的属性和行为封装其中。而用AOP设计思想对“雇员”进行封装将无从谈起。

同样，对于“权限检查”这一动作片断进行划分，则是AOP的目标领域。而通过OOD/OOP对一个动作进行封装，则有点不伦不类。

换而言之，OOD/OOP面向名词领域，AOP面向动词领域。

### 关系 ###

很多人在初次接触 AOP 的时候可能会说，AOP 能做到的，一个定义良好的 OOP 的接口也一样能够做到，我想这个观点是值得商榷的。AOP和定义良好的 OOP 的接口可以说都是用来解决并且实现需求中的横切问题的方法。但是对于 OOP 中的接口来说，它仍然需要我们在相应的模块中去调用该接口中相关的方法，这是 OOP 所无法避免的，并且一旦接口不得不进行修改的时候，所有事情会变得一团糟；AOP 则不会这样，你只需要修改相应的 Aspect，再重新编织（weave）即可。 当然，AOP 也绝对不会代替 OOP。核心的需求仍然会由 OOP 来加以实现，而 AOP 将会和 OOP 整合起来，以此之长，补彼之短。

## 应用举例 ##

编辑

假设在一个应用系统中，有一个共享的数据必须被并发同时访问，首先，将这个[数据封装][Link 13]在[数据对象][Link 14]中，称为Data Class，同时，将有多个访问类，专门用于在同一时刻访问这同一个数据对象。

为了完成上述并发访问同一资源的功能，需要引入锁Lock的概念，也就是说，某个时刻，当有一个访问类访问这个数据对象时，这个数据对象必须上锁Locked，用完后就立即解锁unLocked，再供其它访问类访问。

使用传统的编程习惯，我们会创建一个[抽象类][Link 15]，所有的访问类继承这个抽象父类，如下：

`abstract` `class` `Worker {``    ``abstract` `void` `locked();``    ``abstract` `void` `accessDataObject();``    ``abstract` `void` `unlocked();``}`

accessDataObject()方法需要有“锁”状态之类的相关代码。

Java只提供了单继承，因此具体访问类只能继承这个父类，如果具体访问类还要继承其它父类，比如另外一个如Worker的父类，将无法方便实现。

重用被打折扣，具体访问类因为也包含“锁”状态之类的相关代码，只能被重用在相关有“锁”的场合，重用范围很窄。

仔细研究这个应用的“锁”，它其实有下列特性：

“锁”功能不是具体访问类的首要或主要功能，访问类主要功能是访问数据对象，例如读取数据或更改动作。

[ ![img][img 4] ][_img_img 4_]

“锁”功能其实是这个系统的一个纵向切面，涉及许多类、许多类的方法。如右图：

因此，一个新的程序结构应该是关注系统的纵向切面，例如这个应用的“锁”功能，这个新的程序结构就是aspect（方面）

在这个应用中，“锁”方面（aspect）应该有以下职责：

提供一些必备的功能，对被访问对象实现加锁或解锁功能。以保证所有在修改[数据对象][Link 14]的操作之前能够调用lock()加锁，在它使用完成后，调用unlock()解锁。

### （三）集合的遍历方式 ###

#### 我的回答 ####

三种

1、普通for循环

2.增强for循环

3、迭代器（iterator）

我这样回答是不太对的该分集合来回答。

#### 网上答案 ####

**集合类的通用遍历方式, 用迭代器迭代**

**Map遍历方式：**

**1、通过获取所有的key按照key来遍历**

//Set<Integer> set = map.keySet(); //得到所有key的集合
    for (Integer in : map.keySet()) {
        String str = map.get(in);//得到每个key多对用value的值
    }

**2、通过Map.entrySet使用iterator遍历key和value**

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
    while (it.hasNext()) {
         Map.Entry<Integer, String> entry = it.next();
           System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
    }

**3、通过Map.entrySet遍历key和value，推荐，尤其是容量大时**

for (Map.Entry<Integer, String> entry : map.entrySet()) {
        //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
        //entry.getKey() ;entry.getValue(); entry.setValue();
        //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
        System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
    }

4、通过Map.values()遍历所有的value，但不能遍历key

for (String v : map.values()) {
        System.out.println("value= " + v);
    }

**List遍历方式：**

**第一种：**

for(Iterator iterator = list.iterator();iterator.hasNext();){                    
        int i = (Integer) iterator.next();                   
        System.out.println(i);               
    }

**第二种：**

Iterator iterator = list.iterator();
    while(iterator.hasNext()){
        int i = (Integer) iterator.next();
        System.out.println(i);
    }

**第三种：**

for (Object object : list) { 
        System.out.println(object); 
    }

**第四种：**

for(int i = 0 ;i<list.size();i++) {  
        int j= (Integer) list.get(i);
        System.out.println(j);  
    }

**数据元素是怎样在内存中存放的？**

主要有2种存储方式：

1、顺序存储，Random Access（Direct Access）：

这种方式，相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

2、链式存储，Sequential Access：

这种方式，每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

**每个遍历方法的实现原理是什么？**

1、传统的for循环遍历，基于计数器的：

遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。

2、迭代器遍历，Iterator：

每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。

3、foreach循环遍历：

根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

**各遍历方式对于不同的存储方式，性能如何？**

**1、传统的for循环遍历，基于计数器的：**

因为是基于元素的位置，按位置读取。所以我们可以知道，对于顺序存储，因为读取特定位置元素的平均时间复杂度是O(1)，所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储，因为读取特定位置元素的平均时间复杂度是O(n)，所以遍历整个集合的平均时间复杂度为O(n2)（n的平方）。

ArrayList按位置读取的代码：直接按元素位置读取。

transient Object[] elementData;
    
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
    
    E elementData(int index) {
        return (E) elementData[index];
    }

LinkedList按位置读取的代码：每次都需要从第0个元素开始向后读取。其实它内部也做了小小的优化。

transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;
    
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    
    Node<E> node(int index) {
        if (index < (size >> 1)) {   //查询位置在链表前半部分，从链表头开始查找
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {                     //查询位置在链表后半部分，从链表尾开始查找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

**2、迭代器遍历，Iterator：**

那么对于RandomAccess类型的集合来说，没有太多意义，反而因为一些额外的操作，还会增加额外的运行时间。但是对于Sequential Access的集合来说，就有很重大的意义了，因为Iterator内部维护了当前遍历的位置，所以每次遍历，读取下一个位置并不需要从集合的第一个元素开始查找，只要把指针向后移一位就行了，这样一来，遍历整个集合的时间复杂度就降低为O(n)；

（这里只用LinkedList做例子）LinkedList的迭代器，内部实现，就是维护当前遍历的位置，然后操作指针移动就可以了：

代码：

public E next() {
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();
    
        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
    
    public E previous() {
        checkForComodification();
        if (!hasPrevious())
            throw new NoSuchElementException();
    
        lastReturned = next = (next == null) ? last : next.prev;
        nextIndex--;
        return lastReturned.item;
    }

**3、foreach循环遍历：**

分析Java字节码可知，foreach内部实现原理，也是通过Iterator实现的，只不过这个Iterator是Java编译器帮我们生成的，所以我们不需要再手动去编写。但是因为每次都要做类型转换检查，所以花费的时间比Iterator略长。时间复杂度和Iterator一样。

Iterator和foreach字节码如下：

//使用Iterator的字节码：
        Code:
           0: new           #16                 // class java/util/ArrayList
           3: dup
           4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
           7: astore_1
           8: aload_1
           9: invokeinterface #19,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
          14: astore_2
          15: goto          25
          18: aload_2
          19: invokeinterface #25,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
          24: pop
          25: aload_2
          26: invokeinterface #31,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
          31: ifne          18
          34: return
     
     
    //使用foreach的字节码：
        Code:
           0: new           #16                 // class java/util/ArrayList
           3: dup
           4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
           7: astore_1
           8: aload_1
           9: invokeinterface #19,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
          14: astore_3
          15: goto          28
          18: aload_3
          19: invokeinterface #25,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
          24: checkcast     #31                 // class loop/Model
          27: astore_2
          28: aload_3
          29: invokeinterface #33,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
          34: ifne          18
          37: return

**各遍历方式的适用于什么场合？**

1、传统的for循环遍历，基于计数器的：

顺序存储：读取性能比较高。适用于遍历顺序存储集合。

链式存储：时间复杂度太大，不适用于遍历链式存储的集合。

2、迭代器遍历，Iterator：

顺序存储：如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题。

链式存储：意义就重大了，平均时间复杂度降为O(n)，还是挺诱人的，所以推荐此种遍历方式。

3、foreach循环遍历：

foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，参考上面两种方式，做一个折中的选择。

### （四）Vue的生命周期 ###

我的回答： Vue 实例从创建到销毁的过程，就是生命周期。从开始创建、初始化数据、编译模板、挂载Dom→渲染、更新→渲染、销毁等一系列过程，

1、初始化显示

\*\*\* *beforeCreate()*

\*\*\* *created()*

\*\*\* *beforeMount()*

\*\*\* *mounted()*

2、更新状态: this.xxx = value

\*\*\* *beforeUpdate()*

\*\*\* *updated()*

3、销毁 vue 实例: vm.$destory()

\*\*\* *beforeDestory()*

\*\*\* *destoryed()*

1.什么是vue生命周期？  
答： Vue 实例从创建到销毁的过程，就是生命周期。从开始创建、初始化数据、编译模板、挂载Dom→渲染、更新→渲染、销毁等一系列过程，称之为 Vue 的生命周期。

2.vue生命周期的作用是什么？  
答：它的生命周期中有多个事件钩子，让我们在控制整个Vue实例的过程时更容易形成好的逻辑。

3.vue生命周期总共有几个阶段？  
答：它可以总共分为8个阶段：创建前/后, 载入前/后,更新前/后,销毁前/销毁后。

4.第一次页面加载会触发哪几个钩子？  
答：会触发 下面这几个beforeCreate, created, beforeMount, mounted 。

5.DOM 渲染在 哪个周期中就已经完成？  
答：DOM 渲染在 mounted 中就已经完成了。

网上搜素答案[https://segmentfault.com/a/1190000016344599?utm\_source=tag-newest][https_segmentfault.com_a_1190000016344599_utm_source_tag-newest]

### （五）Vue常用的属性 ###

这个问题我记不起了就只回答了

el属性 data属性

网上查找[https://www.cnblogs.com/bgwhite/p/9297221.html][https_www.cnblogs.com_bgwhite_p_9297221.html]

学习vue我们必须之到它的7个属性，8个 方法，以及7个指令。787原则

*  el属性
 *   *  用来指示vue编译器从什么地方开始解析 vue的语法，可以说是一个占位符。
 *  data属性
 *   *  用来组织从view中抽象出来的属性，可以说将视图的数据抽象出来存放在data中。
 *  template属性
 *   *  用来设置模板，会替换页面元素，包括占位符。
 *  methods属性
 *   *  放置页面中的业务逻辑，js方法一般都放置在methods中
 *  render属性
 *   *  创建真正的Virtual Dom
 *  computed属性
 *   *  用来计算
 *  watch属性
 *   *  watch:function(new,old)\{\}
     *  监听data中数据的变化
     *  两个参数，一个返回新值，一个返回旧值

### （六）Vue中的事件 ###

1、基础事件 v-on:click=“show()”

new Vue({
                    el:'#box',
                    data:{ //数据
                        arr:['apple','banana','orange','pear'],
                        json:{a:'apple',b:'banana',c:'orange'}
                    },
                    methods:{  //methods 用来绑定事件的属性
                        show:function(){     //事件触发时所调用的函数
                            alert(1);
                        }
                    }
                });
     <div id="box">
            <input type="button" value="按钮" v-on:click="show()">
        </div>

2、点击事件

new Vue({
                    el:'#box',
                    data:{ //数据
                        arr:['apple','banana','orange','pear']
    },
                    methods:{
                        add:function(){
                            this.arr.push('tomato');
                        }
                    }
                });
    <div id="box">
            <input type="button" value="按钮" v-on:click="add()">
            <br>
            <ul>
                <li v-for="value in arr">
                    {
       {value}}
                </li>
            </ul>
        </div>

3、键盘事件 VUE提供的方式

new Vue({
    	el:'#box',
    	 data:{
    	},
    	methods:{
    		keydown:function(ev){
    		 //keyCode是事件对象中的属性可以获取键的编码
    		alert("按下了"+ev.keyCode);
    		},
    		keyup:function(){
    			alert("松开了");
    		}
    	}
    });
    	<div id="box">
    		<input type="text" @keydown="keydown($event)"/><br>
    		<input type="text" @keyup="keyup()"/>
    	</div>

<input type="text" @keydown.enter="enter()"/><br>
    			 
    			<input type="text" @keydown.right="right()"/>

[https://www.cnblogs.com/xuqp/p/9406971.html][https_www.cnblogs.com_xuqp_p_9406971.html]

### （七）说一下设计模型 ###

我只提了下单例模式 代理、工厂模式、原型一些知道的模式面试官也没让我写

这方面还得再看看

[https://www.cnblogs.com/lijianxuan/p/10643297.html][https_www.cnblogs.com_lijianxuan_p_10643297.html]

（八）说下冒泡排序的原理

冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。

它是一种较简单的排序算法。它会遍历若干次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！ 采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！

https://blog.csdn.net/onceing/article/details/99838520[冒泡][Link 16]

### （九）jvm的内存和垃圾回收机制 ###

我回答的一般

[https://blog.csdn.net/carson\_ho/article/details/101667672][https_blog.csdn.net_carson_ho_article_details_101667672]

[https://www.cnblogs.com/1024Community/p/honery.html][https_www.cnblogs.com_1024Community_p_honery.html]

## （十）谈一下接口 ##

[https://baijiahao.baidu.com/s?id=1595511474536870490&wfr=spider&for=pc][https_baijiahao.baidu.com_s_id_1595511474536870490_wfr_spider_for_pc]

### （十一）log4J的使用 ###

[https://mp.csdn.net/mdeditor/102455611\#][https_mp.csdn.net_mdeditor_102455611]

##### （十二）JDBC的步骤 #####

> 1.加载JDBC驱动Class.forName(“com.mysql.jdbc.Driver”);  
> 2.与数据库建立连接DriverManager.getConnection(url,uname,pwd);  
> 3.获取操作对象，发送sql语句得到返回结果  
> 4.处理返回结果  
> 5.释放资源.close()

#### 总结： ####

面试有些紧张，得多锻炼，回顾学过的知识点一次比一次好

[img]: /images/20230531/33ad5bd2776c41cc9a53d0e8bc3979ab.png
[img 1]: /images/20230531/fd9439387dcc400a96eae2a2ab9aa68b.png
[img 2]: /images/20230531/77d6f7c70b8b42358a42b302e7102073.png
[img 3]: /images/20230531/a0efa9968e3f4615bb59ad1fb324addb.png
[Spring _]: https://www.google.com/search?q=Spring+%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A+%E6%89%A9%E5%B1%95%E6%8E%A5%E5%8F%A3&oq=Spring+%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A+%E6%89%A9%E5%B1%95%E6%8E%A5%E5%8F%A3&aqs=chrome..69i57j69i65.626j0j1&sourceid=chrome&ie=UTF-8
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjU4NDU0NQ_size_16_color_FFFFFF_t_70]: /images/20230531/10db3ce1c64441a5813222435808d2e9.png
[Link 1]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%88%87%E9%9D%A2%E7%BC%96%E7%A8%8B
[Link 2]: https://baike.baidu.com/item/%E9%A2%84%E7%BC%96%E8%AF%91
[Link 3]: https://baike.baidu.com/item/%E6%BA%90%E4%BB%A3%E7%A0%81
[Link 4]: https://baike.baidu.com/item/%E4%BA%8B%E5%8A%A1
[Link 5]: https://baike.baidu.com/item/%E5%86%85%E8%81%9A%E6%80%A7
[Link 6]: https://baike.baidu.com/item/%E5%BA%94%E7%94%A8%E5%AF%B9%E8%B1%A1
[Link 7]: https://baike.baidu.com/item/%E6%97%A5%E5%BF%97
[Link 8]: https://baike.baidu.com/item/%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86
[Link 9]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%BC%96%E7%A8%8B
[Link 10]: https://baike.baidu.com/item/%E9%80%BB%E8%BE%91%E5%8D%95%E5%85%83
[Link 11]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E6%80%A7
[Link 12]: https://baike.baidu.com/item/%E4%B8%9A%E5%8A%A1%E5%AE%9E%E4%BD%93
[Link 13]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%B0%81%E8%A3%85
[Link 14]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%AF%B9%E8%B1%A1
[Link 15]: https://baike.baidu.com/item/%E6%8A%BD%E8%B1%A1%E7%B1%BB
[img 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9nc3MyLmJkc3RhdGljLmNvbS85Zm8zZFNhZ194STRraEdrcG9XSzFIRjZoaHkvYmFpa2UvcyUzRDIyMC9zaWduPWZmYWYxNWUxOWIyNWJjMzEyZjVkMDY5YTZlZGY4ZGU3LzczOGI0NzEwYjkxMmM4ZmMxMTk0MzZlMmZlMDM5MjQ1ZDY4ODIxYmUuanBn?x-oss-process=image/format,png
[_img_img 4_]: https://baike.baidu.com/pic/AOP/1332219/0/738b4710b912c8fc119436e2fe039245d68821be?fr=lemma&ct=single
[https_segmentfault.com_a_1190000016344599_utm_source_tag-newest]: https://segmentfault.com/a/1190000016344599?utm_source=tag-newest
[https_www.cnblogs.com_bgwhite_p_9297221.html]: https://www.cnblogs.com/bgwhite/p/9297221.html
[https_www.cnblogs.com_xuqp_p_9406971.html]: https://www.cnblogs.com/xuqp/p/9406971.html
[https_www.cnblogs.com_lijianxuan_p_10643297.html]: https://www.cnblogs.com/lijianxuan/p/10643297.html
[Link 16]: https://blog.csdn.net/onceing/article/details/99838520
[https_blog.csdn.net_carson_ho_article_details_101667672]: https://blog.csdn.net/carson_ho/article/details/101667672
[https_www.cnblogs.com_1024Community_p_honery.html]: https://www.cnblogs.com/1024Community/p/honery.html
[https_baijiahao.baidu.com_s_id_1595511474536870490_wfr_spider_for_pc]: https://baijiahao.baidu.com/s?id=1595511474536870490&wfr=spider&for=pc
[https_mp.csdn.net_mdeditor_102455611]: https://mp.csdn.net/mdeditor/102455611#