java基础面试题（3）

java基础
面向对象3大特征

1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行封装
2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针
   一、8大基本类型以及其对应的封装类
   int intger; long Long double Double byte Byte;
   char Character boolean Boolean short Short float Float
   二、重载与重写的区别
   1.重写必须继承，重载不用。
   2.重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。
   3.重写的方法修饰符大于等于父类的方法，重载和修饰符无关。
   4.重写只可以抛出父类异常的子类异常或不部分的异常，或不抛
   三、构造方法能被重写吗
   重载构造方法是可以的. 但是重写则不可以,因为被重写的前提是被继承,而构造方法根本就不能被继承,所以谈不上被重写.
   四、抽象类与接口的区别
   1.抽象类可以有构造方法，接口中不能有构造方法。
   2.抽象类中可以有普通成员变量，接口中没有普通成员变量
   3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected
   但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
   五、short s1=1;s1=s1+1;有什么错?short s1=1;s1+=1;有什么错?
   short s1=1;s1=s1+1; 注释: s1为byte数据类型,后面加上1int类型,最终为int类型,需 要强转成byte类型 s1= (byte)(s1+1);
   short s1=1;s1+=1; 注释: 该表达式支持自动强转,但很容易造成数据溢出
   API
   一、stringbuffer和stringbuilder的区别
8. 在执行速度方面的比较：StringBuilder > StringBuffer
9. StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快了。
10. StringBuilder：线程非安全的
    　 StringBuffer：线程安全的
    当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。
    对于三者使用的总结：1.如果要操作少量的数据用 = String
    　　　　　　 2.单线程操作字符串缓冲区 下操作大量数据 = SringBuilder
    　　　　　　 3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
    二、写出5个常见的运行时异常
    NullPointerException - 空指针引用异常
    ClassCastException - 类型强制转换异常。
    IllegalArgumentException - 传递非法参数异常。
    ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
    IndexOutOfBoundsException - 下标越界异常
    NegativeArraySizeException - 创建一个大小为负数的数组错误异常
    NumberFormatException - 数字格式异常
    三、线程与进程的区别
    进程和线程的主要差别进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

1. 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

2. 线程的划分尺度小于进程，使得多线程程序的并发性高。

3. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

4. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
   四、线程的五大状态
   1.新建状态(New)：
   当用new操作符创建一个线程时， 例如new Thread®，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码
   2.就绪状态(Runnable)
   一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
   处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。
   3.运行状态(Running)
   当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

   4. 阻塞状态(Blocked)
      线程运行过程中，可能由于各种原因进入阻塞状态:
      1>线程通过调用sleep方法进入睡眠状态；
      2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
      3>线程试图得到一个锁，而该锁正被其他线程持有；
      4>线程在等待某个触发条件
      所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
   5. 死亡状态(Dead)
      有两个原因会导致线程死亡：
      1. run方法正常退出而自然死亡，
      2. 一个未捕获的异常终止了run方法而使线程猝死。
         为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的,或者线程死亡了，则返回false.
         五、sleep与wait的区别
         sleep指线程被调用时，占着CPU不工作，此时，系统的CPU部分资源被占用，其他线程无法进入，会增加时间限制。
         wait指线程处于进入等待状态，此时线程不占用任何资源，不增加时间限制。
         所以
         sleep（100L）意思为：占用CPU，线程休眠100毫秒
         wait（100L）意思为：不占用CPU，线程等待100毫秒
         notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
         Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争
         六、java实现线程同步
         分别用ReentrantLock Synchronized
         ReentrantLock 和 Synchronized的区别

1. 如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断
   如果 使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情
2. synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally{}中
3. 在资源竞争不是很激烈的情况下，Synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态；
4. synchronized：
   在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，
   ReentrantLock:
   ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。
   七、Java中创建线程主要有三种方式：
   一、继承Thread类创建线程类
   （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
   （2）创建Thread子类的实例，即创建了线程对象。
   （3）调用线程对象的start()方法来启动该线程。
   二、通过Runnable接口创建线程类
   （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
   （2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
   （3）调用线程对象的start()方法来启动该线程。
   三、通过Callable和Future创建线程
   （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
   （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
   （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
   （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
   八、collection与collections区别、Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
   Collection是个java.util下的接口，它是各种集合结构的父接口。
   List, Set, Map是否继承自Collection接口? List，Set是 Map不是
   List、Map、Set三个接口，存取元素时，各有什么特点？
   list:存储元素的时候是以数组的形式进行存储–有序可重复存相同值。
   map:是以键值对的形式进行存储–entry(key,value)。
   set：存储的元素是不允许重复的–无序,不可重复。
   九、ArrayList和Vector的区别.
   Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。
   数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
   十、hashtable和hashmap的区别
   1.Hashtable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。
   查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized 关键字，而HashMap的源代码中则连 synchronized 的影子都没有，当然，注释除外。
5. Hashtable不允许 null 值(key 和 value 都不可以)，HashMap允许 null 值(key和value都可以)。
6. 两者的遍历方式大同小异，Hashtable仅仅比HashMap多一个elements方法。
   Hashtable 和 HashMap 都能通过values()方法返回一个 Collection ，然后进行遍历处理：
   两者也都可以通过 entrySet() 方法返回一个 Set ， 然后进行遍历处理：
   .HashTable使用Enumeration，HashMap使用Iterator
   .Hashtable中hash数组默认大小是11，增加的方式是 old2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数
   十一、常用的IO流
   bufferedOutputStream：实现缓冲。
   BufferedInputStream为另一个输入流添加一些功能
   FileOutputStream是用于将数据写入 File 的输出流，
   FIleInputStream是用于将数据写入 File 的输入流，
   ObjectOutputStream;用于读取（重构）对象。
   ObjectInputStream对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化
   FileReader用于处理文件的字符读取流对象。
   FileWriter处理文件的字符写入流对象
   InputStreamReader字节到字符的桥梁，可从底层输入流读取一个或多个字节
   OutputStreamWriter字符到字节的桥梁。
   BufferedReader创建一个缓冲字符输入流
   BufferedWriter将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
   十二、什么是序列化，如何实现序列化
   序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
   序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
   十三、说出一些常用的类，包，接口，请各举5个
   类:1.java.lang.Object
   2.java.lang.String
   3.java.lang.System
   4.java.io.file
   5.java.io.FileInputStream
   包: 1.java.lang包
   2.java.io包
   3.java.swt包
   4.java.util包
   5.java.sql包
   接口: 1.java.util.List
   2.java.util.Map
   3.java.util.Iterator
   4.java.sql.CallableStatement
   5.java.lang.Comparable
   延伸：
   J2SE:java2 Standard edition (java 2 标准版)
   J2EE:java2 enterprise edition( Java 2 企业版)
   J2ME:java2 micro edition (Java 2 微缩版)
   写出一个Singleton出来
   public class Singleton {
   private static Singleton instance = null;
   public static synchronized Singleton getInstance() {
   if (instance==null){
   nstance＝new Singleton()
   }
   return instance;
   }
   }
   十四、final finally finalize区别
   final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
   finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
   finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。
   数据库
   一、Mysql与oracle的区别
   mysql免费 oracle收费
   MYSQL里用字段名like%‘字符串%’，ORACLE里也可以用字段名like%‘字符串%’但这种方法不能使用索引
   MYSQL 插入字符串用单引号或双引号，ORACLE只能用单引号
   Mysql 数字可以用int double 等字符串用varchar oracle数字用number 字符可以用varhcar2
   MYSQL日期字段分DATE和TIME两种，ORACLE日期字段只有DATE
   MYSQL处理翻页的SQL语句比较简单，用LIMIT开始位置，ORACLE处理翻页的SQL语句就比较繁琐了。
   MYSQL有自动增长的数据类型，插入记录时不用操作此字段，会自动获得数据值。ORACLE没有自动增长的数据类型，需要建立一个自动增长的序列号，插入记录时要把序列号的下一个值赋于此字段。
   Mysql 分页 select * from emp where empnolimit 0,20
   Oracle 分页select * from (select rownum rn,t. from (select sal from emp_li order by sal desc) t where rownum<=5);
   oracle去重：
   delete from emp_g
   where ename in
   (select ename from emp_g group by ename having count()>1)
   and rowid not in
   (select min(rowid) from emp_g group by ename having count()>1)
   二、如何优化数据库sql
   调整服务器内存分配
   尽量避免select * 的存在，使用具体的列代替*，避免多余的列
   避免在索引列上使用计算．
   避免在索引列上使用IS NULL和IS NOT NULL
   减少对表的查询
   用索引提高效率
   用EXISTS替代IN、用NOT EXISTS替代NOT IN：

三、索引
什么时候用？
应该只为最经常查询和最经常排序的数据列建立索引。
只有表或视图的所有者才能为表创建索引

优点：
第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二，可以大大加快 数据的检索速度，这也是创建索引的最主要的原因。
第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四，在使用分组和排序 子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
缺点
第一，创建索引和维护索引要耗费时间，这种时间随着数据 量的增加而增加。
第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
四、触发器：在一表执行一个事件时触发另一个事件
优点：

1. 自动执行。触发器在对表的数据作了任何修改（比如手工输入或者应用程序的操作）之后立即被激活。
2. 级联更新。触发器可以通过数据库中的相关表进行层叠更改，这比直接把代码写在前台的做法更安全合理。
3. 强化约束。触发器可以引用其它表中的列，能够实现比CHECK约束更为复杂的约束。
   1.缺点占用SGA（用于存储数据库信息的内存区）中的内存，所以太多存储过程会对服务器造成很大的压力
   2.各种数据库的存储过程语法相差很大，给将来的数据库移植带来很大的困难
   五、存储过程
   存储过程是一组予编译的SQL语句
   优点：
   ①重复使用。存储过程可以重复使用，从而可以减少数据库开发人员的工作量。
   ②减少网络流量。存储过程位于服务器上，调用的时候只需要传递存储过程的名称以及参数就可以了，因此降低了网络传输的数据量。
   ③安全性。参数化的存储过程可以防止SQL注入式攻击，
   缺点：
   移植问题，数据库端代码当然是与数据库相关的。但是如果是做工程型项目，基本不存在移植问题。
   3：重新编译问题，因为后端代码是运行前编译的，如果带有引用关系的对象发生改变时，受影响的存储过程、包将需要重新编译（不过也可以设置成运行时刻自动编译）。
   4： 如果在一个程序系统中大量的使用存储过程，到程序交付使用的时候随着用户需求的增加会导致数据结构的变化，接着就是系统的相关问题了，最后如果用户想维护该系统可以说是很难很难、而且代价是空前的，维护起来更麻烦。
   六、怎么保证多台服务器数据一致性
   1、采用高可用sureHA软件镜像型，一台主服务器，一台备服务器，通过心跳线（网线）实时将数据备份，实现服务器双机互备的功能，此方式保证多台服务器之间数据的一致性。
   2、采用高可用sureHA双机热备共享型。一台主服务器，一台备服务器，链接一台存储，将数据放到存储里面，实现数据的共享。此方式保证多台服务器之间数据的一致性。
   3可实现服务器虚拟化，把所有的服务器物理资源都整理成一个大的资源池，数据都存放在磁盘阵列上面，所有应用系统都通过调用磁盘阵列里面的数据，此方式保证多台服务器之间数据的一致性。
   七．如何复制一张表。
   两种方法复制表结构不复制数据：
   1.create table B as select * from A where 1=2;

或者：

2.create table B like A;
八、事务的：原子性、一致性、分离性、持久性
原子性：整个事务中的所有操作要么全部提交成功，要么全部失败回滚，对于一个事务来说，不可以只执行其中的一部分操作。
持久性（durability）：一旦事务提交，则其所做的修改就会永久保存到数据库中。
隔离性：事务的执行是互不干扰的，一个事务不可能看到其他事务运行时，中间某一时刻的数据
一致性：一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。
　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

第一范式1NF:字段不可分;
第二范式2NF:有主键，非主键字段依赖主键;
第三范式3NF:非主键字段不能相互依赖;

解释:
1NF:原子性 字段不可再分,否则就不是关系数据库;
2NF:唯一性 一个表只说明一个事物;
3NF:每列都与主键有直接关系，不存在传递依赖;

前端
一、定义方式
相对定位
想让一个元素在他本来的位置做一些调整(位移)，我们可以将该元素定位设置为relative，同时指定相对位移(利用top,bottom,left,right)。
absolute(绝对定位)
如果你想在一个文档(Document)中将一个元素放至指定位置，你可以使用absolute来定位，将该元素的position设置为absolute，同时使用top,bottom,left,right来定位。
如果没有父元素，位置是相对于body来进行的。
绝对定位会使元素从文档流中被删除，结果就是该元素原本占据的空间被其它元素所填充。
(固定定位)
根据屏幕的位置
获取对象
节点的类型有那些?
ELEMENT_NODE: 1, 元素节点
ATTRIBUTE_NODE: 2, 属性节点
TEXT_NODE: 3, 文本节点
如何访问节点?

1. getElementById(id); // 根据标签的id 属性来寻找节点，返回的是单个节点
2. getElementsByName(name); // 根据标签的name属性寻找节点，返回的是集合
3. getElementsByTagName(tagName) // 根据标签名称寻找节点返回的是集合
4. getElementsByClass(className) // 根据class样式寻找节点，返回的是集合
   二、jQuery选择器
   层叠选择器：如：$("forminput")选择所有的form元素中的input元素基本过滤选择器：如：$(“tr:first”)选择所有tr元素的第一个
   内容过滤选择器：如：$("div:contains{(}^{\prime }Joh{n}^{\prime })")选择所有div中含有John文本的元素可视化过滤选择器：如：$(“div:hidden”)选择所有的被hidden的div元素
   属性过滤选择器：如：$("div[id]")选择所有含有id属性的div元素子元素过滤选择器：如：$(“div span:first-child”)返回所有的div元素的第一个子节点的数组
   表单元素选择器：如：$(":text")选择所有的textinput元素表单元素过滤选择器：如：$(":checked")选择所有的被checked的表单元素

前端除了jQ框架还有什么长用的框架
gulp.js grunt sea.js Bootstrap、React、Angular
servlet与jsp
一、jsp九大内置对象 四大作用域
request 请求对象　 类型 javax.servlet.ServletRequest 作用域 Request
response 响应对象 类型 javax.servlet.SrvletResponse 作用域 Page
pageContext 页面上下文对象 类型 javax.servlet.jsp.PageContext 作用域 Page
session 会话对象 类型 javax.servlet.http.HttpSession 作用域 Session
application 应用程序对象 类型 javax.servlet.ServletContext 作用域 Application
out 输出对象 类型 javax.servlet.jsp.JspWriter 作用域 Page
config 配置对象 类型 javax.servlet.ServletConfig 作用域 Page
page 页面对象 类型 javax.lang.Object 作用域 Page
exception 例外对象 类型 javax.lang.Throwable 作用域 page

jsp四个作用域
application作用域就是服务器启动到关闭的整段时间，在这个作用域内设置的信息可以被所有应用程序使用。application作用域上的信息传递是通过ServletContext实现的.
session作用域比较容易理解，同一浏览器对服务器进行多次访问，在这多次访问之间传递信息，就是session作用域的体现,
一个HTTP请求的处理可能需要多个Servlet合作，而这几个Servlet之间可以通过某种方式传递信息，但这个信息在请求结束后就无效了。Servlet之间的信息共享是通过HttpServletRequest接口的两个方法来实现的。
page对象的作用范围仅限于用户请求的当前页面，对于page对象的引用将在响应返回给客户端之后被释放，或者在请求被转发到其他地方后被释放。对page对象的引用通常存储在pageContext对象中。
二、jsp指令与动作
jsp命令指令用来设置与整个jsp页面相关的属性，它并不直接产生任何可见的输出,而只是告诉引擎如何处理其余JSP页面。其一般语法形式为： <%@ 指令名称 属性=“值”%>
三种命令指令分别是page、include、taglib。
一、page指令。
功能：设定整个JSP网页的静态属性。
语法：<%@ page 标签元素=“值”%>,比如 <%@ page language=“java”%>
标签元素：language、import、contentType、session、errorPage、isErrorPage等等。
1、language
language=“language” 指定JSP Container要用什么语言来编译JSP网页。目前只可以使用Java语言，不过不排除增加其它语言。默认值为Java。比如 <%@ page language=“java”%>
2、import
import=“importList” 定义此JSP页面可以使用哪些Java API。用逗号分隔列出一个或多个全质类名。此列表用于在生成的java servlet中创建相应的导入语句。以下包是自动包含的，不必被指出：java.lang.;java.servlet.;java.servlet.jsp.;java.servlet.http. 比如<%@ page import=“java.util.*”%>
3、contentType
contentType=“ctinfo” 表示将在生成servlet中使用的MIME(Multipurpose Internet Mail Extensions)多用途互联网邮件扩展 类型和可选字符解码。比如<%@ page contentType=“text/html;charset=GBK”%>
4、session
session=“true|false” 指明JSP页面是否需要一个HTTP会话，如果为true，那么产生的servlet将包含创建一个HTTP会话（或访问一个HTTP会话）的代码，缺省为true。
5、errorPage
errorPage=“error_url” 表示如果发生异常错误，网页会被重新指向一个URL页面。错误页面必须在其page指令元素中指定isErrorPage=“true”
6、isErrorPage
isErrorPage=“true|false” 如果此页面被用作处理异常错误的页面，则为true。在这种情况下，页面可被指定为另一页面page指令元素中errorPage属性的取值。指定此属性为true将使exception隐含变量对此页面可用。缺省值为false。
二、include指令
功能：include指令用来向当前页面插入一个静态文件的内容。这个文件可以是JSP、HTML、文本或是Java程序。
语法：<%@ include file=“filename” %> 比如 <%@ include file=“111.txt” %>
标签元素：file
注意：include指令元素和行为元素主要有两个方面的不同点。
1.include指令是静态包含，执行时间是在编译阶段执行，引入的内容为静态文要，在编译成servlet时就和包含者融合到一起。所以file不能是一个变量，也不能在file后接任何参数。
2.include行为是动态包含，执行时间是在请求阶段执行，引入的内容在执行页面时被请求时动态生成再包含到页面中。
三、taglib指令
功能：使用标签库定义新的自定义标签，在JSP页面中启用定制行为。
当页面引用了用户自定义标签时，taglib指令用于引用自定义标签库，并指定标签的前缀。
语法：<%@ taglib uri=“URIToTagLibrary” prefix=“tagPrefix” %>
如<%@ taglib uri=“http://www.jspcentral.com/tags” prefix=“JAXP” %>
标签元素：uri、Prefixpage指令元素的属性
uri=“tagLibraryURI” 标签库描述器的URI，主要是说是tagLibrary的存放位置。
prefix=“tagPrefix” 用于标识在页面后面部分使用定制标签的唯一前缀。
前缀在标签的名字前面使用，例如，在中public在loop前面。空的前缀将被忽略。如果你正在开发或使用自定义的标签的话，你不能使用标签前缀：jsp，jspx，java，javax，servlet，sun和sunw等，因为他们已经被Sun的系统的所使用。
三、JSP基本动作
JSP中的动作元素包括：include、forward、useBean、getProperty、setProperty、plugin、param。
1.include动作
jsp:include标签用来包含一个静态或者动态的文件。
2.forward动作
jsp:forward标签用来重定向一个静态HTML文件、JSP文件或者是一个程序段。
3.useBean动作
jsp:useBean标签用来在JSP页面中创建一个Bean实例，并指定其名称和作用范围。
4.getProperty动作
jsp:getProperty标签用来获取Bean的属性值（在此之前必须用jsp:useBean创建它），并将之转化为一个字符串，然后将其插入到输出的页面中。
5.setProperty动作
jsp:setProperty标签表示用来设置Bean中的属性值。
6.plugin动作
jsp:plugin 标签用于在浏览器中播放或显示一个对象（典型为applet和Bean），这种显示需要在浏览器上安装Java插件。当JSP文件被编译后送往浏览器时，jsp:plugin元素将会根据浏览器的版本替换成或者元素。
7.param动作
jsp:param标签用来传递参数，必须与forward、include及plugin动作配合使用
四、servlet 与 jsp的区别
JSP在本质上就是SERVLET,但是两者的创建方式不一样.
Servlet完全是JAVA程序代码构成，擅长于流程控制和事务处理，通过Servlet来生成动态网页很不直观.
JSP由HTML代码和JSP标签构成，可以方便地编写动态网页.
因此在实际应用中采用Servlet来控制业务流程，而采用JSP来生成动态网页.
在struts框架中，JSP位于MVC设计模式的视图层，而Servlet位于控制层.
JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。
JSP编译后是“类servlet”。
Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP是Java和HTML组合成一个扩展名为.jsp的文件。
JSP侧重于视图，Servlet主要用于控制逻辑.
五，转发与重定向的区别
1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从效率来说
forward:高.
redirect:低.
六、servlet生命周期
Servlet生命周期分为三个阶段：
　　1. init()方法
在Servlet的生命周期中，仅执行一次init()方法，它是在服务器装入Servlet时执行的，可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init()；
2. service()方法 它是Servlet的核心，每当一个客户请求一个HttpServlet对象，该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法
3. destroy()方法
仅执行一次，在服务器端停止且卸载Servlet时执行该方法，有点类似于C++的delete方法。
Servlet工作原理：
Servlet接收和响应客户请求的过程，首先客户发送一个请求，Servlet是调用service()方法对请求进行响应的，service()方法中对请求的方式进行了匹配，选择调用doGet,doPost等这些方法，然后再进入对应的方法中调用逻辑层的方法，实现对客户的响应。
cookie 和session 的区别：
1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
考虑到安全应当使用session。
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能
考虑到减轻服务器性能方面，应当使用COOKIE。
4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
5.cookie关闭浏览器就失效 session默认保存30分钟
6、所以个人建议：
将登陆信息等重要信息存放为SESSION
其他信息如果需要保留，可以放在COOKIE中
MVC
全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写
Model（模型）是应用程序中用于处理应用程序数据逻辑的部分。
　　通常模型对象负责在数据库中存取数据。
View（视图）是应用程序中处理数据显示的部分。
　　通常视图是依据模型数据创建的。
Controller（控制器）是应用程序中处理用户交互的部分。
　　通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

SpringMVC运行原理

1. 客户端请求提交到DispatcherServlet
2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller
3. DispatcherServlet将请求提交到Controller
4. Controller调用业务逻辑处理后，返回ModelAndView
5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
6. 视图负责将结果显示到客户端
   DispatcherServlet是整个Spring MVC的核心。
   spring bean的作用域
   singleton作用域 ：
   当一个bean的作用域设置为singleton，那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

prototype ：
prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）都会产生一个新的bean实例，相当于一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个 prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了

Request：
request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效

session
session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效

global session
global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么，web会自动当成session类型来使用。

Spring 框架是一个分层架构，由 7 个定义良好的模块组成
。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
spring原理
内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射，反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 。
Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是 在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过 配置类达到的。
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置 内部通过反射去动态的组装对象）

spring依赖注入：依赖注入其实就是控制反转，它分为构造方法注入，set方法注入，接口注入，我们最常用的就是set方法注入。
Spring的AOP
优点：
AOP只是一种编程范式，用于提供从另一角度来考虑程序结构以完善面向对象编程。主要优点有：1-降低模块之间的耦合度。2-使系统容易扩展。3-更好的代码复用。

AOP的概念(切面,连接点,通知[顾问],切入点,[引入,关注点],目标对象, 代理对象, 织入目标)
2.1 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子
在Aspect中 声明类似于Java 中的类声明，在Aspect中会包含着一些切入点Pointcut 以及对切入点进行相应的操作的通知Advice。
2.2 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。
2.3 通知（Advice）有时候也叫处理：Advice(通知):所谓通知是指拦截到切入点之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知
2.4 切入点（Pointcut）：连接点集合
2.5 Target Object）： 被一个或者多个切面所通知的对象。也被称做被通知（advised）对象
2.6 AOP代理（AOP Proxy）：AOP框架创建的对象，用来实现切面功能（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
2.7 织入 (Weave):指将切面应用到目标对象并导致代理对象创建的过程称为织入.
2.8 引入(Introduction):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法
AOP的通知
3.1 前置通知：执行目标方法前拦截到的方法。没有特殊注意的地方，只需要一个连接点，JoinPoint,即可获取拦截目标方法以及请求参数。
3.2 后置通知： 切面的后置通知，不管方法是否抛出异常，都会走这个方法。只需要一个连接点，JoinPoint,即可获取当前结束的方法名称。
3.3 返回通知： 在方法正常执行通过之后执行的通知叫做返回通知。此时注意，不仅仅使用JoinPoint获取连接 点信息，同时要在返回通知注解里写入，resut=“result”。在切面方法参数中加入Object result,用于接受返回通知 的返回结果。如果目标方法方法是void返回类型则返回NULL
3.4 异常通知： 在执行目标方法过程中，如果方法抛出异常则会走此方法。和返回通知很相似，在注解中 加入，throwing=“ex”，在切面方法中加入Exection ex用于接受异常信息
3.5 环绕通知：环绕通知需要携带ProceedingJoinPoint 这个类型的参数，环绕通知类似于动态代理的全过程 ProceedingJoinPoint类型的参数可以决定是否执行目标函数环绕通知必须有返回值。其实就是包含了所有通知的全 过程

MyBatis与Hibernate的区别
两者相同点
• Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。
• Hibernate和MyBatis都支持JDBC和JTA事务处理。
Mybatis优势
• MyBatis可以进行更为细致的SQL优化，可以减少查询字段
•mybatis是把sql语句与java代码分离了…sql语句在xml文件配置的
Hibernate优势
• Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。
• Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
• Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
• Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

•大大简化了dao层的编码工作
mybatis与jdbc的区别：
jdbc操作数据的效率更高，mybatis实现了对Dao层的封装，便于管理扩展
hibernate与jdbc的区别:
hibernate操作的是对象去操作数据库,jdbc则是直接操作数据库
JDBC要比hibernate的效率好，因为hibernate是基于JDBC的技术
hibernate是JDBC的轻量级封装对象，hibernate可以用在任何JDBC可以使用的场合
ajax的优缺点。
优点：
最大的优点是页面局部刷新。
使用异步方式与服务器通讯，响应速度更快。
还可以减轻服务器端的负担。
缺点：
最大的缺点就是不能回退。
只能用于小型项目的业务逻辑，不适于大型项目的业务逻辑
安全性不高，因为Ajax是基于脚本的客户端可能会看到源码。
***** Struts2请求处理流程 *****
1、客户端发送请求 (客户端初始化一个指向Servlet容器（如Tomcat）的请求)
2、请求经过一系列过滤器（如ActionContextCleanUp、SiteMesh等）,ActionContextCleanUp–>FilterDispatcher
3、FilterDispatcher通过ActionMapper来决定这个Request需要调用哪个Action 如果不是调用action 则直接执行你的资源
4、如果ActionMapper决定调用某个Action，FilterDispatcher把请求的处理交给ActionProxy，
5、ActionProxy通过Configuration Manager询问Struts配置文件（Struts.xml），找到需要调用的Action类。
6、ActionProxy创建一个ActionInvocation的实例
7、ActionInvocation调用真正的Action，当然这涉及到相关拦截器的调用
8、Action执行完毕，ActionInvocation创建Result并返回，返回结果前要做些动作也是可以的

什么时候用assert。
assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。
反射机制的概念:
指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法,对于任意一个对象,都能调用它的任意一个方法.这种动态获取信息,以及动态调用对象方法的功能叫java语言的反射机制.

Java有23种设计模式
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
Ø 工厂方法模式（Factory Method Pattern）--------记住
Ø 抽象工厂模式（Abstract Factory Pattern）------记住
Ø 建造者模式（Builder Pattern）---------------记住
Ø 原型模式（Prototype Pattern）---------------记住
Ø 单例模式（Singleton Pattern）---------------记住
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
Ø 适配器模式（Adapter Pattern）
Ø 桥接模式（Bridge Pattern）
Ø 组合模式（Composite Pattern）
Ø 装饰者模式（Decorator Pattern）-------记住
Ø 外观模式（Facade Pattern）
Ø 享元模式（Flyweight Pattern）
Ø 代理模式（Proxy Pattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
Ø 责任链模式（Chain of Responsibility Pattern）
Ø 命令模式（Command Pattern）
Ø 解释器模式（Interpreter Pattern）
Ø 迭代器模式（Iterator Pattern）----------记住
Ø 中介者模式（Mediator Pattern）
Ø 备忘录模式（Memento Pattern）
Ø 观察者模式（Observer Pattern）
Ø 状态模式（State Pattern）
Ø 策略模式（Strategy Pattern）
Ø 模板方法模式（Template Method Pattern）-------Spring里用的最经典的一个设计模式
Ø 访问者模式（Visitor Pattern）

如何介绍项目
1.先介绍项目背景（基本上是一带而过，然面试官有个了解）
2.项目功能，也就是说说项目是干什么的
3.用到的技术和自己做的结果（细点儿，这部分是重点，要把握住度，面试官一般主要是从这个地方给了解你的实际能力的）
4.说说还需改进的地方（一般不需要，但说说能体现你发现问题的能力）
例一：
版本自动升级工具系统测试软件环境：Windows 2000 Professional SP4; Visual SourceSafe; IIS5.0
硬件环境：Intel® on®2.93GHz; 512M; 40G
开发环境：Delphi
软件介绍：是供证券公司对自身软件进行升级的工具；已经有三个版本，需要对其功能及性能等分别进行测试
主要职责：作为组长，制定测试计划初稿，编写测试需求框架，进行工作任务的分配与安排，参与部分模块——业务流程的测试（编写完整的测试需求、设计测试用例、执行测试用例并完成缺陷报告），完成测试总结分析报告、工作绩效统计；各阶段组织评审；另外对控件命名的规范以及每个人提交文档的格式进行统一。

例二： 2006/4—2006/5：
项目名称：商场管理系统
项目描述： 该项目是在心力教育学习期间以小组为团队完成的一个实践项目，团队5人，我主要负责项目计划、测试需求分析、测试分析和总结分析，系统测试用例设计、执行。 全程使用测试管理工具TestDirector进行管理。

例三：
PhpWind Blog（Web项目）在项目中担任组长，负责制定测试计划，并和组员一起按照测试计划按时完成测试需求、测试用例设计、测试执行和缺陷报告、总结分析报告等一系列测试过程的工作。在测试的开始阶段就进行了需求的细分，事实也验证了这样做的好处。运用了数据驱动的测试用例设计方法进行功能测试和安全性测试，并制定相关指标进行了手工的性能测试。