java 面试题 | 仰望·星空

1 自增
2 单例模式
3 类初始化和实例初始化
4 方法的参数传递机制
5 递归与迭代
6 成员变量与局部变量
7 Spring Bean的作用域之间有什么区别
8 Spring支持的常用数据库事务传播属性和事务隔离级别
9 SpringMVC中如何解决POST请求中文乱码问题GET的又如何处理呢
10 SpringMVC的工作流程
11 MyBatis中当实体类中的属性名和表中的字段名不一样怎么办
12 Git 分支相关命令
13 面试第二季笔记

文章目录[隐藏]

自增
单例模式
类初始化和实例初始化
方法的参数传递机制
递归与迭代
成员变量与局部变量
Spring Bean的作用域之间有什么区别
Spring支持的常用数据库事务传播属性和事务隔离级别
SpringMVC中如何解决POST请求中文乱码问题GET的又如何处理呢
SpringMVC的工作流程
MyBatis中当实体类中的属性名和表中的字段名不一样怎么办
Git 分支相关命令
面试第二季笔记

自增

public class AutoIncrement {

public static void main(String[] args) {

int i = 1;

i = i++;

int j = i++;

int k = i + ++i * i++;

System.out.println("i = " + i);

System.out.println("j = " + j);

System.out.println("k = " + k);

}

问：输出结果

答案

单例模式

问：什么是单例，有什么用。

问：单例的要点

问：单例有几种常见形式。

问：手写单例

饿汉式 – 直接实例化

* 饿汉式：

* 在类初始化时直接创建实例对象，不管你是否需要这个对象都会创建

* （1）构造器私有化

* （2）自行创建，并且用静态变量保存

* （3）向外提供这个实例

* （4）强调这是一个单例，我们可以用final修改

public class Singleton1 {

public static final Singleton1 INSTANCE = new Singleton1();

private Singleton1(){};

}

饿汉式 – 枚举式

* 枚举类型：表示该类型的对象是有限的几个

* 我们可以限定为一个，就成了单例

public enum Singleton2 {

INSTANCE

}

饿汉式 – 静态内部类形式

/**

* 静态代码块

public class Singleton3 {

public static final Singleton3 INSTANCE;

static{

INSTANCE = new Singleton3();

}

private Singleton3(){

}

懒汉式 – 线程不安全

* 懒汉式：

* 延迟创建这个实例对象

* (1)构造器私有化

* (2)用一个静态变量保存这个唯一的实例

* (3)提供一个静态方法，获取这个实例对象

public class Singleton4 {

private static Singleton4 instance;

private Singleton4(){

}

public static Singleton4 getInstance(){

if(instance == null){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

instance = new Singleton4();

}

return instance;

}

懒汉式 – 线程安全

* 懒汉式：

* 延迟创建这个实例对象

* (1)构造器私有化

* (2)用一个静态变量保存这个唯一的实例

* (3)提供一个静态方法，获取这个实例对象

public class Singleton5 {

private static Singleton5 instance;

private Singleton5(){

}

public static Singleton5 getInstance(){

if(instance == null){

synchronized (Singleton5.class) {

if(instance == null){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

instance = new Singleton5();

}

return instance;

}

懒汉式 – 静态内部类形式

* 在内部类被加载和初始化时，才创建INSTANCE实例对象

* 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。

* 因为是在内部类加载和初始化时，创建的，因此是线程安全的

public class Singleton6 {

private Singleton6(){

}

private static class Inner{

private static final Singleton6 INSTANCE = new Singleton6();

}

public static Singleton6 getInstance(){

return Inner.INSTANCE;

}

小结：

如果是饿汉式，枚举形式最简单
如果是懒汉式，静态内部类形式最简单

[collapse title="其他"]
静态代码块 – 应用示例

import java.io.IOException;

import java.util.Properties;

/**

* 静态代码块 - 应用示例

* 读取配置文件: single.properties

public class Singleton3Example {

public static final Singleton3Example INSTANCE;

private String info;

static{

try {

Properties pro = new Properties();

pro.load(Singleton3Example.class.getClassLoader().getResourceAsStream("single.properties"));

INSTANCE = new Singleton3Example(pro.getProperty("info"));

} catch (IOException e) {

throw new RuntimeException(e);

}

private Singleton3Example(String info){

this.info = info;

}

public String getInfo() {

return info;

}

public void setInfo(String info) {

this.info = info;

}

@Override

public String toString() {

return "Singleton3Example [info=" + info + "]";

}

各个单例的调用
饿汉式 – 直接实例化

import com.binz.singleton.Singleton1;

public class TestSingleton1 {

public static void main(String[] args) {

Singleton1 s = Singleton1.INSTANCE;

System.out.println(s);

}

饿汉式 – 枚举式

import com.binz.singleton.Singleton2;

public class TestSingleton2 {

public static void main(String[] args) {

Singleton2 s = Singleton2.INSTANCE;

System.out.println(s);

}

饿汉式 – 静态内部类形式

import com.binz.singleton.Singleton3;

public class TestSingleton3 {

public static void main(String[] args) {

Singleton3 s = Singleton3.INSTANCE;

System.out.println(s);

}

懒汉式 – 线程不安全

import com.binz.singleton.Singleton4;

import java.util.concurrent.*;

public class TestSingleton4 {

public static void main(String[] args) throws InterruptedException, ExecutionException {

/*Singleton4 s1 = Singleton4.getInstance();

Singleton4 s2 = Singleton4.getInstance();

System.out.println(s1 == s2);

System.out.println(s1);

System.out.println(s2);*/

Callable<Singleton4> c = new Callable<Singleton4>() {

@Override

public Singleton4 call() throws Exception {

return Singleton4.getInstance();

}

};

ExecutorService es = Executors.newFixedThreadPool(2);

Future<Singleton4> f1 = es.submit(c);

Future<Singleton4> f2 = es.submit(c);

Singleton4 s1 = f1.get();

Singleton4 s2 = f2.get();

System.out.println(s1 == s2);

System.out.println(s1);

System.out.println(s2);

es.shutdown();

}

懒汉式 – 线程安全

import com.binz.singleton.Singleton5;

import java.util.concurrent.*;

public class TestSingleton5 {

public static void main(String[] args) throws InterruptedException, ExecutionException {

Callable<Singleton5> c = new Callable<Singleton5>() {

@Override

public Singleton5 call() throws Exception {

return Singleton5.getInstance();

}

};

ExecutorService es = Executors.newFixedThreadPool(2);

Future<Singleton5> f1 = es.submit(c);

Future<Singleton5> f2 = es.submit(c);

Singleton5 s1 = f1.get();

Singleton5 s2 = f2.get();

System.out.println(s1 == s2);

System.out.println(s1);

System.out.println(s2);

es.shutdown();

}

懒汉式 – 静态内部类形式

import com.binz.singleton.Singleton6;

public class TestSingleton6 {

public static void main(String[] args) {

Singleton6 s = Singleton6.getInstance();

System.out.println(s);

}

[/collapse]

类初始化和实例初始化

public class Father {

private int i = test();

private static int j = method();

static{

System.out.print("(1)");

}

Father(){

System.out.print("(2)");

}

{

System.out.print("(3)");

}

public int test(){

System.out.print("(4)");

return 1;

}

public static int method(){

System.out.print("(5)");

return 1;

}

public class Son extends Father{

private int i = test();

private static int j = method();

static{

System.out.print("(6)");

}

Son(){

System.out.print("(7)");

}

{

System.out.print("(8)");

}

public int test(){

System.out.print("(9)");

return 1;

}

public static int method(){

System.out.print("(10)");

return 1;

}

public static void main(String[] args) {

Son s1 = new Son();

System.out.println();

Son s2 = new Son();

}

问：输出的结果

答案

(5)(1)(10)(6)(9)(3)(2)(9)(8)(7)
(9)(3)(2)(9)(8)(7)

解析
考点：类初始化过程 + 实例初始化过程 + 方法的重写。
类初始化过程：

① 一个类要创建实例需要先加载并初始化该类

main方法所在的类需要先加载和初始化

②一个子类要初始化需要先初始化父类

③一个类初始化就是执行<clinit>()方法

<clinit>()方法由静态类变量显示赋值代码和静态代码块组成
类变量显示赋值代码和静态代码块代码从上到下顺序执行
<clinit>()方法只执行一次

实例初始化过程：

实例初始化就是执行<init>()方法

<init>()方法可能重载有多个，有几个构造器就有几个<init>方法
<init>()方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
每次创建实例对象，调用对应构造器，执行的就是对应的<init>方法
<init>方法的首行是super()或super(实参列表)，即对应父类的<init>方法

方法的重写Override ：

①哪些方法不可以被重写

final方法
静态方法
private等子类中不可见方法

②对象的多态性

子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
非静态方法默认的调用对象是this
this对象在构造器或者说<init>方法中就是正在创建的对象

* 父类的初始化<clinit>：

* （1）j = method();

* （2）父类的静态代码块

* 父类的实例化方法：

* （1）super()（最前）

* （2）i = test();

* （3）父类的非静态代码块

* （4）父类的无参构造（最后）

* 非静态方法前面其实有一个默认的对象this

* this在构造器（或<init>）它表示的是正在创建的对象，因为这里是在创建Son对象，所以

* test()执行的是子类重写的代码（面向对象多态）

* 这里i=test()执行的是子类重写的test()方法

public class Father{

private int i = test();

private static int j = method();

static{

System.out.print("(1)");

}

Father(){

System.out.print("(2)");

}

{

System.out.print("(3)");

}

public int test(){

System.out.print("(4)");

return 1;

}

public static int method(){

System.out.print("(5)");

return 1;

}

* 子类的初始化<clinit>：

* （1）j = method();

* （2）子类的静态代码块

* 先初始化父类：(5)(1)

* 初始化子类：（10）(6)

* 子类的实例化方法<init>：

* （1）super()（最前）（9）（3）（2）

* （2）i = test(); （9）

* （3）子类的非静态代码块（8）

* （4）子类的无参构造（最后）（7）

* 因为创建了两个Son对象，因此实例化方法<init>执行两次

* （9）（3）（2）（9）（8）（7）

public class Son extends Father{

private int i = test();

private static int j = method();

static{

System.out.print("(6)");

}

Son(){

// super();//写或不写都在，在子类构造器中一定会调用父类的构造器

System.out.print("(7)");

}

{

System.out.print("(8)");

}

public int test(){

System.out.print("(9)");

return 1;

}

public static int method(){

System.out.print("(10)");

return 1;

}

public static void main(String[] args) {

Son s1 = new Son();

System.out.println();

Son s2 = new Son();

}

进阶要求：
Override和Overload的区别？

Override重写的要求？

方法名
形参列表
返回值类型
抛出的异常列表
修饰符

方法的参数传递机制

import java.util.Arrays;

public class PassValue {

public static void main(String[] args) {

int i = 1;

String str = "hello";

Integer num = 200;

int[] arr = {1,2,3,4,5};

MyData my = new MyData();

change(i,str,num,arr,my);

System.out.println("i = " + i);

System.out.println("str = " + str);

System.out.println("num = " + num);

System.out.println("arr = " + Arrays.toString(arr));

System.out.println("my.a = " + my.a);

}

public static void change(int j, String s, Integer n, int[] a,MyData m){

j += 1;

s += "world";

n += 1;

a[0] += 1;

m.a += 1;

}

class MyData{

int a = 10;

}

问：输出是什么？

答案

递归与迭代

编程题：有n步台阶，一次只能上1步或2步，共有多少种走法？

答案

递归：

public class Recursive{

public static void main(String[] args) {

long start = System.currentTimeMillis();

System.out.println(f(40));//165580141

long end = System.currentTimeMillis();

System.out.println(end-start);//586ms

}

//实现f(n)：求n步台阶，一共有几种走法

public static int f(int n) {

if(n<1){

throw new IllegalArgumentException(n + "不能小于1");

}

if(n==1 || n==2){

return n;

}

return f(n-2) + f(n-1);

}

迭代：

/**

* 求n台阶有多少种走法-迭代法

public class StepIteration {

public static void main(String[] args) {

long start = System.currentTimeMillis();

System.out.println(loop(40));

long end = System.currentTimeMillis();

System.out.println(end-start);//<1ms

}

public static int loop(int n){

if(n<1){

throw new IllegalArgumentException(n + "不能小于1");

}

if(n==1 || n==2){

return n;

}

int one = 2;//初始化为走到第二级台阶的走法

int two = 1;//初始化为走到第一级台阶的走法

int sum = 0;

for(int i=3; i<=n; i++){

//最后跨2步 + 最后跨1步的走法

sum = two + one;

two = one;

one = sum;

}

return sum;

}

小结：

方法调用自身称为递归，利用变量的原值推出新值称为迭代。
递归

优点：大问题转化为小问题，可以减少代码量，同时代码精简，可读性好；
缺点：递归调用浪费了空间，而且递归太深容易造成堆栈的溢出。

迭代

优点：代码运行效率好，因为时间只因循环次数增加而增加，而且没有额外的空间开销；
缺点：代码不如递归简洁，可读性好

成员变量与局部变量

public class Variable {

static int s;

int i;

int j;

{

int i = 1;

i++;

j++;

s++;

}

public void test(int j){

j++;

i++;

s++;

}

public static void main(String[] args) {

Variable obj1 = new Variable();

Variable obj2 = new Variable();

obj1.test(10);

obj1.test(20);

obj2.test(30);

System.out.println(obj1.i + "," + obj1.j + "," + obj1.s);

System.out.println(obj2.i + "," + obj2.j + "," + obj2.s);

}

问：输出结果？

答案

Spring Bean的作用域之间有什么区别

com.binz.spring.beans.Book

public class Book {

private Integer id;

private String title;

private String author;

private double price;

private Integer sales;

public Book() {

System.out.println("Book对象被创建了");

}

public Book(Integer id, String title, String author, double price, Integer sales) {

super();

this.id = id;

this.title = title;

this.author = author;

this.price = price;

this.sales = sales;

System.out.println("全参的构造器被调用");

}

public Book(Integer id, String title, String author, double price) {

super();

this.id = id;

this.title = title;

this.author = author;

this.price = price;

System.out.println("不含销量的构造器被调用");

}

public Book(Integer id, String title, String author, Integer sales) {

super();

this.id = id;

this.title = title;

this.author = author;

this.sales = sales;

System.out.println("不含价格的构造器被调用");

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

public String getAuthor() {

return author;

}

public void setAuthor(String author) {

this.author = author;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public Integer getSales() {

return sales;

}

public void setSales(Integer sales) {

this.sales = sales;

}

@Override

public String toString() {

return "Book [id=" + id + ", title=" + title + ", author=" + author + ", price=" + price + ", sales=" + sales

+ "]";

}

com.binz.spring.test.SpringTest

class SpringTest {

//01.Spring Bean的作用域之间有什么区别

//创建IOC容器对象

ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

@Test

void testBook() {

Book book = (Book) ioc.getBean("book");

Book book2 = (Book) ioc.getBean("book");

System.out.println(book==book2);

}

config.beans.xml

<!-- ★bean的作用域

可以通过scope属性来指定bean的作用域

-singleton：默认值。当IOC容器一创建就会创建bean的实例，而且是单例的，每次得到的都是同一个

-prototype：原型的。当IOC容器一创建不再实例化该bean，每次调用getBean方法时再实例化该bean，而且每调用一次创建一个对象

-request：每次请求实例化一个bean

-session：在一次会话中共享一个bean

-->

</bean>

Spring支持的常用数据库事务传播属性和事务隔离级别

2021072713041249

SpringMVC中如何解决POST请求中文乱码问题GET的又如何处理呢

2021072713063766

SpringMVC的工作流程

答案

@Controller

public class SpringMVCHandler {

public static final String SUCCESS="success";

//1.简单的谈一下SpringMVC的工作流程

//处理模型数据方式一：将方法的返回值设置为ModelAndView

@RequestMapping("/testModelAndView")

public ModelAndView testModelAndView() {

//1.创建ModelAndView对象

ModelAndView mav = new ModelAndView();

//2.设置模型数据，最终会放到request域中

mav.addObject("user", "admin");

//3.设置视图

mav.setViewName("success");

return mav;

}

* ★处理模型数据方式二：方法的返回值仍是String类型，在方法的入参中传入Map、Model或者ModelMap

* 不管将处理器方法的返回值设置为ModelAndView还是在方法的入参中传入Map、Model或者ModelMap，

* SpringMVC都会转换为一个ModelAndView对象

@RequestMapping("/testMap")

public String testMap(Map<String , Object> map) {

//向Map中添加模型数据，最终会自动放到request域中

map.put("user", new Employee(1, "韩总", "hybing@atguigu.com", new Department(101, "教学部")));

return SUCCESS;

}

流程说明（重要）：
1、客户端（浏览器）发送请求，直接请求到 DispatcherServlet。
2、DispatcherServlet 根据请求信息调用 HandlerMapping，解析请求对应的 Handler。
3、解析到对应的 Handler（也就是我们平常说的 Controller 控制器）后，开始由 HandlerAdapter 适配器处理。
4、HandlerAdapter 会根据 Handler 来调用真正的处理器来处理请求，并处理相应的业务逻辑。
5、处理器处理完业务后，会返回一个 ModelAndView 对象，Model 是返回的数据对象，View 是个逻辑上的 View。
6、ViewResolver 会根据逻辑 View 查找实际的 View。
7、DispaterServlet 把返回的 Model 传给 View（视图渲染）。
8、把 View 返回给请求者（浏览器）

MyBatis中当实体类中的属性名和表中的字段名不一样怎么办

解决方案：

1.写sql语句时起别名

<!-- id属性：必须是接口中方法的方法名

resultType属性：必须是方法的返回值的全类名

-->

select id,last_name lastName,email,salary,dept_id deptId from employees where id = #{id}

</select>

2.在MyBatis的全局配置文件中开启驼峰命名规则

<!--

开启驼峰命名规则，可以将数据库中的下划线映射为驼峰命名

例如：last_name可以映射为lastName

-->

</settings>

3.在Mapper映射文件中使用resultMap来自定义映射规则

</resultMap>

select * from employees where id = #{id}

</select>

测试用例：

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

* 解决方案：

* 1.写sql语句时起别名

* 2.在MyBatis的全局配置文件中开启驼峰命名规则

* 3.在Mapper映射文件中使用resultMap来自定义映射规则

@Test

void testGetEmployee() throws IOException {

//1.创建SqlSessionFactory对象

String resource = "mybatis-config.xml";

InputStream inputStream = Resources.getResourceAsStream(resource);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

//2.获取sqlSession，sqlSession就相当于JDBC中的connection

SqlSession sqlSession = sqlSessionFactory.openSession();

try {

//3.获取Mapper对象

EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

//4.调用EmployeeMapper中获取Employee的方法

Employee employee = mapper.getEmployeeById(1);

System.out.println(employee);

} finally {

//5.关闭sqlSession

sqlSession.close();

}

Git 分支相关命令

答案

面试第二季笔记

2021072713505218

文章 java 面试题转载需要注明出处

自增

单例模式

类初始化和实例初始化

方法的参数传递机制

递归与迭代

成员变量与局部变量

Spring Bean的作用域之间有什么区别

Spring支持的常用数据库事务传播属性和事务隔离级别

SpringMVC中如何解决POST请求中文乱码问题GET的又如何处理呢

SpringMVC的工作流程

MyBatis中当实体类中的属性名和表中的字段名不一样怎么办

Git 分支相关命令

面试第二季笔记

您必须 登录 才能发表评论！

您必须登录才能发表评论！