面试题

面试题

1、使用length属性获取数组长度，public、private、protected、friendly区别

1）private，同类
2）默认，同类、同包
3）protected，同类，同包，子类
4）public，所有

2、Collection和Collections区别

Collection  是一个集合接口（集合类的一个顶级接口）。
它提供了对集合对象进行基本操作的通                   
用接口方法。Collection接口在Java 类库中有很多具体的实现。
Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，
其直接继承接口有List与Set。

Collections则是集合类的一个工具类/帮助类，
其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

3、String s=new String(‘xyz’);创建了几个object对象

2个、第一个是new String创建的 'xyz'在string池中 然后在给s引用 所以是2个

4、short s1;

s1=s1+1;是否有错？

报错 因为s1未赋值

5、Overriding和Overloading区别

Override 特点 ：  
1、 override的子类的方法名称、参数类型必须要和父类方法的完全匹配，才能达到重写的效果；   
2、 override的子类的方法的返回值类型必须和 父类方法的一致，其modifier可以扩大，不可以缩小 ； 
3、 override的子类的方法所抛出的异常只能是父类方法抛出异常的子异常；  
4、被private、final等关键字修饰的方法是不能被override的； 
5、 一个不是用abstract标识的方法不可以override成abstract方法。


Overload 特点 ：  
1、在使用重载时只能通过不同的参数样式（例如，不同的参数类型，不同的参数个数，不同的参数顺序）；
2、方法的异常类型和数目不会对重载造成影响；   
3、不能通过访问权限、返回类型、抛出的异常进行重载（例如，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载
，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果）。  

6、Set里面的元素不能重复，用什么方法区分重复与否。

  采用继承Object类的equals去判断是否重复 

7、给出一个常见的runtime exception。

NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常

8、error和exception区别。

Exception：是程序本身可以处理的异常
Error：是程序无法处理的错误，这些错误标识故障发生于虚拟机自身或者发生在虚拟机试图执行应用时，一般不需要程序处理，例如：内存空间不足，栈溢出
检查异常（编译器要求必须处置的异常）：除了Error，其他的Exception类及其子类都属于可查异常，这种异常的特点是java编译器会检查他，也就是是说，当程序中出现此类异常的时候，要么try-catch捕获，要么throws，否则不能编译通过。
非检查异常（编译器不要求处置的异常）：包括运行时异常和Error

9、List和Set是否继承自Collection接口。、

Set 和List 都继承了Conllection；Set具有与Collection完全一样的接口，
因此没有任何额外的功能，不像前面有两个不同的List。实际上Set就是Collection,只 是行为不同
。(这是继承与多态思想的典型应用：表现不同的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责) 

10、abstract class和interface 的区别。

1.相同点
A. 两者都是抽象类，都不能实例化。
B. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

2. 不同点
A. interface需要实现，要用implements，而abstract class需要继承，要用extends。
B. 一个类可以实现多个interface，但一个类只能继承一个abstract class。
C. interface强调特定功能的实现，而abstract class强调所属关系。 
D. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。interface中的每一个方法都是抽象方法，都只是声明的 (declaration, 没有方法体)，实现类必须要实现。而abstract class的子类可以有选择地实现。
这个选择有两点含义：
一是Abastract class中并非所有的方法都是抽象的，只有那些冠有abstract的方法才是抽象的，子类必须实现。那些没有abstract的方法，在Abstrct class中必须定义方法体。
二是abstract class的子类在继承它时，对非抽象方法既可以直接继承，也可以覆盖；而对抽象方法，可以选择实现，也可以通过再次声明其方法为抽象的方式，无需实现，留给其子类来实现，但此类必须也声明为抽象类。既是抽象类，当然也不能实例化。
E. abstract class是interface与Class的中介。
interface是完全抽象的，只能声明方法，而且只能声明pulic的方法，不能声明private及protected的方法，不能定义方法体，也 不能声明实例变量。然而，interface却可以声明常量变量，并且在JDK中不难找出这种例子。但将常量变量放在interface中违背了其作为接 口的作用而存在的宗旨，也混淆了interface与类的不同价值。如果的确需要，可以将其放在相应的abstract class或Class中。
abstract class在interface及Class中起到了承上启下的作用。一方面，abstract class是抽象的，可以声明抽象方法，以规范子类必须实现的功能；另一方面，它又可以定义缺省的方法体，供子类直接使用或覆盖。另外，它还可以定义自己 的实例变量，以供子类通过继承来使用。

11、是否可以继承String类。

 不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变

12、try{}里有一个return语句，紧跟在try后的finally里的code会不会被执行，什么时候执行，return前执行还是return后执行。

①、如果finally中也有return，则会直接返回并终止程序，函数栈中的return不会被完成！；

②、如果finally中没有return，则在执行完finally中的代码之后，会将函数栈中的try中的return的内容返回并终止程序；

13、最有效率的方法算2*8等于几

  2*8=2 << 3；
因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运   算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。

14、两个对象值相同，x.equal(y)==true，但是却可有不同的hashcode，这句话对不对。

1) 对象相等则hashCode一定相等；
2) hashCode相等对象未必相等

15、值传递和引用传递

1、值传递

在方法的调用过程中，实参把它的实际值传递给形参，此传递过程就是将实参的值复制一份传递到函数中，这样如果在函数中对该值（形参的值）进行了操作将不会影响实参的值。因为是直接复制，所以这种方式在传递大量数据时，运行效率会特别低下。

2、引用传递

引用传递弥补了值传递的不足，如果传递的数据量很大，直接复过去的话，会占用大量的内存空间，而引用传递就是将对象的地址值传递过去，函数接收的是原始值的首地址值。在方法的执行过程中，形参和实参的内容相同，指向同一块内存地址，也就是说操作的其实都是源数据，所以方法的执行将会影响到实际对象。

16、switch是否作用在byte、long、string上。

显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，
所以，它们不能作用于swtich语句中【JDK1.7以前的版本】。

17、ArrayList和Vector区别，HashMap和Hashtable区别（了解这几个类的底层jdk中的编码方式）。

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的 

二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半



就HashMap与HashTable主要从三方面来说。 

一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现 

二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的 

三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

18、GC是什么，为什么要有GC，简单介绍GC。

C是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一:

System.gc() 或Runtime.getRuntime().gc() 。
19、float f=3.4是否正确。

  不正确。 float f=3.14f

20、介绍Java中的Collection framework。

Collection和Map类型。 在Java中提供了Collection和Map接口。

21、Collection框架中实现比较方法

    Comparable/comparator

22、String和Stringbuffer的区别

String：适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

23、final、finally、finalize区别

1.final：如果一个类被final修饰，意味着该类不能派生出新的子类，不能作为父类被继承。因此一个类不能被声明为abstract，又被声明为final。将变量或方法声明为final。可以保证他们在使用的时候不被改变。其初始化可以在两个地方：一是其定义的地方，也就是在final变量在定义的时候就对其赋值；二是在构造函数中。这两个地方只能选其中的一个，要么在定义的时候给值，要么在构造函数中给值。被声明为final的方法也只能使用，不能重写。

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

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

24、面向对象的特征

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。，同时继承也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？请看我一一为你揭开：

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

25、String是最基本的数据类型吗。

String不是基本的数据类型，是final修饰的java类，java中的基本类型一共有8个，它们分别为

26、运行时异常和一般异常的区别

相同点：

两种异常同属于Exception父类。

不同点：

(1)运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等。

(2)一般异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。

27、说出ArrayList、Vector、Linkedlist的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此 数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据 慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存 储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector 默认增长为原来一培，而ArrayList却是原来的一半

28、heap和stack区别

    堆:队列优先,先进先出（FIFO—first in first out）。
    栈:先进后出(FILO—First-In/Last-Out)。

29、Java中的异常处理机制的简单原理和应用

30、垃圾回收的原理和特点，并考虑2种回收机制

1.      Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有退的份了，例如说内存溢出和线程死锁等系统问题。

2.      Exception表示程序还能够克服和恢复的问题，其中又分为运行时异常和检查异常，运行时异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉。例如，数组越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；检查异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

Java为运行时异常和检查异常提供了不同的解决方案，编译器强制检查异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以检查异常也称为checked异常，而运行异常可以处理也可以不处理，所以编译器不强制用try..catch处理或用throws声明，所以运行异常也称为Runtime异常。

31、说出一些常用的 集合类和方法

最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。 
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作”键”和”值”），其中每个键映射到一个值。

32、描述一下JVM加载Class文件的原理和机制

  1.隐式装载， 程序在运行过程中当碰到通过new 等方式生成对象时，隐式调用类装载器加载对应的类到jvm中，
  2.显式装载， 通过class.forname()等方法，显式加载需要的类 

33、排序的几种方法，了解。（算法和数据结构在面试的时候还没有被问到）

①冒泡算法
②选择排序
③插入排序
④快速排序

34、Java语言如何进行异常处理，throws，throw，try catch finally代表什么意义，try块中可以抛出异常吗

try块表示程序正常的业务执行代码。如果程序在执行try块的代码时出现了“非预期”情况，JVM将会生成一个异常对象，这个异常对象将会被后面相应的catch块捕获。

catch块表示一个异常捕获块。当程序执行try块引发异常时，这个异常对象将会被后面相应的catch块捕获。

throw用于手动地抛出异常对象。throw后面需要一个异常对象。

throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。

finally块代表异常处理流程中总会执行的代码块。

对于一个完整的异常处理流程而言，try块是必须的，try块后可以紧跟一个或多个catch块，最后还可以带一个finally块。

try块中可以抛出异常。

35、一个’.java’源文件是否可以包括多个类，有什么限制。

  一个".java"源文件中可以包含多个类，但是只能有一个类用public修饰，并且该类名与文件名一致。

36、Java中有几种类型流，jdk为每种类型的流提供了一些抽象类以供继承，请分别说出它们是哪些类。

   字节流和字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。关于Java的I/O需要注意的有两点：一是两种对称性（输入和输出的对称性，字节和字符的对称性）；二是两种设计模式（适配器模式和装潢模式）。另外Java中的流不同于C#的是它只有一个维度一个方向。

37、Java中会存在内存泄漏吗，请简单描述。

  理论上Java因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是Java被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄露的发生。例如Hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露。下面例子中的代码也会导致内存泄露。

38、静态变量和实例变量的区别。

语法区别：静态变量需要static关键字修饰，实例变量不需要。

程序运行时的区别：静态变量从属于类，实例变量从属于对象。

实例变量必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量；

静态变量即类别量，只要程序加载了类的字节码，静态变量就会被分配空间，即可使用。

 综上，实例变量必须创建对象后通过这个对象来使用，静态变量可以直接使用类名来引用。

39、什么是Java序列化，如何实现java序列化。

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。
序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，
然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

40、是否可以从一个static方法内部发生对非static方法调用。

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，
*         才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以
*    直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例
*    对象，如果从一个static方法中发出对非static方法的调用，那个非static
*    方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部
*    发出对非static方法的调用。

41、写clone方法，通常都有一行代码。

如果要克隆的对象中还包含其他对象

则克隆后的对象是 浅拷贝 的而不是 深拷贝 的 克隆前后对象中的对象都是同一个对象

如果要深拷贝则要在clone() 方法中把对象中的对象也进行克隆

42、Java中如何跳出多重嵌套循环

采用break关键词

43、说出常用类、包、接口，各举5个。

  常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date，System，Class，List,HashMap

  常用的包：java.lang java.io java.util

  java.sql ,javax.servlet,org.apache.strtuts.action,org.hibernate

  常用的接口：Remote List Map Document

  NodeList ,Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate)、

  Session(Hibernate),HttpSession

44、Java中实现线程的方法，用关键字修饰同步方法。

第一种直接调用thread 的 run 方法， 所以， 我们往往使用Thread 子类， 即 new SubThread()。 
第二种调用 runnable 的 run 方法。 
用synchronized关键字修饰同步方法。 
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 
同步的实现方面有两种，分别是synchronized,wait与notify 
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。 
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。 
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。 
notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

45、同步和异步区别。

  所谓同步，就是发出一个功能调用时，在没有得到结果之前，该调用就不返回或继续执行后续操作
  异步与同步相对，当一个异步过程调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作。当这个调用完成后，一般通过状态、通知和回调来通知调用者。对于异步调用，调用的返回并不受调用者控制。

二、Java高级

2、写出单例模式。

    public class Singleton{

     //最后构建一个方法 供外界进行访问到 获取这个map
    public static HashMap getInstance(){
     return getMapInstance.map;
    }
    //构建静态类进行创建一个HashMap
    //静态块只有在jvm加载时候才能访问到
    public static class getMapInstance{
    //map必须是静态的 因为需要保护不被外界干扰 访问到 以免对她的值进行修改
      static HashMap map=new HashMap();
      //同理  她的值是固定的 所以在静态快中赋值
      static {
         map.put("key","keyone");
      }
    }
}

5、字符串常用方法，substring(),split()。

6、start()和run()区别。

  1.start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；通过调用Thread类的start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
  2.run（）方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的。

7、写出知道的设计模式。

  单例模式、工厂方法模式、代理模式、外观模式

8、Webservice介绍。（这个我自己没用过，渣渣了）

WebService就是一种跨编程语言和跨操作系统平台的远程调用技术

9、说出Servlet生命周期，Servlet和CGI区别。

  Servlet的生命周期分为5个阶段:
  实例化：Servlet容器创建Servlet类的实例。
  初始化：该容器调用init()方法，通常会申请资源。
  服务：由容器调用service()方法，（也就是doGet()和doPost()）。
  破坏：在释放Servlet实例之前调用destroy()方法，通常会释放资源。
  不可用：释放内存的实例。


  概括来讲，Servlet可以完成和CGI相同的功能。 

  CGI（Common Gateway Interface通用网关接口）程序来实现数据在Web上的传输，使用的是如Perl这样的语言编写的，它对于客户端作出的每个请求，必须创建CGI程序的一个新实例，这样占用大量的内存资源。由此才引入了Servlet技术。

  Servlet是一个用java编写的应用程序，在服务器上运行，处理请求信息并将其发送到客户端。对于客户端的请求，只需要创建Servlet的实例一次，因此节省了大量的内存资源。Servlet在初始化后就保留在内存中，因此每次作出请求时无需加载。

10、sleep和wait的区别。

  对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

  sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

  在调用sleep()方法的过程中，线程不会释放对象锁。

  而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

11、什么是反射，如何实现。

  是指在运行时状态中，获取类中的属性和方法，以及调用其中的方法的一种机制。这种机制的作用在于获取运行时才知道的类（Class）及其中的属性（Field）、方法（Method）以及调用其中的方法，也可以设置其中的属性值。
  1、通过Class.forName()方法加载字符串，就可以得到该字符串做代表的Class对象。
  2、通过类名调用class属性得到该类的Class对象。
  3、调用实例的getClass()方法。
  4、如果是基本类型的包装类，则可以通过调用包装类的Type属性来获得该包装类的Class对象。

12、检查字符串回文，实现英文中单词个数和单词次数统计（部分公司要求较高，需要手动编程，百度查找一些面试常用编程题即可）。

    System.out.println("请输入一个字符串");
    Scanner input = new Scanner(System.in);
    String str = input.next();
    StringBuilder sb=new StringBuilder(str);
    sb.reverse();//将str倒置的方法
    String newStr=new String(sb);
    if(str.equals(newStr)){
      System.out.println(str+"是回文字符串");
    }else{
      System.out.println(str+"不是回文字符串");
    }

13、tcp/ip协议三次握手。

  在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。 
  第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认； 
  第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态； 第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。 完成三次握手，客户端与服务器开始传送数据.

14、http协议几种请求方式，区别。

  1.options：返回服务器针对特定资源所支持的HTML请求方法 或web服务器发送测试服务器功能（允许客户端查看服务器性能）
  2.Get：向特定资源发出请求（请求指定页面信息，并返回尸体主题）
  3.Post：向指定资源提交数据进行处理请求（提交表单、上传文件），有可能导致新的资源的建立或原有资源的修改
  4.Put 向指定资源位置上上传其最新内容（从客户端向服务器传送的数据取代指定文档的内容）
  5.Head 与服务器索与get请求一致的相应，响应体不会返回，获取包含在消息头中额度原信息（与get请求类似，返回的相应中没有具体内容，用于获取报头）
  6.Delect 请求服务器删除request-URL所标示的资源（请求服务器删除页面）
  7.Trace 回显服务器收到的请求，用于测试和诊断
  8.Connect HTTP/1.1协议中能够将连接改为管道方式的代理服务器

15、Ajax请求是否可以实现同步。

    能 、默认使用async：false   设置为true则异步

16、隐藏URL方式。

    采用UrlRewriteFilter的jar包可以实现 对地址进行处理 然后返回处理过后的地址

17、描述取到一个网页内容的实现步骤，不需要具体实现过程（就是爬虫:取到网页的URL，然后从URL中国获取网页内容），考察逻辑思维能力。

    使用jsoup jar包对页面解析 该jar包提供了抓取页面html文本以及 解析的方法
     Document document =Jsoup.connect( "https://blog.csdn.net/guoxiaolongonly/article/details/51497495" ).get();//获取这个页面返回document对象jsoup的documet象
    Element element=document.body();//获取网页的主体  其中提供了head等方法可以自行查找
    System.out.println(element.getAllElements());

18、简述form表单提交post方法与get方法在字符编码、http协议方面的区别。

GET后退按钮/刷新无害，POST数据会被重新提交（浏览器应该告知用户数据会被重新提交）。
GET书签可收藏，POST为书签不可收藏。GET能被缓存，POST不能缓存 。GET编码类型application/x-www-form-url，
POST编码类型encodedapplication/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
GET历史参数保留在浏览器历史中。
POST参数不会保存在浏览器历史中。
GET对数据长度有限制，当发送数据时，
GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）。
POST无限制。GET只允许 ASCII 字符。
POST没有限制。也允许二进制数据。与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。在发送密码或其他敏感信息时绝不要使用 GET ！POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
GET的数据在 URL 中对所有人都是可见的。POST的数据不会显示在 URL 中。
GET和POST本质上就是TCP链接，并无差别。但是由于HTTP的规定和浏览器/服务器的限制，导致他们在应用过程中体现出一些不同。
GET和POST还有一个重大区别，简单的说：GET产生一个TCP数据包；
POST产生两个TCP数据包。对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）； 而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 （返回数据）

19、一个http请求从开始到结束都经历了哪些过程，简写流程图。

  1. 建立TCP连接在 HTTP 工作开始之前，Web 浏览器首先要通过网络与 Web 服务器建立连接，该连接是通过TCP来完成的，该协议与 IP 协议共同构建 Internet，即著名的 TCP/IP 协议，因此 Internet 又被称作是TCP/IP网络。HTTP 是比 TCP 更高层次的应用层协议，根据规则，只有低层协议建立之后才能进行更高层协议的连接，因此，首先要建立 TCP 连接，一般TCP连接的端口号是80。建立TCP连接需要找到连接主机，所以需要先解析域名得到 IP 再找到主机进行3 次握手建立TCP连接（两台电脑之间建立一个通信桥梁）2. Web浏览器向Web服务器发送请求命令 一旦建立了 TCP 连接，Web 浏览器就会向 Web 服务器发送请求命令。例如：GET/hello/index.jsp HTTP/1.1。浏览器发送其请求命令之后，还要以头信息的形式向Web服务器发送一些别的信息(例：Accept ,User-Agent 等 )，之后浏览器发送了一空白行来通知服务器，它已经结束了该头信息的发送。3. Web服务器应答
  客户机向服务器发出请求后，服务器会客户机进行应答，应答内容包括：协议的版本号和应答状态码 ：HTTP/1.1 200 OK，响应头信息来记录服务器自己的数据，被请求的文档内容。最后发送一个空白行来表示头信息的发送到此为结束，接着以Content-Type响应头信息所描述的格式发送用户所请求的实际数据。4. Web服务器关闭TCP连接 一般情况下，一旦 Web 服务器向浏览器发送了请求的数据，它就要关闭 TCP 连接，但是如果浏览器或者服务器在其头信息加入了这行代码：Connection:keep-aliveTCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了网络带宽。5 浏览器接受到服务器响应的数据浏览器接受服务器应答回来的 html 代码和css，和js代码再进行页面的渲染或者接受到应答的文件进行保存等操作

三、框架（只介绍自己熟悉）
1、Spring中的事务管理，支持哪几种方式，以及每种方式具体方法。

  实现方式共有两种：编码方式，声明式事务管理方式。
基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。
声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中（一般定在service层）。

2、Spring常用注解。

@Configuration把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。
@Scope注解 作用域
@Lazy(true) 表示延迟初始化
@Service用于标注业务层组件、 
@Controller用于标注控制层组件（如struts中的action）
@Repository用于标注数据访问组件，即DAO组件。
@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Scope用于指定scope作用域的（用在类上）

3、Hibernate的缓存级别。

一级缓存(session):内部缓存
事务范围：缓存只能被当前事务访问。缓存的生命周期依赖于事务的生命周期，当事务结束时，缓存也就结束生命周期。
二级缓存(sessionFactory):
缓存被应用范围内的所有事务共享。 这些事务有可能是并发访问缓存，因此必须对缓存进行更新。缓存的生命周期依赖于应用的生命周期，应用结束时， 缓存也就结束了生命周期，二级缓存存在于应用范围。集群范围：在集群环境中，缓存被一个机器或者多个机器的进程共享。缓存中的数据被复制到集群环境中的每个进程节点，进程间通过远程通信来保证缓存中的数据的一致性， 缓存中的数据通常采用对象的松散数据形式，二级缓存也存在与应用范围。

4、hibernate是什么，工作原理。

1.读取并解析配置 
2.读取并解析映射信息，创建Session Factory 
3.打开Session 
4.创建事务Transation 
5.持久化操作 
6.提交事务 
7.关闭Session
8.关闭SesstionFactory

5、hibernate如何实现延迟加载。

  在类标签Class中出现的lazy取值有true（默认值 延迟加载）、false（立即加载）两种取值如下所示：
  如果想要在获取对象的同时立即加载与之关联的自定义类型属性就需要在其多对一配置中设置lazy属性，在此处lazy属性的取值为：proxy：延迟加载（默认值）、no-proxy:无代理延迟加载,false:立即加载

6、hibernate如何怎样类之间的关系。

  类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many，来实现类之间的关系。

7、struts1是什么，工作流程。

ActionSerlvet接收客户Http请求，使用ActionForm Bean自动填充客户送来的表单数据到ActionForm Bean对象中?根据配置信息（struts_config.xml）将请求分发给相应的Action对象?Action 对象调用execute()方法处理请求（根据JavaBean和ActionForm取得业务逻辑和表单数据），并反回ActionForward对象 给ActionSerlvet对象?根据ActionForward对象的信息（目标页面），ActionServlet再次将Http请求导航到目标页 面，并发送到客户端。

8、struts2工作流程。

  用户发出请求  
  请求会被Tomcat接收到，Tomcat服务器来选择处理这个请求的Web应用，就是选择哪一个web工程来处理这个请求.

  web容器去读这个工程的web.xml  
  在web.xml中进行匹配,发现是由struts2的过滤器FilterDispatcher(StrutsPrepareAndExecuteFilter)来处理,找到该过滤器的实例(初始化).

  找到FilterDispatcher,回调doFilter()  
  通常情况下，web.xml文件中还有其他过滤器时，FilterDispatcher是放在滤器链的最后；如果在FilterDispatcher前出现了如SiteMesh这种特殊的过滤器，还必须在SiteMesh前引用Struts2的ActionContextCleanUp过滤器.

  FilterDispatcher将请求转发给ActionMapper  
  ActionMapper负责识别当前的请求是否需要Struts2做出处理.

  ActionMapper告诉FilterDispatcher，需要处理这个请求,建立ActionProxy  
  FilterDispatcher会停止过滤器链以后的部分，所以通常情况下：FilterDispatcher应该出现在过滤器链的最后。然后建立一个ActionProxy对象，这个对象作为Action与xwork之间的中间层，会代理Action的运行过程.

  ActionProxy询问ConfigurationManager,读取Struts.xml  
  ActionProxy对象刚被创建出来的时候，并不知道要运行哪个Action，它手里只有从FilterDispatcher中拿到的请求的URL.这时候,它问ConfigurationManager问到底要运行哪个Action.
  而ConfigurationManager就是负责读取并管理struts.xml的，可以简单的理解为ConfigurationManager是struts.xml在内存中的映像.
  在服务器启动的时候，ConfigurationManager会一次性的把struts.xml中的所有信息读到内存里，并缓存起来，以保证ActionProxy拿着来访的URL向他询问要运行哪个Action的时候，就可以直接匹配、查找并回答了.

  ActionProxy建立ActionInvocation对象  
  ActionProxy拿到了运行哪个Action、相关的拦截器以及所有可能使用的result信息，就可以着手建立ActionInvocation对象了，ActionInvocation对象描述了Action运行的整个过程.

  在execute()之前的拦截器  
  在execute()之前会执行很多默认的拦截器.拦截器的运行被分成两部分，一部分在Action之前运行，一部分在Result之后运行，而且顺序是刚好反过来的。也就是在Action执行前的顺序，比如是拦截器1、拦截器2、拦截器3，那么运行Result之后，再次运行拦截器的时候，顺序就变成拦截器3、拦截器2、拦截器1了。
  执行execute()方法
  根据execute方法返回的结果，也就是Result，在struts.xml中匹配选择下一个页面
  找到模版页面,根据标签库生成最终页面
  在execute()之后执行的拦截器,和8相反

  ActionInvocation对象执行完毕  
  这时候已经得到了HttpServletResponse对象了,按照配置定义相反的顺序再经过一次过滤器,向客户端展示结果.

9、spring是什么。

  是一个轻量级的、用来简化企业级应用开发的开发框架。注:    a.简化开发:    Spring对常用的api做了简化，比如，使用Spring    jdbc来访问数据库，就不用再考虑如何获取连接、关闭连接、处理异常等等。    b.解耦:    Spring容器(Spring框架的一个模块)帮我们管理    对象（包括对象的创建及对象之间的依赖关系），    这样一来，对象之间的耦合度会大大降低，提供高了    系统的维护性。    c.集成其它框架:    Spring可以将其它一些常用的框架集成进来，比如    可以将Quartz,MyBatis等集成进来。

10、介绍IOC和AOP。

  IOC容器：就是具有依赖注入功能的容器，是可以创建对象的容器，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。通常new一个实例，控制权由程序员控制，而"控制反转"是指new实例工作不由程序员来做而是交给Spring容器来做。。在Spring中BeanFactory是IOC容器的实际代表者。
  DI(依赖注入Dependency injection) ：在容器创建对象后，处理对象的依赖关系。
  
  AOP就是纵向的编程，如业务1和业务2都需要一个共同的操作，与其往每个业务中都添加同样的代码，不如写一遍代码，让两个业务共同使用这段代码。在日常有订单管理、商品管理、资金管理、库存管理等业务，都会需要到类似日志记录、事务控制、权限控制、性能统计、异常处理及事务处理等。AOP把所有共有代码全部抽取出来，放置到某个地方集中管理，然后在具体运行时，再由容器动态织入这些共有代码。

11、springmvc工作原理。

1 、  用户发送请求至前端控制器DispatcherServlet。

2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、  处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、  DispatcherServlet调用HandlerAdapter处理器适配器。

5、  HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、  Controller执行完成返回ModelAndView。

7、  HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、  DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、  ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

12、Mybatis工作流程。

  加载配置文件。需要加载的配置文件包括全局配置文件(SqlMapConfig.xml)和SQL(Mapper.xml)映射文件，其中全局配置文件配置了MyBatis的运行环境信息(数据源、事务等)，SQL映射文件中配置了与SQL执行相关的信息。
  创建会话工厂。MyBatis通过读取配置文件的信息来构造出会话工厂(SqlSessionFactory)。
  创建会话。拥有了会话工厂，MyBatis就可以通过它来创建会话对象(SqlSession)。会话对象是一个接口，该接口中包含了对数据库操作的增删改查方法。
  创建执行器。因为会话对象本身不能直接操作数据库，所以它使用了一个叫做数据库执行器(Executor)的接口来帮它执行操作。
  封装SQL对象。在这一步，执行器将待处理的SQL信息封装到一个对象中(MappedStatement)，该对象包括SQL语句、输入参数映射信息(Java简单类型、HashMap或POJO)和输出结果映射信息(Java简单类型、HashMap或POJO)。
  操作数据库。拥有了执行器和SQL信息封装对象就使用它们访问数据库了，最后再返回操作结果，结束流程。

15、简述Spring事务管理，使用什么设计模式实现。

Spring事务策略是通过PlatformTransactionManager接口实现的，它是整个Spring事务的核心。它是对事务策略的一个高度抽象，不依赖于任何具体的事务策略，而对于底层的具体的事务策略它相应的有不同的实现类。而对于不同的事务策略的切换通常由Spring容器来负责管理，应用程序既无须与具体的事务API耦合，也无须与特定的实现类耦合而将应用和持久化技术，事务API彻底分离开来。

7、如何防止SQL注入。

 不安全字符屏蔽、采用预编译语句

9、简述悲观锁和乐观锁。

  线程对共享资源进行访问或修改时，通常会认为在这个时候肯定会有其他线程和我争这个共享资源，如果不进行锁定，共享资源的值可能出现非预期的情况。在这种悲观的情况下，线程对共享资源进行操作之前先上了一把锁，相当于该线程独占该资源，这个时候其他线程如果想要访问该资源将被阻塞，直到拥有资源的线程进行unlock，其他线程才能继续进行竞争访问。

  乐观的情绪是指线程在访问共享资源时认为应该只有我在对其操作，其他人应该没有在访问，在这种情况下，所有线程对资源就进行直接访问。但竞争的问题还在，即真的发生了多个线程同时访问的情况，这时候会有一个线程访问到了，其他线程都访问失败。针对这种情况，非阻塞算法解决方法也很简单：线程发现自己没有竞争过的时候就再尝试直接访问直到访问成功。针对上面逻辑，逻辑代码大概如下

五、linux基础
1、修改系统时间命令、修改权限命令、

date -s  
chmod -R 777 /var/home/userid/cc