某公司（技术面）

一天没顾得上吃饭，连续三面真的好累的，记录一下面试过程中的问题吧，也算是对自己学习过程中的总结吧！
一面很奇怪HR面，二面技术面，三面是综合面，在这里主要说说二面过程中的问题吧！

和同学一起去的面试，大部分面了5分钟结束，不知道面试官比较感兴趣还是怎么了，就给面了30多分钟，其中的问题就记得下面这些，当然还有好多不记得了。

简历中写了自己做过的两个项目，开始是画项目流程图，还有为什么做这个项目，项目中遇到的最大问题是什么，当时是怎么解决的。

现在把一些基础的问题记录下来吧，虽然很基础，但是每一个问题都有不同的侧重点！
1. 什么是多态，为什么要使用多态？

多态是同一个行为具有多个不同表现形式或形态的能力。
多态性是对象多种表现形式的体现。
比如我们说"宠物"这个对象，它就有很多不同的表达或实现，比如有小猫、小狗、蜥蜴等等。那么我到宠物店说"请给我一只宠物"，服务员给我小猫、小狗或者蜥蜴都可以，我们就说"宠物"这个对象就具备多态性。
接下来让我们通过实例来了解Java的多态。

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
实现多态的两种方式：重载和覆盖

  覆盖，是指子类重新定义父类的虚函数的做法。
  重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

使用多态主要实现Java不能多继承的问题。

 

2.面向对象的特性，那好你再说说Java语言的特性。

面向对象的三个基本特征是：封装、继承、多态。
Java语言的特性：面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和静态的语言。

 

3.Java中单例模式有多少种，写出其中的3个

懒汉式，线程不安全
public class Singleton {
private static Singleton instance;
private Singleton (){
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
这段代码简单明了，而且使用了懒加载模式，但是却存在致命的问题。当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。也就是说在多线程下不能正常工作。
懒汉式，线程安全为了解决上面的问题，最简单的方法是将整个 getInstance() 方法设为同步（synchronized）。
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}

虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。因为在任何时候只能有一个线程调用 getInstance() 方法。但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。这就引出了双重检验锁。
双重检验锁双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，因为会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为什么在同步块内还要再检验一次？因为可能会有多个线程一起进入同步块外的 if，如果在同步块内不进行二次检验的话就会生成多个实例了。
public static Singleton getSingleton() {
if (instance == null) {                         //Single Checked
synchronized (Singleton.class) {
if (instance == null) {                 //Double Checked
instance = new Singleton();
}
}
}
return instance ;
}

这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

1. 给 instance 分配内存
2. 调用 Singleton 的构造函数来初始化成员变量
3. 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。
我们只需要将 instance 变量声明成 volatile 就可以了。
public class Singleton {
private volatile static Singleton instance; //声明成 volatile
private Singleton (){}

public static Singleton getSingleton() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}

}

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。
但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。
相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的办法。
饿汉式 static final field这种方法非常简单，因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的。
public class Singleton{
//类加载时就初始化
private static final Singleton instance = new Singleton();

private Singleton(){}

public static Singleton getInstance(){
return instance;
}
}

这种写法如果完美的话，就没必要在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式（lazy initialization），单例会在加载类后一开始就被初始化，即使客户端没有调用 getInstance()方法。饿汉式的创建方式在一些场景中将无法使用：譬如 Singleton 实例的创建是依赖参数或者配置文件的，在 getInstance() 之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。
静态内部类 static nested class我比较倾向于使用静态内部类的方法，这种方法也是《Effective Java》上所推荐的。
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}

这种写法仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。
枚举 Enum用枚举写单例实在太简单了！这也是它最大的优点。下面这段代码就是声明枚举实例的通常做法。
public enum EasySingleton{
INSTANCE;
}

我们可以通过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。创建枚举默认就是线程安全的，所以不需要担心double checked locking，而且还能防止反序列化导致重新创建新的对象。但是还是很少看到有人这样写，可能是因为不太熟悉吧。
总结一般来说，单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现，文章开头给出的第一种方法不算正确的写法。
就我个人而言，一般情况下直接使用饿汉式就好了，如果明确要求要懒加载（lazy initialization）会倾向于使用静态内部类，如果涉及到反序列化创建对象时会试着使用枚举的方式来实现单例。

4.java final finally finalize有什么不同

(1) final：修饰符（关键字），如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载

(2) finally：在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally块（如果有的话）。

(3) finalize：方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

 

 
5.有没有使用过接口，具体说说接口有什么好处

接口的概念其实并不难理解， 接口关键字Interface， 在使用时可以只定义函数体而不需求详细的实现。 再类的继承过程中可以实现多个接口而取代了类的多继承。

 

6.（接上一个问题）抽象类使用过吧?谈谈接口和抽象类的区别

在使用抽象类时需要注意几点：
1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2、抽象方法必须由子类来进行重写。
3、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。
4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
5、子类中的抽象方法不能与父类的抽象方法同名。
6、abstract不能与final并列修饰同一个类。
7、abstract 不能与private、static、final或native并列修饰同一个方法。

抽象类--抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板

接口-- -接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。

什么时候使用抽象类和接口

如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

 

7.String类了解吧？看过源代码吗，讲一讲String函数的定义，String能被继承吗？

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{
/** The value is used for character storage. */
private final char value[]; //用来存储字符串转换而来的字符数组

/** The offset is the first index of the storage that is used. */
private final int offset; //字符串起始字符在字符数组的位置

/** The count is the number of characters in the String. */
private final int count; //字符串分解成字符数组后字符的数目
}

 

8.数据库学的怎么样，增删改查应该知道吧。

1 增:
2 insert into 表名 values(0,'测试');
3 注：如上语句，表结构中有自动增长的列，也必须为其指定一个值，通常为0
4 insert into 表名(id,name) values(0,'尹当')--同上
5 2.删数据:
6 delete from 表名;
7 delete from 表名 where id=1;
8 删除结构：
9 删数据库：drop database 数据库名;
10 删除表：drop table 表名;
11 删除表中的列:alter table 表名 drop column 列名;
12 3. 改:
13 修改所有：updata 表名 set 列名='新的值，非数字加单引号' ;
14 带条件的修改：updata 表名 set 列名='新的值，非数字加单引号' where id=6;
15 4.查:
16 查询所有的数据：select *from 表名;
17 带条件的查询：
18 select *from 表名 where 列名=条件值;
19 Select * from 表名 where 列名 not like（like） '字符值'
20 分页查询：select *from 表名 limit 每页数量 offset 偏移量;

 

9.说说order by 和group by 的区别

order    by    　是按字段排序    group    by    　是按字段分类

 

 
10.看你简历熟悉linux命令，说说你常使用的10个命令，ls 命令都有哪些参数、

1.ls – List
ls会列举出当前工作目录的内容（文件或文件夹），就跟你在GUI中打开一个文件夹去看里面的内容一样。
2.mkdir – Make Directory
mkdir <new-directory-name>常见一个新目录
3.pwd – Print Working Directory
pwd显示当前工作目录

4.cd – Change Directory
对于当前在终端运行的会中中，cd <directory>将给定的文件夹（或目录）设置成当前工作目录。

5.rmdir – Remove Directory
rmdir <directory-name>删除给定的目录。

6.rm – Remove
rm <file-name>会删除给定的文件或文件夹，可以使用rm -r <directory-name>递归删除文件夹

7.cp – Copy
cp <source-file> <destination-file>命令对文件或文件夹进行复制，可以使用cp -r <source-folder> <destination-folder> 选项来递归复制文件夹。

8.mv – MoVe
mv <source> <destination>命令对文件或文件夹进行移动，如果文件或文件夹存在于当前工作目录，还可以对文件或文件夹进行重命名。

9.cat – concatenate and print files
cat <file>用于在标准输出（监控器或屏幕）上查看文件内容。

10.tail – print TAIL (from last) >
tail <file-name>默认在标准输出上显示给定文件的最后10行内容，可以使用tail -n N <file-name>指定在标准输出上显示文件的最后N行内容。

11.less – print LESS
less <file-name>按页或按窗口打印文件内容。在查看包含大量文本数据的大文件时是非常有用和高效的。你可以使用Ctrl+F向前翻页，Ctrl+B向后翻页。

12.grep
grep "<string>" <file-name>在给定的文件中搜寻指定的字符串。grep -i "<string>" <file-name>在搜寻时会忽略字符串的大小写，而grep -r "<string>" <file-name>则会在当前工作目录的文件中递归搜寻指定的字符串。

13.Find
这个命令会在给定位置搜寻与条件匹配的文件。你可以使用find <folder-to-search> -name <file-name>的-name选项来进行区分大小写的搜寻，find <folder-to-search> -iname <file-name>来进行不区分大小写的搜寻。

find <folder-to-search> -iname <file-name>

14.tar
tar命令能创建、查看和提取tar压缩文件。tar -cvf <archive-name.tar> <file1-OR-file2-OR-both-to-archive>是创建对应压缩文件，tar -tvf <archive-to-view.tar>来查看对应压缩文件，tar -xvf <archive-to-extract.tar>来提取对应压缩文件。

15.gzip
gzip <filename>命令创建和提取gzip压缩文件，还可以用gzip -d <filename>来提取压缩文件。

16.unzip
unzip <archive-to-extract.zip>对gzip文档进行解压。在解压之前，可以使用unzip -l <archive-to-extract.zip>命令查看文件内容。

17.help
<command-name> --help会在终端列出所有可用的命令,可以使用任何命令的-h或-help选项来查看该命令的具体用法。

18.whatis – What is this command
whatis <command-name>会用单行来描述给定的命令。

19.man – Manual
man <command-name>会为给定的命令显示一个手册页面。

20.exit
exit用于结束当前的终端会话。

21.ping
ping <remote-host-address>通过发送数据包ping远程主机(服务器)，常用与检测网络连接和服务器状态。

22.who – Who Is logged in
who能列出当前登录的用户名。

23.su – Switch User
su <username>用于切换不同的用户。即使没有使用密码，超级用户也能切换到其它用户。

24.uname
uname会显示出关于系统的重要信息，如内核名称、主机名、内核版本、处理机类型等等，使用uname -a可以查看所有信息。

25.free – Free memory
free会显示出系统的空闲内存、已经占用内存、可利用的交换内存等信息，free -m将结果中的单位转换成KB，而free –g则转换成GB。

26.df – Disk space Free
df查看文件系统中磁盘的使用情况–硬盘已用和可用的存储空间以及其它存储设备。你可以使用df -h将结果以人类可读的方式显示。

27.ps – ProcesseS
ps显示系统的运行进程。

28.Top – TOP processes
top命令会默认按照CPU的占用情况，显示占用量较大的进程,可以使用top -u <username>查看某个用户的CPU使用排名情况。

29.shutdown
shutdown用于关闭计算机，而shutdown -r用于重启计算机。

 

11.linux 文件的权限了解吧，讲讲，后面给出个例子问相关的权限
12.多线程怎么实现的，写一个多线程吧
13.框架了解吧，说说Spring的生命周期
14.你使用过Jsp，那好你说说JSP 是什么？Jsp的生命周期又是什么。JSP有哪些指令。
◆装载和实例化：服务端为JSP页面查找已有的实现类，如果没找到则创建新的JSP页面的实现类，然后把这个类载入JVM。在实现类装载完成之后，JVM将创建这个类的一个实例。这一步会在装载后立刻执行，或者在第一次请求时执行。
◆初始化：初始化JSP页面对象。如果你希望在初始化期间执行某些代码，那么你可以向页面中增加一个初始化方法（method），在初始化的时候就会调用该方法。
◆请求处理：由页面对象响应客户端的请求。需要注意的是，单个对象实例将处理所有的请求。在执行完处理之后，服务器将一个响应（response）返回给客户端。这个响应完全是由HTML标签和其他数据构成的，并不会把任何Java源码返回给客户端。
◆生命周期终止：服务器不再把客户端的请求发给JSP。在所有的请求处理完成之后，会释放掉这个类的所有实例。一般这种情况会发生在服务器关闭的时候，但是也有其他的可能性，比如服务器需要保存资源、检测到有JSP文件更新，或者由于其他某些原因需要终止实例等情况。如果想让代码执行清除工作，那么可以实现一个方法，并且在这个类实例释放之前调用该方法。本章随后一节“处理JSP的初始化和终止”将对此加以讨论。
 
6.Java中为什么不能使用多继承？
15.写一个冒泡排序吧