20170412----面试总结---一直更新

一.java基础

                   1.java中jre和jdk区别

                          jre:java运行环境，jre是将要执行java程序的java虚拟机

                          jdk:是java开发工具包，包含了jre，可以让开发者开发，编译，调试。

                        

                   2.public  protected  default  private  区别

                                              同类              同包    不同包子类     不同包非子类 
                       private        yes
                       default         yes              yes
                       protected    yes              yes          yes   
                       public          yes              yes          yes                      yes

                   3.static 的用法

                           “static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。

                   4.方法的重写和方法的重载区别

                    Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖    必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。

                   5.List和set区别

                        1、List,Set都是继承自Collection接口
                        2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 
                        3、List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

                   6.List和Map区别及用法

                         

                   7.redirect（重定向）和forward（请求转发）的区别

                          

                            forward:客户端和浏览器间只发出一次请求

                            redirect:实际上是两次HTTP请求

                            举例子：forward----A找B借钱，B说没有，B去找C借钱，借到借不到都会把信息传递给A

                                          redirect----A找B借钱，B说没有，让A去找C借

                            redirect:用户在没有登录的情况下访问后台资源，servlet可以将HTTP请求重定向到登录页面，让用户登录后再访问   更安全些                           

                          

                   8.hashtable和hashmap的区别

                        

                （1）HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点：

                （2）HashMap允许键和值是null，而Hashtable不允许键或者值是null。

                （3）Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。

               （4）HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。

                   9.描述一下ArrayList和LinkedList各自实现和区别

                  10.equals和==的区别

                        “==”比较的是值【变量(栈)内存中存放的对象的(堆)内存地址】 
              equal用于比较两个对象的值是否相同【不是比地址】 

                  11.抽象类和接口的区别             

                     （1）  接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。

                     （2）类可以实现很多个接口，但是只能继承一个抽象类

                     （3）类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象

                     （4）抽象类可以在不提供接口方法实现的情况下实现接口。

                    （5）Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。

                   （6）Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。

                   （7）接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

                  12.session和cookid的区别

                     （1）cookie数据是存放在客户的浏览器上，session数据是存放在服务器上

                     （2）cookie没有session安全

                     （3）session会在一定时间内保存在服务器上，当访问增多，会占用你的服务器性能，性能不如cookie

                     （4）cookie存储的数据不超过4k，很多浏览器都限制一个站点最多保存20个cookie

                      建议：登录等重要信息保存在session中，其他信息可以保存在cookie中

                  13.servlet的生命周期

                           （1）创建servlet实例    在配置文件web.xml中，<servlet-name>HelloWorld</servlet-name>    <servlet-class>com.neusoft.HelloWorld</servlet-class>

                           （2）一旦servlet被实例化后，web服务器会自动调用init方法来初始化该servlet    <init-param> </init-param>     在servlet生命周期中，该方法只被执行一次

                           （3）一旦servlet被实例和初始化后，该servlet实例就可以被服务器用来服务于客户端的请求并生成响应。

                           （4）调用destory()方法

                  14.synchronized  用法

                       synchronized是一种线程同步锁   一次只能有一个线程进入该方法，其他线程要想调用此方法只能排队等候，执行完该方法才能进入

                        举例：学员缴费，同时调用缴费方法，在方法前加上synchronized修饰，确保学员缴费安全

                   15.遍历map的方法

                       Map<String,String> map = new HashMap<String,String>();

                       map.put("1","value1111");

                       map.put("2","value2222");

                     方式一：

                            for(String key:map.keySet()){

                                 sysout("key="+key+"value="+map.get(key));

                        }

                   方式二：

                           Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();

                           while(it.hasNext()){

                                     Map.Entry<String,String> entry = it.next();

                                     sysout("key="+entry.getKet()+"value="+entry.getValue());

                            }

                    //第三种：推荐，尤其是容量大时
                System.out.println("通过Map.entrySet遍历key和value");
                 for (Map.Entry<String, String> entry : map.entrySet()) {
                   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
                  }

             16.用iterator遍历  list

                    

1. public static void main(String[] args) {  
2.   
3.         // 1、创建多个狗狗对象  
4.         Dog ououDog = new Dog("欧欧", "雪娜瑞");  
5.         Dog yayaDog = new Dog("亚亚", "拉布拉多");  

1.   
2.         // 2、创建ArrayList集合对象并把多个狗狗对象放入其中  
3.         List dogs = new ArrayList();  
4.         dogs.add(ououDog);  
5.         dogs.add(yayaDog);
6.   
7.         // 3、通过迭代器依次输出集合中所有狗狗的信息  
8.         System.out.println("使用Iterator遍历，所有狗狗的昵称和品种分别是：");  
9.         Iterator it = dogs.iterator();  //调用集合的iterator方法  
10.         while (it.hasNext()) {      //循环遍历   
11.             Dog dog = (Dog) it.next();  //遍历出来的对象默认是 object 类型，需要转换    
12.             System.out.println(dog.getName()+"\t"+dog.getStrain());  
13.         }  
14.     }  

     17.java中实现线程的两种方式

          （1）直接继承Thread类

          （2）实现Runnable接口

           启动线程用start()方法  

          实现Runnable接口比继承Thread类所具有的优势：
          1）：适合多个相同的程序代码的线程去处理同一个资源
          2）：可以避免Java中的单继承的限制
          3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

   18.throws 和 throw 区别

         throws可以单独使用，但throw不能 。throw要么和try-catch-finally 语句配套使用，要么和throws配套使用

        throw：语句抛出异常

        throws:声明方法（方法抛出一个异常）

19.doGet和 doPost区别

    （1）提交的数据有大小限制，get在1024字节范围内，post没有限制

    （2）post更安全些 ,get会在地址栏显示参数信息。  method属性不指定，会默认未get方式.

    （3）页面刷新时，get方式：不会有任何提示   post方式：会弹出提示框，问用户是否重新提交

20.单例模式

      （1）私有的构造方法

      （2）私有的静态的类型引用

      （3）提供获取实例的方法

public static ShoppingCar getInstance(){
  if(null == shoppingCar){
   shoppingCar = new ShoppingCar();
  }
  return shoppingCar;
 }

21.jdbc操作数据库的编程步骤

   （1）加载驱动程序

            class.forName("com.mysql.jdbc.Driver");

  （2）获取数据库的链接

           Connection  conn=DriverManager.getConnection(url);

  （3）创建会话

          Statment stmt = conn.createStatement()

   （4）执行SQL语句

         int result = stmt.execute(sql);

   （5）对结果进行处理

  （6）关闭链接 

        rs.close();

        stmt.close();

        conn.close();

       

21.i++和++i区别

     i++ ：先用后加i

    ++i  ：先加后用i

22.StringBuffer和StringBuilder区别

          StringBuffer和StringBuilder都是对大量字符的拼接使用，StringBuilder是线程安全的，效率低于StringBuffer

23.工厂模式

     public class Factory{
    public static Sample creator(int which){
        //getClass 产生Sample 一般可使用动态类装载装入类。
        if (which==1)
            return new SampleA();
        else if (which==2)
            return new SampleB();
    }
}

    Sample sampleA=Factory.creator(1);

    Sample sampleB=Factory.creator(2);

二.  oracle

       1.索引的优缺点

           创建索引可以大大提高系统的性能:
              第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
             第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。 
             第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
            第四，在使用分组和排序 子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
            第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

       增加索引也有许多不利的方面:
          第一，创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。 
          第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
          第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

      2.truncate 比delete速度快的原因

          truncate操作不产生日志，delete产生日志

          truncate操作无法rollback

     3.数据库的性能优化

           （1）select 语句中避免使用(*)

           （2）用exits替代in

           （3）用索引提高效率

           （4）sql语句用大写的，解析SQL语句时，把小写的字母转换成大写的再执行

           （5）用union替代or

           （6）尽量多是用commit 原因：需求会因commit所释放的资源而减少     commit释放的资源：a---回滚段上用于恢复数据的信息 b---被程序语句获得的锁

           （7）使用表的别名

           （8）通过一些函数来提高效率   如：decode函数

           （9）用truncate代替delete

          （10）减少表的查询次数

    4.函数和存储过程的区别及联系

       （1）关键字不同

       （2）存储过程不能有返回值，函数必须有返回值

（3）如果只有一个返回值，用函数function，否则用存储过程

（4）都可以携带多个传入参数和传出参数

    5.union和union all区别

      union 是取唯一值，记录没有重复

      union  all是直接连接，取得所有值，记录可以重复

三：前段技术

           1.盒子模型

                   

            2.li标签默认是竖排的，怎么将其横排显示

                 li{float:left;list-style:none;}   left代表左对齐，list-style:none用来取出li标签前面的小圆点

            3.jquery怎么获取复选框的值

                    <body> 
                       <input type="checkbox" name="test" value="0" />0

<input type="checkbox" name="test" value="1" />1
<input type="checkbox" name="test" value="2" />2

</body>

                function chk(){
                     var obj=document.getElementsByName('test'); //选择所有name="'test'"的对象，返回数组
                    //取到对象数组后，我们来循环检测它是不是被选中
                     var s='';
                     for(var i=0; i<obj.length; i++){
                          if(obj[i].checked) s+=obj[i].value+','; //如果选中，将value添加到变量s中 
           }
                     //那么现在来检测s的值就知道选中的复选框的值了
                    alert(s==''?'你还没有选择任何内容！':s);
                     }

                    function jqchk(){ //jquery获取复选框值
                      var chk_value =[]; 
                      $('input[name="test"]:checked').each(function(){
                      chk_value.push($(this).val());
                     });
                    alert(chk_value.length==0 ?'你还没有选择任何内容！':chk_value); 
    }

4.jquery里的each()是什么函数？

            each()函数相当于java里的iterator.它允许遍历一个元素的集合

5.css选择器和jquery选择器

   css选择器：（1）ID选择器（2）类选择器（3）标签选择器h1{ color:red;}

  jquery选择器：（1）ID选择器（2）类选择器（3）属性选择器 $("input[name=accept]").attr("checked", "true");将name为accept的复选框选中

四、框架类经常提出的问题

        1.springmvc 和 struts2区别

          （1）struts2入口是filter过滤器，springmvc入口是servlet 即:前段控制器

          （2）springmvc是基于方法开发，是个单例模式，而struts2是基于类开发   传参是通过类的属性   是个多例模式

        2.spring的注入方式（IOC：依赖注入）

          （1）set注入

                     package com.bless.springdemo.action
                    public class SpringAction {
                          //注入对象springDao
                         private SpringDao springDao;
                         //一定要写被注入对象的set方法
                        public void setSpringDao(SpringDao springDao) {
                              this.springDao = springDao;
                         }

                        public void ok(){
                               springDao.ok();
                          }
                      }

           在xml文件中代码如下：

                   <!--配置bean,配置后该类由spring管理-->
                  <bean name="springAction" class="com.bless.springdemo.action.SpringAction">
                  <!--(1)依赖注入,配置当前类中相应的属性-->
                   <property name="springDao" ref="springDao"></property>
                  </bean>
                   <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

         （2）构造器注入

                带有参数的构造函数注入

              public class SpringAction {
                          //注入对象springDao
                 private SpringDao springDao;
                 private User user;
               public SpringAction(SpringDao springDao,User user){
                         this.springDao = springDao;
                         this.user = user;
                        System.out.println("构造方法调用springDao和user");
                 }
        public void save(){
                  user.setName("卡卡");
                  springDao.save(user);
            }
      }

配置文件xml

<!--配置bean,配置后该类由spring管理-->

      <bean name="springAction" class="com.bless.springdemo.action.SpringAction">

<!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置-->
         <constructor-arg index="0" ref="springDao"></constructor-arg>
        <constructor-arg index="1" ref="user"></constructor-arg>
     </bean> 
        <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>
        <bean name="user" class="com.bless.springdemo.vo.User"></bean>

（3）静态工厂的方法注入

（4）实例工厂的方法注入

3.AOP：面向切面编程的理解

      （1）面向切面编程提供声明式事务管理