JAVA面试微总结

# 一、Spring面试题总结

## 1、spring是什么

- 一个轻量级的IOC和AOP容器框架；
- 常见的配置方式
  - 基于XML的配置
  - 基于注解的配置
  - 基于Java的配置
- Spring Core：核心类库，提供IOC服务
- Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI，定时任务）
- Spring AOP：AOP服务
- Spring DAO：对JDBC的抽象，简化了数据访问异常的处理
- Spring Web/Spring ORM/Spring MVC

## 2、Spring的优点

- spring的依赖注入机制将对象之间的依赖关系交由框架处理，减低组件的耦合性
- spring提供了面向切面(AOP)技术，支持将一些通用任务进行集中式管理。从而提供更好的复用
- spring对主流的应用框架提供了集成支持；属于低侵入式设计，代码的污染低；

## 3、Spring的AOP理解

### 3.1、代理模式

- 定义：给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用；(中介)

- 

- ```java
  //静态代理
  
  //接口
  public interface Image {
     void display();
  }
  //实现类
  public class RealImage implements Image {
   
     private String fileName;
   
     public RealImage(String fileName){
        this.fileName = fileName;
        loadFromDisk(fileName);
     }
   
     @Override
     public void display() {
        System.out.println("Displaying " + fileName);
     }
   
     private void loadFromDisk(String fileName){
        System.out.println("Loading " + fileName);
     }
  }
  //代理类，实现接口
  public class ProxyImage implements Image{
   
     private RealImage realImage;
     private String fileName;
   
     public ProxyImage(String fileName){
        this.fileName = fileName;
     }
   
     @Override
     public void display() {
        if(realImage == null){
           realImage = new RealImage(fileName);
        }
        realImage.display();
     }
  }
  
  //测试类
  public class ProxyPatternDemo {
     
     public static void main(String[] args) {
        Image image = new ProxyImage("test_10mb.jpg");
   
        // 图像将从磁盘加载
        image.display(); 
        System.out.println("");
        // 图像不需要从磁盘加载
        image.display();  
     }
  }
  ```

- 动态代理
  - 基于接口，JDK
    - 核心InvocationHandler接口和Proxy类，InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
  - 基于类，CGLIB

### 3.2、AOP

- OOP面向对象，允许开发者定义纵向的关系，定义横向的关系时会导致大量代码的重复，而不利于各个模块的重用

- AOP，面向切面，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块命名为”切面“，减少系统的重复代码。（日志、权限）

- 静态代理

  - AspectJ

- 动态代理

  - 代理模式的动态代理

- 实现方式

  - 使用原生Spring API接口

    - ```xml
       
     
       
     
     
       
       
      
      ```

      

  - 自定义类

    - ```xml
     
      
         
             
             
                 
                 
                 
                 
                 
             
         
      ```

  - 使用注解方式

    - @Aspect 标注类为一个切面
    - @Before ("execution(...)")标记方法，execution(需要切入的方法)标记切入点
    - @After，@Around

## 4、Spring 的IOC理解

#### 4.1、IOC

- IOC，控制反转，指创建对象的控制权的转移，手动创建对象的控制权交给spring框架管理
- 注入方式：构造器注入、setter方法注入、注解注入

## 5、BeanFactory和ApplicationContext的区别

- ApplicationContext是BeanFactory的子接口
- BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化
- ApplicationContext，它是在容器启动时，一次性创建了所有的Bean

## 6、Spring Bean的生命周期

- **实例化Bean**：对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。
- **设置对象属性（依赖注入）**：实例化后的对象被封装在BeanWrapper对象中
- **处理Aware接口：**

## 7、Spring常用注解

- @Autowired（标记在属性、成员上）：自动装配
  - 消除代码里的getter/setter与bean属性的property;默认是按类型匹配；
- @Qualifier（标记在类上，指定注入Bean的名称）
  - 若有多个实现类，且都在xml配置文档中，可以使用@Qualifier(引用的实现类)
- @Resource（和Autowired功能类似，默认byName，找不到按byType；不属于Spring注解属于j2EE）
- @Service(业务层)/@Component(泛指组件)/@Controller(表现层)/@Repository(数据层)
  - 都放在类上使用，被标记的类，会被作为Bean注册进Spring容器。

## 8、Spring循环依赖

Spring解决循环依赖依靠的是Bean的“中间态”这个概念，而这个中间态指的是`已经实例化`，但还没初始化的状态。而构造器是完成实例化的东东，所以构造器的循环依赖无法解决~~~

```xml
https://blog.csdn.net/f641385712/article/details/92801300
```

- 解决办法：三级缓存

```java
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    ...
    // 从上至下 分表代表这“三级缓存”
    private final Map singletonObjects = new ConcurrentHashMap<>(256); //一级缓存
    private final Map earlySingletonObjects = new HashMap<>(16); // 二级缓存
    private final Map> singletonFactories = new HashMap<>(16); // 三级缓存
    ...
    
    /** Names of beans that are currently in creation. */
    // 这个缓存也十分重要：它表示bean创建过程中都会在里面呆着~
    // 它在Bean开始创建时放值，创建完成时会将其移出~
    private final Set singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** Names of beans that have already been created at least once. */
    // 当这个Bean被创建完成后，会标记为这个 注意：这里是set集合 不会重复
    // 至少被创建了一次的  都会放进这里~~~~
    private final Set alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
}
```

- `singletonObjects`：用于存放完全初始化好的 bean，**从该缓存中取出的 bean 可以直接使用**
- `earlySingletonObjects`：提前曝光的单例对象的cache，存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
- `singletonFactories`：单例对象工厂的cache，存放 bean 工厂对象，用于解决循环依赖

获取单例bean的源码：

```java
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    ...
    @Override
    @Nullable
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
    ...
    public boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonsCurrentlyInCreation.contains(beanName);
    }
    protected boolean isActuallyInCreation(String beanName) {
        return isSingletonCurrentlyInCreation(beanName);
    }
    ...
}
```

- 先从`一级缓存singletonObjects`中去获取。（如果获取到就直接return）
- 如果获取不到或者对象正在创建中（`isSingletonCurrentlyInCreation()`），那就再从`二级缓存earlySingletonObjects`中获取。（如果获取到就直接return）
- 如果还是获取不到，且允许singletonFactories（allowEarlyReference=true）通过`getObject()`获取。就从`三级缓存singletonFactory`.getObject()获取。**（如果获取到了就从`singletonFactories`中移除，并且放进`earlySingletonObjects`。其实也就是从三级缓存`移动（是剪切、不是复制哦~）`到了二级缓存）**

## 9、Spring Bean创建过程

```xml
https://www.imooc.com/article/32882
```


# 二、Java总结

## 0、反射

- 在运行状态中，对于任何一个类都知道这个类的属性和方法，对于任何一个对象，都可以调用它的属性和方法。这种动态获取的信息以及动态调用对象方法的机制被称为反射。

## 1、重写、重载

- 重载是同一个方法能够根据输入数据的不同，做出不同的处理
  - 方法名相同，参数类型、个数、顺序，方法返回值和访问修饰符不同
  - 只是返回值不同不能算重载；
- 重写，发生在继承、子类对父类的方法重写

## 2、封装、继承、多态

- 多态
  - 程序定义的引用变量所指向的具体类型和通过引用调用的方法在编程时不确定，在程序运行期间才确定。
  - 实现方法
    - 接口实现，实现接口并实现方法
    - 继承，多个子类对同一方法重写

## 3、String、StringBuilder、StringBuffer

- String对象是不可变的，使用final关键字修饰字符数组来保存字符串
- StringBuilder、StringBuffer都继承自AbstractStringBuilder
- StringBuffer，String线程安全，StringBuilder线程不安全

## 4、接口、抽象类

- 抽象类可以有非抽象方法
- 一个类可实现多个接口，但只能实现一个抽象类
- 接口方法默认修饰符是public，抽象方法不可用private关键字修饰

## 5、final关键字

- 修饰变量
- 修饰方法
- 修饰类，类不能被继承、成员方法都会被隐式指定为final方法

## 6、深拷贝、浅拷贝

- 浅拷贝：对基本数据类型进行值传递，引用类型进行引用传递
- 深拷贝：基本数据类型进行值传递，对于引用数据类型，创建一个新的对象，并复制其内容

## 7、ArrayList、LinkedList、Vector

- 两者都不是线程安全的
- ArrayList底层是Object数组实现，LinkedList底层是双向链表
- ArrayList可支持随机访问
- Vector类的所有方法都是同步的，线程安全，耗时大

## 8、HashMap、HashTable

- HashMap线程不安全，HashTable线程安全(内部方法synchronized修饰)
- HashMap初始底层实现方法：数组+链表；当链表长度过长时，链表转化为红黑树
- HashMap的键值可为null，HashTable键值为null会抛出异常(NullPointerException)
- HashTable使用同一把锁保证线程安全、ConcurrentHashMap通过分段锁实现线程安全

## 9、HashSet检重

HashSet首先会先计算对象的hashcode值来判断对象位置，同时也会与其他加入的对象hashcode值作比较，不相同则认为没有重复，相同的话，调用equals()方法检查哈希值相同的对象是否相同；

## 10、集合框架底层数据结构

- List
  - ArrayList：Object数组
  - Vector：Object数组
  - LinkedList：双向链表
- Set
  - HashSet（无序，唯一）；基于hashMap实现
  - LinkedHashSet：继承于HashSet，通过LinkedHashMap实现
  - TreeSet（有序，唯一）：红黑树
- Map
  - HashMap：数组+链表/数组+红黑树
  - LinkedHashMap：
  - HashTable：数组+链表
  - TreeMap：红黑树

## 11、多线程

### 11.1线程、进程

进程是程序的一次执行过程，是系统运行程序的基本单位。线程是一个比进程更小的执行单位。**同类的多个线程共享进程的堆和方法区资源**，**但每个线程有自己的程序计数器和虚拟机栈、本地方法栈。**

### 11.2程序计数器

- 实现代码流程控制
- 多线程情况下，记录当前线程执行的位置，从而保证线程切换

### 11.3线程死锁

- 多个线程同时被阻塞，都在等待某个资源被释放
- 死锁条件
  - 互斥条件：资源只能有一个线程占用
  - 请求与保持条件：进程被阻塞时，所获得资源不释放
  - 不剥夺条件：资源在被一个进程占用时，其他进程不可强行使用
  - 循环等待：若干进程形成头尾相接的循环等待资源关系

### 11.4sleep()、wait()

- sleep方法没有释放锁，wait方法释放了锁
- 都可暂停线程的执行
- sleep调用后，线程可自然苏醒，wait方法不可需调用同一对象上的notify()或notifyAll()

### 11.5 synchronized，ReentrantLock关键字

- 修饰实例方法：作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
- 修饰静态方法：是给当前类加锁，会作用于类的所有对象实例，因为静态方法不属于任何一个实例对象，是类成员。
- 修饰代码块：指定加锁对象
- **synchronized关键字加到static静态方法和synchronized(class)代码块上都是给class类上锁。synchronized关键字加到实例方法上是给对象实例上锁。**

- 底层实现

  - 同步语句块：使用的是monitorenter和monitorexit指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令指明代码块结束位置。
  - 修饰方法：使用的ACC_SYNCHRONIZED标识，JVM同过该标识辨别方法是否声明为同步方法。

- 区别

  - 两者都是可重入锁

  - synchronized依赖于JVM，ReentrantLock依赖于API（JDK层面实现）

  - ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁

  - ReentrantLock实现等待/通知机制，需要借助于Condition接口和newCondition()方法。

    - 可以实现多路通知功能，也就是一个Lock对象中可以创建多个Condition实例(对象监视器)，线程对象可以注册在指定Condition中，从而可以有选择性的进行线程通知，线程调度上更加灵活。

    - ```java
      /*
      线程A输出1 2 3，线程B输出4 5 6， 线程A输出7 8 9
       */
      public class ReentrantLock  {
          static class NumberWrapper{
              int val = 1;
          }
      
          public static void main(String[] args) {
              //初始化可重入锁
              final Lock lock = new java.util.concurrent.locks.ReentrantLock();
      
              //第一个条件当屏幕上输出到3
              final Condition condition3 = lock.newCondition();
      
              //第二个条件当屏幕上输出到6
              final  Condition condition6 = lock.newCondition();
      
              final NumberWrapper num = new NumberWrapper();
      
              //初始化线程A
              Thread threadA = new Thread(
                      new Runnable() {
                          public void run() {
                              //需要先获得锁
                              lock.lock();
                              try{
                                  System.out.println("线程A开始输出：");
                                  while(num.val <= 3)
                                  {
                                      System.out.println(num.val);
                                      num.val++;
                                  }
                                  condition3.signal();
                              }
                              finally {
                                  lock.unlock();
                              }
      
      
                              //输出7 8 9
                              lock.lock();
                              try{
                                  //等待输出
                                  condition6.await();
                                  System.out.println("线程A开始输出：");
                                  while(num.val <= 9)
                                  {
                                      System.out.println(num.val);
                                      num.val++;
                                  }
                              }
                              catch (InterruptedException ex){
                                  System.out.println(ex.getMessage());
                              }
                              finally {
                                  lock.unlock();
                              }
                          }
                      }
              );
      
              Thread threadB = new Thread(
                      new Runnable() {
                          public void run() {
                              //获得锁
                              lock.lock();
                              try{
                                  while(num.val <= 3)
                                      condition3.await();
      
                              }
                              catch (InterruptedException ex){
                                  System.out.println(ex.getMessage());
                              }
                              finally {
                                  lock.unlock();
                              }
      
                              try{
                                  lock.lock();
                                  //等待线程A输出完成，唤醒condition3
      
                                  System.out.println("线程B开始输出：");
                                  while(num.val <= 6){
                                      System.out.println(num.val);
                                      num.val++;
                                  }
                                  condition6.signal();
                              }
                              finally {
                                  lock.unlock();
                              }
                          }
                      }
              );
              threadB.start();
              threadA.start();
      
          }
      }
      ```

- synchronized 和Lock的区别
  - synchronized是java内置关键字，在jvm层面。Lock是java类
  - synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁。
  - synchronized会自动释放锁（线程执行完同步代码；线程执行过程中发生异常），Lock需要在finally里手工释放锁（unlock()）
  - 使用synchronized关键字的线程，一个线程获得锁，另一个线程需要等待，一个线程阻塞，另一个线程会一直等待；Lock锁，如果一个线程尝试获取不到锁，线程可以不用一直等待就结束了（tryLock()）；
  - synchronized的锁可重入、不可中断、非公平，Lock锁可重入、可中断、公平
  - synchronized锁适合代码少量的同步问题，Lock锁适合大量同步的代码的问题。

### 11.6 Volatile关键字

- 保证变量的可见性
- 防止指令重排
- Volatile和synchronized区别
  - volatile关键字只能用于变量，轻量级实现
  - 多线程访问volatile关键字不会发生阻塞，不能保证数据的原子性。

### 11.7 并发编程三个特性

- 原子性
- 可见性
- 有序性

### 11.8 ThreadLocal

- ThreadLocal类主要解决的就是让每个线程绑定自己的值。保证每个线程有自己的专属本地变量

### 11.9 线程实现方式

- 继承Thread类，重写run方法（无返回值）

```java

public class ThreadDemo01 extends Thread{
    public ThreadDemo01(){
        //编写子类的构造方法，可缺省
    }
    public void run(){
        //编写自己的线程代码
 System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){ 
        ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
        threadDemo01.setName("我是自定义的线程1");
        threadDemo01.start();       
        System.out.println(Thread.currentThread().toString());  
    }
}
```

- 实现Runnable接口，重写run方法(无返回值)，接口的实例作为参数传入带参的Thread构造参数

```java
public class ThreadDemo02 {
 
    public static void main(String[] args){ 
        System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start(); 
    }
}
 
class MyThread implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");
    }   

```

- 通过Callable和FutureTask创建线程
  - 创建Callable接口的实现类，重写Call方法（有返回值）
  - 创建Callable实现类的对象，使用FutureTask类包装此对象
  - 将FutureTask作为参数传递给Thread构造方法创建线程

```java

public class ThreadDemo03 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        Callable