久远银海武汉事业部Java开发岗位面经

来到公司以后，让你做一套长达九页的Java笔试题，包括了前端js的知识，css的知识，后端主要是Java基础，J2EE的相关知识,MySQL数据库的相关应用。笔试完成以后，HR现场修改试卷（主要是选择题部分，单选与多选），改完之后，聊公司，聊大学生活，假设的场景模拟，能否接受加班，出差，最后聊薪资，培养机制。

笔试回忆

前端的let与var与const的区别？

JavaScript有一个严格模式；具体作用：

• 消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为;

• 消除代码运行的一些不安全之处，保证代码运行的安全；

• 提高编译器效率，增加运行速度；

• 为未来新版本的Javascript做好铺垫。

参考链接

1、var声明一个变量，没有块级的概念，它可以跨块访问，但是不能跨方法函数访问。

	function test() {
			    var message = "hello world";   // 局部变量
			}
	test();
	console.log(message);  // 报错

2、在方法中不使用var定义的话，就会产生一个全局的变量

	function test() {
		    message = "hello world";   // 局部变量
		}
	test();
	console.log(message);  // hello world

省略掉var操作符之后，message就变成了全局变量。只要调用一次函数test()，就会定义这个变量，并且可以在函数外部访问到。在局部作用域中定义的全局变量很难维护，不推荐这么做。在严格模式下，如果像这样给未声明的变量赋值，则会导致抛出ReferenceError。
3、var声明的提升
javaScript引擎，在代码预编译时，javaScript引擎会自动将所有代码里面的var关键字声明的语句都会提升到当前作用域的顶端,如下代码：

	function foo() {
	    var age;
	    console.log(age);
	    age = 26;
	}
	foo(); // undefined

4、let声明的作用域
let定义的变量，只能在块作用域里访问，不能跨块访问，也不能跨函数访问，而var可以跨块访问。

	// var定义的变量
	if (true) {
	    var name = 'Matt';
	    console.log(name); // Matt
	}
	console.log(name); // Matt
	
	// let定义的变量
	if (true) {
	    let age = 26;
	    console.log(age); // 26
	}
	console.log(age); // ReferenceError: age没有定义

let也不允许同一个块作用域中出现冗余声明（重复声明）

	var name;
	var name;
	
	let age;
	let age; // SyntaxError；标识符age已经声明过了

et、const与var的另一个重要的区别，let、const声明的变量不会在作用域中被提升。ES6新增的let、const关键字声明的变量会产生块级作用域，如果变量在当前作用域中被创建出来，由于此时还未完成语法绑定，所以是不能被访问的，如果访问就会抛出错误ReferenceError。因此，在这运行流程进入作用域创建变量，到变量可以被访问之间的这一段时间，就称之为暂时死区。

	// name会被提升
	console.log(name); // undefined
	var name = 'Matt';
	
	// age不会被提升
	console.log(age); // ReferenceError：age没有定义
	let age = 26;

全局声明：与var关键字不同，var定义的全局变量会挂载到window对象上，使用window可以访问，而let在全局作用域中声明的变量不会成为window对象的属性

	var name = 'Matt';
	console.log(window.name); // 'Matt'
	
	let age = 26;
	console.log(window.age); // undefined

for循环中的var、let声明
for循环中var定义的迭代变量会渗透到循环体外部：

for (var i = 0; i < 5; ++i) {
    // 循环逻辑
}
console.log(i); // 5

改成使用let之后，这个问题就消失了，因为迭代变量的作用域仅限于for循环块内部：

for (let i = 0; i < 5; ++i) {
    // 循环逻辑
}
console.log(i); // ReferenceError: i没有定义

使用var和let定义for循环中的变量，循环里使用定时器setTimeout后循环结果如下代码：

for (var i = 0; i < 5; ++i) {
    setTimeout(() => console.log(i), 0)
}
// 输出5、5、5、5、5

for (let j = 0; j < 5; ++j) {
    setTimeout(() => console.log(j), 0)
}
// 输出0、1、2、3、4

let 是在代码块内有效，var 是在全局范围内有效。let 只能声明一次 ，var 可以声明多次。

当同步代码执行完毕后，开始执行异步的setTimeout代码，执行setTimeout时需要从当前作用域内寻找一个变量 i，for循环执行完毕，当前 i=5，执行setTimeout时输出为5，任务队列中的剩余4个setTimeout也依次执行，输出为5。

变量 j 是用 let 声明的，当前的 i 只在本轮循环中有效，每次循环的 j 其实都是一个新的变量，所以 setTimeout 定时器里面的 j 其实是不同的变量，即最后输出0-4。

5、const声明
const的行为与let基本相同，唯一一个重要的区别是：

const是用来定义常量的，而且定义的时候必须赋值，不赋值会报错，定义之后是不允许被修改的，修改const声明的变量会导致运行时错误。

而const声明的变量是一个对象时，修改这个对象内部的属性并不会报错。

这是因为const声明的是栈区里的内容不能修改，基本数据类型的值直接在栈内存中存储，而引用数据类型在栈区保存的是对象在堆区的地址，修改对象的属性，不会修改对象在栈区的地址，如果重新给对象person赋值，则会报错。

const person = {
    name: 'Lili'
};
person.name = 'Matt'; // ok

SQL问题

给定了四张表，需要写出按照他条件说明来书写sql语句，具体如下；

表结构如上图所示，数据不做更多的展示了
1、查询所有学生的姓名与年龄
方法1、SELECT sname,YEAR(CURDATE())-YEAR(sbirth) as age FROM student;
方法2，SELECT sname,TIMESTAMPDIFF(YEAR, sbirth, CURDATE()) as age FROM student;
参考链接
2、查询课程的cid为2的课程名以及所有参与该课程的学生

SELECT c.cid,c.cname,s.sname
FROM course c inner join implementation i
on c.cid = i.cid and c.cid = 2
INNER JOIN student s on i.sid = s.sid;

3、查询课程的cid为2的课程名、任课老师以及所有参与该课程的学生

SELECT c.cid,c.cname,t.tname,s.sname
FROM course c inner join implementation i
on c.cid = i.cid and c.cid = 2
INNER JOIN teacher t on t.tid = c.tid
INNER JOIN student s on i.sid = s.sid;

4、查询所有老师的代课情况，并且按照老师的姓名降序排列

SELECT c.cid,c.cname,t.tname
FROM course c INNER JOIN teacher t ON t.tid = c.tid;
ORDER BY t.tname DESC;

5、在查询到的视图中包括课程名，授课教师，新增字段标注为score，授课时长大于5个月的课程，score为3，小于5个月的课程，score为2

SELECT DISTINCT(c.cname),t.tname,
(CASE WHEN (MONTH(i.end_time)-MONTH(i.start_time)) < 5 THEN '2' ELSE '3' END) score
FROM implementation i INNER JOIN course c on c.cid = i.cid
INNER JOIN teacher t on t.tid = c.tid;

Java编程，查询指定文件下后缀为.txt的文件，并且输出他的绝对地址，主要考察File类+递归

以下代码带你回顾Java File的API常用方法

import java.io.File;
import java.util.LinkedList;
import java.util.List;

public class TxtFile {
    public static void main(String[] args) {
        String path = "D:"+File.separator+"java_file"+File.separator+"test02";
        System.out.println(path);
        File file = new File(path);
        List<String> result = new LinkedList<>();
        List<String> files = getFileEndWithTxt(file, result);
        files.forEach(System.out::println);
    }
    /**
     * 获取后缀为txt的文件
     * @param file 传入文件的地址
     */
    public static List<String> getFileEndWithTxt(File file,List<String> result) {
        //判断该文件是文件夹还是文件
        if (file.isDirectory()) {
            //是文件夹，则获取它包含的文件内容
            File[] files = file.listFiles();
            //遍历一个一个检测是否为文件夹
            for (File file1 : files) {
                if (file1.isDirectory()) {
                    //为文件夹则递归往文件的下一层进发相同的操作
                    getFileEndWithTxt(file1,result);
                }else {
                    //判断文件后缀
                    if (file1.getAbsolutePath().endsWith(".txt")) {
                        result.add(file1.getAbsolutePath());
                    }
                }
            }
        }else {
            //是文件夹就判断是否是以txt结尾
            if (file.getAbsolutePath().endsWith(".txt")) {
                result.add(file.getAbsolutePath());
            }
        }
        return result;
    }
}

主要考察一些基础的知识，例如接口与抽象类的应用场景，数据库表格设计相关问题