java后端初级工程师面试知识点

1. 方法重写

两同两小一大

两同：方法名和参数列表相同

两小：返回值类型，异常类型小于等于父类

一大：权限修饰大于等于父类

2. 一个线程不能启动(start)多次，否则报运行时异常

3. 类加载顺序：

class MyThread {
    private int a=initA();
    static int b= initB();
    public MyThread(){
        System.out.println("构造器");
    }
    public int initA(){
        System.out.println("初始化A");
        return 1;
    }
    static {
        System.out.println("静态代码块");
    }
    public static int initB(){
        System.out.println("初始化B");
        return 2;
    }
}
class Test{
    public static void main(String[] args) {
         new MyThread();
    }
}
//结果自己实验

4. 抽象类和接口的区别

1. 抽象类可以有构造方法(在子类构造方法中调用)，接口不能有构造方法

2. 抽象类中可以有普通成员变量，接口中没有普通成员变量

3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
   eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

5. synchronized 锁的是对象或类，不能锁基本数据类型，

要保证基本数据类型安全，可以在方法上加锁

6. 解决hash冲突的方法

1. 拉链发
2. 开放地址法
3. 再hash法
4. 创建公共溢区

hashmap用哪种方法，threadlocal用的哪种方法

7. short s= 1; s= s + 1;有错吗?short s= 1; s+= 1;有错吗？

隐式类型转换可以从小到大自动转，即baibyte->short->int->long如果反过来会丢失精度，必须进行显示类型转换
而s+=1的意思与s = s+1不同，s=s+1这句先执行s+1然后把结果赋给s，由于1为int类型，所以s+1的返回值是int，
编译器自动进行了隐式类型转换 所以将一个int类型赋给short就会出错，而s+=1不同由于是+=操作符，
在解析时候s+=1就等价于s = (short)(s+1)

8. Arraylist和Linkedlist在尾部添加元素时谁的效率高

数据量小于千万：

​ arraylist需要扩容时，linkedlist效率高； arrsylist不需要扩容时arraylist效率高

数据量大于千万时：

​ linkedlist在new Node对象的时间大于扩容时间，arraylist效率高

总的来说：arraylist更好，因为可以预估数据大小，设置初始值

9. 二分算法

int low=0;
int high=arr.length-1;
while(low<=high){
    int mid=(low+high) >> 1
    if(arr[mid]==key)
        return mid;
    else if(arr[mid]<key)
        low=mid+1;
    else
        high=mid-1;
}

10. 冒泡排序

for(int i=0;i<arr.length;i++){
    for(int j=0;j<arr.length-i-1;j++){
        if(arr[j]>arr[j+1]){
            int temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
}

11. OSI七层协议

物理层、数据链路层、网络层、传输层、会话层、表现层、应用层

12. 快速失败和安全失败

快速失败：在使用迭代器对集合对象进行遍历是时，同时对集合进行修改，遍历线程会抛出异常

HashMap、ArrayList 等集合类，这些在 java.util 包的集合类就都是快速失败的

解决方案：

单线程修改时：不要使用集合对象修改，而使用iterator对象修改集合，例如Iterator.remove()

多线程修改时：使用安全失败的集合类

安全失败：遍历时，先复制一个集合再遍历

java.util.concurrent 包下的类都是安全失败，比如：ConcurrentHashMap

13. 悲观锁，乐观锁

1.悲观锁，会锁数据

2.乐观锁不锁记录，增加一个version字段作为判断依据，每次更新操作都会对version+1，提交时version的值改变，则更新失败

{

select version from student where id =1;

update student set name=nn where id=1 and version =

}

14. 线程和进程的区别

根本区别：进程是操作系统分配资源的基本单位，而线程是处理器任务调度和执行的基本单位

资源开销：每个进程都有独立的代码和数据空间，进程之间的切换都会有较大的开销。线程可以看作轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器，线程之间的切换开销少

包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线共同完成的；线程是进程的一部分

15. hashmap内存泄漏问题

当hashmap以对象类型的key存入，这时改动对象对应的类的属性，由于对象的hash值是根据类中属性计算的，导致用get()取不到已经存入的数据，这样内存是可达，但是不会被用到，gc又不会回收

16. Threadlocal

里面有个map,每一个线程对应一个map;

多个线程都用到相同类对象，例如：simpleDateFormat

可以只new一个公共对象，但是又要考虑线程安全问题

解决：使用一个Threadlocal对象，把simpleDateFormat 对象放入Threadlocal中，在多线程中取出的simpleDateFormat 对象只是一个副本，解决多线程安全问题

应用：SpringJDBC 中事务管理的connection 放入ThreadLocal中使用

17. 事务的四大特征

1. 原子性：一个事务为最小单位，不可分割
2. 一致性：保证数据操作逻辑一致，例如：一个账户加钱，另一个账户减钱
3. 隔离性：不同的事务之间互不影响
4. 持久性：事务提交后，数据库永久保存

18. Spring框架支持以下五种bean的作用域：

1. singleton :bean在每个Spring ioc 容器中只有一个实例。
2. prototype：一个bean的定义可以有多个实例。
3. request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
4. session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
5. global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
   缺省的Spring bean 的作用域是Singleton

19. spring创建对象的三种方式

1.构造器

2.静态工厂：使用factory-method字段指定类中创建对象的方法

3.实例工厂：相对于静态工厂，需要先创建一个工厂类的对象

20. 简单介绍springbean的生命周期

实例化–>设置依赖–>初始化–>spring容器进行管理–>销毁前处理–>消亡

21. spring事务

• 事务隔离

  service方法中实现多个dao操作，以一个方法为单位实现事务

  spring事务本质上使用数据库事务，spring使用aop方式，增强5使用数据库事务

  隔离级别除了数据库的四种外还有一种default默认，使用数据库的隔离级别

• 事务的传播属性

​ 一个service方法除了dao操作外调用了另一个service方法，需要设置是否为一个事务

​ 默认：支持当前事务，如果当前没有事务，就创建一个新的事务（在同一个事务中）

22. springMVC怎么设定重定向和转发

在SpringMVC中仍然可以使用传统方式实现转发和重定向

​ 转发: request.getRequestDispatcher("").forward(request, response);

​ 重定向: response.sendRedirect("");

在SpringMVC中也提供了快捷方法实现转发和重定向

​ controller方法中返回字符串类型：

​ 转发：return “forward:/product/productList4.action”;

​ 重定向：return “redirect:/productList4.action”;

23. springmvc常用注解

1. @RequestParam —> 将请求中的参数与controller方法的形参绑定，value指定请求参数名，defaultValue指定默认值
2. @RequestBody(required=false) —>post的json格式的请求，转化为controller方法形参的对象类型
3. @PathVaribale —> 可以将URL中占位符参数{xxx}绑定到处理器类的方法形参中@PathVariable(“xxx“)，restful风格中使用
4. @CookieValue(value=“JSESSIONID”,required=false) —> 获取cookie值，传入cookie键，加在形参之前
5. @DateTimeFormat(pattern = “yyyy-MM-dd”) —> 转换请求中时间格式参数
6. @ResponseBody —> 返回类型转换成json格式 加在方法返回类型之前
7. @sessionAttributes(“key值”) —> 加载类上，将model中的键值对放到session中，类似于session.setAttributes，实现共享数据
   取数据的方式：
   1.@ModelAttribute(“键”) 赋值给形参
   2.ModelMap model 直接从model中取，model.get(“键”)
   3.HttpSession.getAttribute

24. SpringMVC工作流程

1.首先，将请求分给前端控制器DispatcherServlet

2.DispatcherServlet查询HandlerMapping(映射控制器)，从而找到处理请求的Controller

3.Controller执行业务逻辑后，返回一个ModelAndView

4.DispatcherServlet查询一个或多个ViewResolver(视图解析器)，找到对应的视图对象，视图对象负责渲染返回给客户端

25. SpringMVC的方法返回值类型有哪些？

1、ModoelAndView–携带视图和数据，要求前端使用JSP页面，并使用JSTL标签，才可以匹配解析后端返回的数据

@RequestMapping(value = "/product/productList.action")
   public ModelAndView itemList(){
       //定义返回对象
       ModelAndView modelAndView = new ModelAndView();
       //设置返回数据
       modelAndView.addObject("productList",list);
       //设置返回页面
       modelAndView.setViewName("/static/productList.jsp");
       return modelAndView;
   }

2、void,没有返回值

​ （1）使用request转发
​ request.getRequestDispatcher( “/static/productList.jsp” ).forward( request,response );
​ (2) 使用response重定向
​ response.sendRedirect( “/static/productList.jsp” );

3、返回字符串

​ （1）逻辑视图名： return “/static/index.html”
​ （2）转发：return “forward:product/productList4.action”;
​ （3）重定向：return “redirect:/productList4.action”;

4.json格式数据

 ````java
@ResponseBody
@RequestMapping(value="model",method = RequestMethod.POST)
public Result model(HttpServletRequest request){
	Result result = new Result(Result.RESULT_FAILURE,"系统繁忙!");
	Param param = (Param) request.getAttribute("param");
    JSONObject jobject = JSON.parseObject(param.getData().toString());
    result.setTotal(1);
    result.setData("");
    result.setCode(Result.RESULT_SUCCESS);
    result.setMsg("操作成功！");
    return result;
}
 ````

26. mybatis一级缓存和二级缓存

一级缓存

一级缓存默认开启

一级缓存作用域为同一个SqlSession

如果中间有对数据库的更新操作，缓存会清除

二级缓存

多个SqlSession之间共享数据

修改数据操作也会清空缓存

不能在多表查询的情况下使用

不推荐使用，可以用redis代替

27. 当实体类中的属性名和表中的字段名不一样 ，怎么办 ？

第1种： 通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致

第2种： 通过< resultMap>来映射字段名和实体类属性名的一一对应的关系

第3种：开启下划线转驼峰自动转换

28. springboot读取配置文件的方式

1. @value

   加在属性上 @Value(value=”${config.name}”)，值为配置文件键全称

2. @ConfigurationProperties（支持下划线转驼峰命名格式）

   加在类上@ConfigurationProperties(prefix = “supergo.username”) 添加前缀

29. springboot的核心注解是什么，主要由几个注解组成的

启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：

1. @SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。

2. @EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，
   如关闭数据源自动配置功能：

   @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class })。

3. @ComponentScan：Spring组件扫描。

30. 微服务的特点

优点

1.每个服务足够内聚，足够小，代码容易理解，开发效率提高；

2.服务之间单独部署，微服务架构让持续部署成为可能

3.每个服务可以各自进行负载均衡扩展和数据库扩展，每个服务可以根据需要部署到不同的硬件上

4.争对每个服务分别开发

5.提高容错性，单个服务内存泄漏不会让整个系统瘫痪

6.系统不会长期限制在某个技术栈上

7.代码复用，可以提取出基础服务

缺点：

1.开发人员要处理分布式系统的复杂性，

2.需要设计服务之间的通信，远程通信增加延迟

3.运维难度提高，

4.多个数据库，增加了分布式事务挑战

31. 微服务之间的通信方式

1.同步调用

• Dubbo,RPC的方式，底层采用Netty来实现，基于TCP建立的长连接

  注意：BIO,NIO只是一种网络通信模式

  BIO：为每一个连接创建一个线程

  NIO：一个线程服务多个连接，有弊端，当连接数太多，性能下降

  Netty：封装了NIO，在它的基础上，添加主从处理组，BossGroup,WorkerGroup

  编程模型：Reactor(反应堆)思想，NIO,Netty是一种实现

• Springcoud,restful http的方式，短连接的方式

性能角度：Dubbo>SpringCloud

调用方需要等待处理方的执行结果

2.异步调用

MQ，调用方无需等待执行方的处理结果

32. 分布式锁

1.mysql

乐观锁

2.redis

加锁，设置超时间，超时自动释放；

释放锁：先判断是不是该锁再释放

3.zooKeeper

33. 分布式事务

​ MQ

34. 如何解决redis并发key问题

1.分布式锁，适合分布式系统 环境

2.消息队列，串行化处理

35. Redis的持久化方式有哪些

1.默认开启一种二进制文件方式，是一种周期性持久化方式，重启恢复快，但是周期性可能导致宕机数据丢失

2.以日志形式记录每一次修改操作的文本文件方式，可以打开开到详细记录，文件大，效率低，数据完整

36. Redis缓存问题

缓存穿透：redis和mysql都没有

​ 1.设置拦截不可能的参数 2. mysql查不到则添加空值缓存+过期时间

缓存击穿：一个数据过期 ，mysql有redis没有

​ 1.设置热点数据永不过期 2. 加锁，一个线程获取到锁查询数据库，其他线程等待后重新执行方法

缓存雪崩：多条数据同时过期 ，mysql有redis没有

​ 1.设置热点数据永不过期 2. 设置不同的过期时间

37. 负载均衡

负载均衡是应对高并发的处理方式

• 服务端负载均衡

  常见的nginx,通过 nginx管理多个tomcat服务器，实现多台tomcat服务器同时对外提供服务

• 客户端负载均衡

  SpringCloud的Ribbon: 通过feign调用服务时，只需在配置文件里配置ribbon，没有其他操作

  Dubbo的Proxy

负载均衡常见的方式：

1，轮询

即按照固定顺序，顺序循环访问后台的服务器，比如上述的tomcat1，tomcat2

2，权重****

即可以根据后台服务器的硬件差异，配置权重，让性能好的服务器多处理请求

3，最小活跃数

根据服务器的压力，动态调整对请求的处理

4，ip_hash

根据客户端的ip地址做hash运算，找到对应的服务器进行处理

5，一致性hash

相同参数的请求总是发到同一提供者。

38. 设计模式的三大分类（下列模式都在spring中用到）

1. 创建型模式：工厂模式，单例模式
2. 结构型模式：代理模式(aop中用到)，适配器模式，装饰者模式
3. 行为型模式：模板方法模式，观察者模式

39. 单例模式，懒汉式和饿汉式的区别

饿汉式：在类加载的时候初始化对象

懒汉式：在方法中初始化，需要加锁

40. 代码实现工厂模式

public interface UserDao {
    void test();
}
public class UserDaoImp implements UserDao{
    @Override
    public void test() {
        System.out.println("UserDaoImp");
    }
}
public class UserDaoImp2 implements UserDao {
    @Override
    public void test() {
        System.out.println("UserDaoImp2");
    }
}
public class UserDaoFactory {
    public static UserDao bean(){
        return new UserDaoImp2();     /只需要改这里即可
    }
}
public class Test {
    public static void main(String[] args) {
        UserDao bean = UserDaoFactory.bean();
        bean.test();
    }
}

41. MQ的作用

1.应用的解耦：作为中间件，实现解耦

2.任务异步处理，提高效率

3.削峰填谷：设置消费速度

42. mysql和orecl的区别

43. JVM

jvm内存分为五个部分：

1. 虚拟机栈

   线程私有，每个方法创建一个栈帧 存放局部变量(基本数据类型和对象引用)

2. 本地方法栈

   线程私有，native方法

3. 程序计数器

   线程私有，存放 当前指令的地址

4. 本地方法区（永久代替换为原空间来实现方法区）

   线程共享，存放 运行时常量池(存放编译期生成的各种字面量和符号引用)、类信息，静态变量

5. 堆

   线程共享，存放 对象、字符串常量池

   堆分为： 新生代、老年代

   新生代分为：Eden区(新创建对象的) 、两个survivor区

   ​ Eden区和非空闲survivor区 —复制—> 空闲survivor区

   老年代：Full GC (标记清除算法)