我遇到的Java面试题汇总（2019实习篇）

2018年Java研发工程师面试题

• 秋招也已经结束,来总结一下自己在这段时间所遇到的面试题吧！这些题都是作者亲身经历所遇到的。自认为比较菜，所以碰了很多壁！在这儿分享我的求职经历！希望对你有所帮助！想走Java研发方向的话，主要还是要掌握三个重要模块：
• Java基础、数据库基础、Linux基础
• 这三个模块是我面试了大多公司的笔试题面试题都会涉及到的！还有的就是框架方面，这里我们暂且不讲！

Java实习生面试（Java基础）

• 在找正式工作前所要面对的无疑是找实习，而找实习所遇到的就相对要简单一些！考的也都相对于基础一些，但是有的公司要求有些奇葩，不仅要求你要会Java ，还要求你会前端，JavaScript ,Linux 等相关知识！想想实习生要求就如此，那正式的可想而知：
  实习一般的小的公司是直接面试，问一些基础的问题，大一点的公司都会做一套笔试题，然后再进行面试，问题大致也就以下：

1.Java有哪些基本数据类型：

八个基本类型：

项目	位数	类型	描述
boolean	1	布尔型	boolean数据类型表示一位的信息；
byte	8	整型	byte 数据类型是8位、有符号的，以二进制补码表示的整数；
char	16	字符型	char类型是一个单一的 16 位 Unicode 字符；
short	16	整型	short 数据类型是 16 位、有符号的以二进制补码表示的整数
int	32	整型	int 数据类型是32位、有符号的以二进制补码表示的整数；
float	32	浮点型	float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
long	64	整型	long 数据类型是 64 位、有符号的以二进制补码表示的整数；
double	64	浮点型	double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；

2.自动拆箱与自动装箱：

自动装箱：简单来说就是以上八种基本类型在需要的时候自动装箱为封装类型的过程。
自动拆箱：与之对应的就是数据从封装类型自动转换为基本类型的过程！

//例如：
Integer x = 2;     // 装箱
int y = x;         // 拆箱

八种数据类型拆箱和装箱对应表：

基本类型	封装类型
int	Integer
char	Character
boolean	Boolean
long	Long
short	Short
float	Float
byte	Byte
double	Double

3.关于封装类型Integer的问题辨析！

• a.由于Integer变量实际上是对一个Integer对象的引用，所以两个new生成的变量永远都不会相等；

Integer i= new Integer(100);
Integer j= new Integer(100);
System.out.print(i==j); //false

b.Integer变量和int变量比较时，只要两者的值是相同的，结果就为true；

Integer i= new Integer(100);
int j= 100;
System.out.print(i==j); //true

c.非new生成的Integer变量和new Integer（）生成的变量也不相等；

Integer i= new Integer(100);
Integer j= 100;
System.out.print(i==j); //false

d.对于两个非new生成的Integer对象，进行比较时，如果两个变量值在-128到127之间时为true，否则为false；

Integer i= 100;
Integer j= 100;
System.out.print(i==j); //true
Integer i= 128;
Integer j= 128;
System.out.print(i==j); //false

4.面向对象的三大特征：继承、多态 、封装

• a.继承：就是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
• b.多态：就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
• c.封装：就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。
• 要求能简单描述每个特征

5.int和Integer区别：

• Integer是int的包装类，int则是java中的一种基本数据类型；
• Integer变量必须实例化后才能使用，而int不需要；
• Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值；
• Integer默认的值是null，而int默认值为0；

6.Java中的equal和==的区别是什么：

• ==：运用在基本类型的时候，通过比较它们实际的值是否相同；而用在比较引用型时，则是比较两个引用的地址是否相同，也就是是否指向同一个对象；
• Equal方法：是java.lang.Object的方法，也就是所有Java类都会有的方法。他可以由程序员覆盖重写，通过自定义方式来判断两者是否相等。对于字符串java.lang.String类来说，它的equal方法用来比较两个字符串的字符序列是否完全相等；

7.接口和抽象类的区别：（频率较高）

• 抽象类：声明方法的存在而不去实现它的类，用于创建一个体现某些基本行为的类，并为该类声明方法；但不能在该类中实现的情况；
• 接口：是抽象类的变体，在接口中所有方法都是抽象的，多继承性可通过实现接口而获得；
• 最大的区别：一个实现类只能继承一个抽象类，但可以继承多个接口；抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能修改的数据的集合，两者都不能被实例化。

8.Java变量：

静态变量，成员变量，局部变量三种；

• 静态变量是指在类中用static修饰的变量，它的生存周期由类决定；
• 成员变量则是类中没有用static修饰的变量，他的生命周期由对象决定；
• 局部变量则是定义在方法里的变量，方法的参数或代码块里定义的变量，它们作用的范围用{ } 来界定；

9.Public、private、protect和默认的区别：

• private表示成员是私有的，只有自身可以访问；
• public表示成员公开，所有其他类都可以访问；
• protect表示受保护权限，体现在继承，即子类可以访问父类受保护成员，同事相同堡垒的其他类可以访问protect成员；
• 无修饰词（默认）表示包访问权限，同一个包内可以访问；

10.String、StringBuffer和StringBuilder存在的作用：

• String 字符串常量；一旦声明就不可改变；String类是final类不可继承；
• StringBuffer 字符串变量（线程安全）类中提供的方法都是同步方法；
• StringBuilder 字符串变量（非线程安全）类中方法属于异步方法；

11.Servlet的生命周期：

• Servlet是服务器端处理HTTP请求的基本组成单元，包括JSP，过滤器等在内的许多技术都给予servlet实现；
• 生命周期为：创建、初始化、提供服务、销毁；

12.面向对象的五大设计原则：

• a.单一职责原则SRP(Single Responsibility Principle)
  是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。
• b.开放封闭原则OCP(Open－Close Principle)
  一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，
  那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。
• c.替换原则(the Liskov Substitution Principle LSP)
  子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，
  也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。
• d.依赖原则(the Dependency Inversion Principle DIP) 具体依赖抽象，上层依赖下层。假设B是较A低的模块，但B需要使用到A的功能，
  这个时候，B不应当直接使用A中的具体类： 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口：这样就达到
  了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件，而编译B时同样要直接包含到A的cpp文件。
• e.接口分离原则(the Interface Segregation Principle ISP)
  模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来.

13.Error和Exception有什么区别？

• Error表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
• Exception表示一种设计或实现问题。也就是说，他表示如果程序运行正常，从不会发生的情况；

14.Java的变量分为哪两大类数据类型：

• 基本数据类型8种：byte \ short \ int \ long \ float \ double \ Boolean \ char
• 引用型数据类型：类（class）、接口（interface）、数组；
• 两者区别：引用型数据类型存放的是数据所在的地址，而基本数据类型是直接存储数据的值；

15.数组和集合的区别：

• a.数组声明了它容纳的元素类型，而集合不声明。这是由于集合是以Object形式来存储它们的元素；
• b.一个数组实例具有固定的大小，不能伸缩。集合则可以根据需要动态改变大小。
• c.数组是一种可读/可写的数据结构，没有办法创建一个只读数组。然而可以使用集合提供的ReadOnly只读方式来使用集合；该方法将返回一个集合的只读版本；

16.常考的几个基础程序，要求务必熟记：

1.各进制间转换：

public static void main(String args[]) { 
@SuppressWarnings("resource") 
Scanner input = new Scanner(System.in); 
System.out.println("请输入十进制数！"); 
Integer i = input.nextInt();
String binary = Integer.toBinaryString(i);  //十进制转二进制
String octal = Integer.toOctalString(i);    //十进制转八进制
String hex = Integer.toHexString(i);        //十进制转十六进制
System.out.println("i的二进制数是："+binary);
System.out.println("i的八进制数是："+octal);
System.out.println("i的十六进制数是："+hex);
System.out.println("请输入进制数！"); 
Integer j = input.nextInt(); 
int t = Integer.parseInt(String.valueOf(j),2);    //二进制转十进制
int b = Integer.parseInt(String.valueOf(j),8);    //八进制转十进制
int s = Integer.parseInt(String.valueOf(j),16); //十六进制转十进制
System.out.println("j的十进制数是："+t); 
System.out.println("j的十进制数是："+b); 
System.out.println("j的十进制数是："+s); 
input.close();          //必须要写
   }           

2.递归调用，循环输出数组：

public static void main(String args[]) {
int a[] = new int[20]; 
for(int i = 0; i < 20; i++) {
a[i] = getRe(i);  }
System.out.println("数组是："); 
for (int i = 0; i < a.length; i++) {
System.out.println(a[i] + "\t");}	}
 private static int getRe(int n){
 if (n==0||n==1) {return 2;}
else return getRe(n-2) + getRe(n-1); 
} 

3.冒泡排序：

  //进行冒泡排序（升序排列）
  int temp = 0; 
  //如果length太大，提出来单独定义，有利于提高程序效率！
  //为养成良好的代码习惯，建议将length提出来
  int m = a.length；
	     for(int j = 0 ;j < m ;j++){
	     for(int k = 0;k < m-j-1 ;k++) {
	    		if (a[k+1] < a[k]) {      
	    			temp = a[k];
	    			a[k] = a[k+1];
	    			a[k+1] = temp;
	    		} } } 

4.定义数组并依次输出：

@SuppressWarnings("resource")
		  Scanner input = new Scanner(System.in);
	     int i = input.nextInt();     //输入数组长度
	     int []a = new int[i];        //定义数组
	     System.out.println("请输入数组数据");
	     @SuppressWarnings("resource")
		 Scanner in = new Scanner(System.in);
	     for(int j = 0; j < a.length; j++) {
	    	 a[j]=in.nextInt();  }
	     System.out.print("未排序的数组是：");
	     for(int k = 0; k < a.length; k++) {
	    	 System.out.print(a[k]+"  ");	  }    

5.进行字符串反转：

System.out.println("反转后的字符串是：");
for(int i = str.length(); i > 0; i--){
System.out.print(str.charAt(i-1));}
字符串替换（将所有c换为0.0）：  
System.out.println(str.replaceAll("c", "0.0"));

6.获取当前时间：

public static void main(String args[]) {
	Date dat = new Date();
	int y = dat.getYear();
	int M = dat.getMonth();
	int d = dat.getDay();
	int h = dat.getHours();
	int m = dat.getMinutes();
	int s = dat.getSeconds();
System.out.println("当前时间是"+y+"年"+M+"月"+d+"日"+h+":"+m+":"+s);	}

Java实习生面试（数据库基础）

关于数据库的笔试题面试题考的最关键的还是运用，要么写出语句让你说明它的作用，要么给你一个要求让你用数据库语句写出来！关于一些理论性的问题以下是我遇到的。

1.索引：

索引是对数据库表中一或多个列的值进行排序的结构，是帮助数据库高效获取数据的数据结构；简单理解为数据库中加快检索表中数据的方法；

2.事务：

是并发控制的基本单位，所谓事务，他就是个操作序列，这些操作要么不执行，要么全部执行，是一个不可分割的工作单位；是数据库维护数据一致性的单位，在每个事务结束是，都能保持数据一致性；

3.Drop、delete与truncate的区别：

三者都表示删除；
Delete和truncate只删除表中的数据，不删除表的数据结构；
执行速度：drop>truncate>delete
一般在删除整个表的时候用drop，只删除部分数据行的时候用delete，而删除表中所有数据的时候用truncate；

4.视图：

视图是一种虚拟的表，具有和物理表相同的功能。可以对视图进行增、改、查、操作；优点是获取数据更容易；

5.数据库三大范式：

第一范式（1NF）：数据库表中的字段都是单一属性的，不可在分的；这个单一属性由基本类型构成，包括整型，实数，字符型，逻辑型，日期型等；
第二范式（2NF）：数据库表中不存在非关键字段对任意候选关键字的部分函数依赖；即所有非关键字段都完全依赖于任意一组候选关键字；
第三范式（3NF）：在第二范式的基础上，数据库表中不存在非关键字段对任意候选字段传递函数依赖；

6.SQL常用语句：

1.create table lee(id number primary key not null)       建表；
2.create view_name lee select *from Table_name;          建立视图；
3.create unique index lee_name on lee(name)；            建立索引；
4.drop index lee_name on lee;                            删除索引
5.insert into lee values（“12”，“一班”，“”）；            插入数据
6.update lee set 年龄=“20” where 姓名=“李凡”and 学号“1234”   数据更新；
7.select * from lee；                              查询lee表中的数据；
8.select * into 学生 from lee；        查询lee表中的数据并插入到学生表

7.主键约束和唯一性约束的区别：

A．主键约束在表中定义一个主键值，这是唯一确定表中每一行数据的标识符。该约束强制实体完整性。一个表中最多只有一个主键，且主键列不允许空值。
B．UNIQUE（唯一性）约束指定表中某个列或多个列不能有相同的两列或两行以上的数据存在。这种约束通过实现唯一性索引来强制实体完整性。当表中已经有了一个主键约束时，如果要在其他列上实现实体完整性，又因为表中不能有两个或两个以上的主键约束，所以只能通过创建UNIQUE约束来实现。一般的，把UNIQUE约束称为候选的主键约束。

8. 数据库的三级模式：

A．逻辑模式：也称模式，它是对数据库中数据的整体逻辑结构和特征的描述；
B.外模式：也称子模式，它是对各个用户或程序所涉及到的数据的逻辑结构和数据特征的描述。
C.内模式：也成存储模式或者物理模式，它是对数据的内部表示或底层描述；

9. 数据模型三大要素：

数据结构、数据操作、数据约束条件；

10.拓展一点数据结构 的

1.算法：

是对特定问题求解步骤的一种描述。它是指令的有效序列，其中每条指令表示一个或者多个操作。
算法应具有以下五种特性：有穷性、确定性、有效性、输入、输出；
所要达到的目标：正确性、可读性、健壮性、高效性；

2.栈和队列的区别

栈：先进后出；
队列：先进先出；

3.3种遍历：根据遍历反推结构，根据结构写出遍历；

先序遍历：根左右； 中序遍历：左根右； 后续遍历：左右根；

Java实习生面试（Linux基础）

Linux可以说是博大精深，关于Linux的面试题遇到的不是很多，但是如果想走后端开发的，Linux还是很重要的！作者目前对Linux的研究还仅限于cd 和ls 。
在这就附上两个很不错的网址吧，自认为很适合新手学习Linux基础，也花不了多少时间。

1.Linux基础入门链接：

实验楼Linux学习，作者亲验

2.Linux基础命令：

实验楼Linux基础命令学习，作者亲验

4.最后来分享两个很好的大佬的知识库：

不论是学习还是面经都是很不错的选择，后悔没有在求职之前好好看，在这分享出来给大家：
宝库一
宝库二

后面还会分享作者秋招遇到的面试笔试题（或许还有春招），简历投了一打，面试了一堆
这是秋招篇Java研发工程师面试题（秋招篇）

声明：本文所有面试的问题都是作者在实习求职期间自己遇到并总结出来的面经，答案有的摘自博客有的看书所得，不一定都能适用，希望对后来的小伙伴们有所帮助。真心感谢网上分享经验的大佬们！才疏学浅，如有错误，望指正！谢谢！