zoukankan      html  css  js  c++  java

  • javaEE面试重点

    Hibernate工作原理及为什么要用？


    原理：


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


    为什么要用：


    * 对JDBC訪问数据库的代码做了封装。大大简化了数据訪问层繁琐的反复性代码。


    * Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。

    他非常大程度的简化DAO层的编码工作
    * hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
    * hibernate的性能非常好。由于它是个轻量级框架。映射的灵活性非常出色。它支持各种关系数据库。从一对一到多对多的各种复杂关系。


    Hibernate是怎样延迟载入?


    * Hibernate2延迟载入实现：a)实体对象 b)集合（Collection）
    * Hibernate3 提供了属性的延迟载入功能


    当Hibernate在查询数据的时候。数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟载入。他节省了server的内存开销，从而提高了server的性能。
    Hibernate中如何实现类之间的关系?

    (如：一对多、多对多的关系)
    类与类之间的关系主要体如今表与表之间的关系进行操作。它们都市对对象进行操作，我们程序中把全部的表与类都映射在一起。它们通过配置文件里的many-to-one、one-to-many、many-to-many、


    说下Hibernate的缓存机制


    * 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
    * 二级缓存：


    a)应用及缓存


    b)分布式缓存


    条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据


    c) 第三方缓存的实现
    Hibernate的查询方式
    Sql、Criteria,object comptosition
    Hql：


    * 属性查询
    * 參数查询、命名參数查询
    * 关联查询
    * 分页查询
    * 统计函数


    怎样优化Hibernate？


    * 使用双向一对多关联。不使用单向一对多
    * 灵活使用单向一对多关联
    * 不用一对一。用多对一代替
    * 配置对象缓存，不使用集合缓存
    * 一对多集合使用Bag,多对多集合使用Set
    * 继承类使用显式多态
    * 表字段要少，表关联不要怕多，有二级缓存撑腰


    Struts工作机制？为什么要使用Struts？
    工作机制：
    Struts的工作流程:
    在web应用启动时就会载入初始化ActionServlet,ActionServlet从struts-config.xml文件里读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将运行例如以下流程.
    (1)检索和用户请求匹配的ActionMapping实例,假设不存在,就返回请求路径无效信息;
    (2)假设ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
    (3)依据配置信息决定是否须要表单验证.假设须要验证,就调用ActionForm的validate()方法;
    (4)假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActuibErrors对象, 就表示表单验证成功;
    (5)ActionServlet依据ActionMapping所包括的映射信息决定将请求转发给哪个Action,假设对应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
    (6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;
    (7)ActionForward对象指向JSP组件生成动态网页,返回给客户;


    为什么要用：
    JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。

    但用这些技术构建的系统很的繁乱，所以在此之上。我们须要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。


    基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件
    Struts的validate框架是怎样验证的？
    在struts配置文件里配置详细的错误提示，再在FormBean中的validate()方法详细调用。


    说下Struts的设计模式
    MVC模式: web应用程序启动时就会载入并初始化ActionServler。用户提交表单时。一个配置好的ActionForm对象被创建。并被填入表单对应的数据，ActionServler依据Struts-config.xml 文件配置好的设置决定是否须要表单验证，假设须要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，假设 Action不存在。ActionServlet会先创建这个对象。然后调用Action的execute（）方法。Execute（）从 ActionForm对象中获取数据，完毕业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给 ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。




    单例模式


    Factory(工厂模式)：


    定义一个基类===》实现基类方法（子类通过不同的方法）===》定义一个工厂类（生成子类实例）


    ===》开发者调用基类方法


    Proxy(代理模式)


    spring工作机制及为什么要用?
    1.spring mvc请全部的请求都提交给DispatcherServlet,它会托付应用系统的其它模块负责负责对请求进行真正的处理工作。
    2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
    3.DispatcherServlet请请求提交到目标Controller
    4.Controller进行业务逻辑处理后，会返回一个ModelAndView
    5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
    6.视图对象负责渲染返回给client。


    为什么用：
    AOP 让开发者能够创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就能够分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。


    IOC 同意创建一个能够构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每个对象都是用 其协作对象构造的。

    因此是由容器管理协作对象（collaborator）。




    Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，仅仅要用 JavaBean 属性和配置文件增加依赖性（协作对象）。然后能够非常easy地在须要时替换具有类似接口的协作对象。




    网友自出的几道面试题


    1、 简述你对IoC（Inversion of Control）的理解。描写叙述一下Spring中实现DI（Dependency Injection）的几种方式。




    2、 Spring的Bean有多种作用域，包含：
    singleton、prototype、request、session、global session、application、自己定义


    3、 简单描写叙述Spring Framework与Struts的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？


    4、 Hibernate中的update()和saveOrUpdate()的差别


    5、 Spring对多种ORM框架提供了非常好的支持，简单描写叙述在Spring中使用Hibernate的方法，并结合事务管理。




    Hibernate


    1.在数据库中条件查询速度非常慢的时候,怎样优化?
    1.建索引
    2.降低表之间的关联
    3.优化sql，尽量让sql非常快定位数据，不要让sql做全表查询。应该走索引,把数据量大的表排在前面
    4.简化查询字段，无用的字段不要，已经对返回结果的控制，尽量返回少量数据


    [2.在hibernate中进行多表查询,每一个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之相应,怎样解决问题?
    解决方式一，依照Object[]数据取出数据，然后自己组bean
    解决方式二，对每一个表的bean写构造函数。比方表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，然后在hql里面就能够直接生成这个bean了。

    详细怎么用请看相关文档。我说的不是非常清楚。


    session.load()和session.get()的差别
    Session.load/get方法均能够依据指定的实体类和id从数据库读取记录，并返回与之相应的实体对象。

    其差别在于：


    假设未能发现符合条件的记录，get方法返回null。而load方法会抛出一个ObjectNotFoundException。
    Load方法可返回实体的代理类实例，而get方法永远直接返回实体类。
    load方法能够充分利用内部缓存和二级缓存中的现有数据。而get方法则只在内部缓存中进行数据查找，如没有发现相应数据。将越过二级缓存，直接调用SQL完毕数据读取。
    Session在载入实体对象时，将经过的过程：


    首先，Hibernate中维持了两级缓存。第一级缓存由Session实例维护。当中保持了Session当前全部关联实体的数据，也称为内部缓存。而第二级缓存则存在于SessionFactory层次。由当前全部由本 SessionFactory构造的Session实例共享。出于性能考虑。避免无谓的数据库訪问。Session在调用数据库查询功能之前。会先在缓存中进行查询。首先在第一级缓存中，通过实体类型和id进行查找。假设第一级缓存查找命中。且数据状态合法。则直接返回。


    之后，Session会在当前“NonExists”记录中进行查找。假设“NonExists”记录中存在相同的查询条件，则返回null。 “NonExists”记录了当前Session实例在之前全部查询操作中，未能查询到有效数据的查询条件（相当于一个查询黑名单列表）。如此一来。假设 Session中一个无效的查询条件反复出现，就可以迅速作出推断，从而获得最佳的性能表现。


    对于load方法而言，假设内部缓存中未发现有效数据，则查询第二级缓存，假设第二级缓存命中，则返回。
    如在缓存中未发现有效数据，则发起数据库查询操作（Select SQL）。如经过查询未发现相应记录。则将此次查询的信息在“NonExists”中加以记录，并返回null。
    依据映射配置和Select SQL得到的ResultSet。创建相应的数据对象。


    将其数据对象纳入当前Session实体管理容器（一级缓存）。


    运行Interceptor.onLoad方法（假设有相应的Interceptor）。
    将数据对象纳入二级缓存。
    假设数据对象实现了LifeCycle接口。则调用数据对象的onLoad方法。
    返回数据对象。
    Hibernate的主键生成机制
    1) assigned
    主键由外部程序负责生成。无需Hibernate參与。
    2) hilo
    通过hi/lo 算法实现的主键生成机制，须要额外的数据库表保存主键生成历史状态。


    3) seqhilo
    与hilo 类似。通过hi/lo 算法实现的主键生成机制，仅仅是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。
    4) increment
    主键按数值顺序递增。

    此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次须要生成主键的时候将此值加1作为主键。

    这样的方式可能产生的问题是：假设当前有多个实例訪问同一个数据库，那么因为各个实例各自维护主键状态，不同实例可能生成相同的主键。从而造成主键反复异常。

    因此，假设同一数据库有多个实例訪问，此方式必须避免使用。


    5) identity
    採用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。
    6) sequence
    採用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。


    7) native
    由Hibernate依据底层数据库自行推断採用identity、hilo、sequence当中一种作为主键生成方式。
    8) uuid.hex
    由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）作为主键。
    9) uuid.string
    与uuid.hex 类似，仅仅是生成的主键未进行编码（长度16）。在某些数据库中可能出现故障（如PostgreSQL）。
    10) foreign
    使用外部表的字段作为主键。

    一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。
    这10中生成OID标识符的方法,increment 比較经常使用,把标识符生成的权力交给Hibernate处理.可是当同一时候多个Hibernate应用操作同一个数据库,甚至同一张表的时候.就推荐使用identity 依赖底层数据库实现,可是数据库必须支持自己主动增长,当然针对不同的数据库选择不同的方法.假设你不能确定你使用的数据库详细支持什么的情况下.能够选择用native 让Hibernate来帮选择identity,sequence,或hilo.
    另外因为经常使用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们能够在数据库提供的主键生成机制上，採用generator-class=native的主键生成方式。
    只是值得注意的是。一些数据库提供的主键生成机制在效率上未必最佳。大量并发insert数据时可能会引起表之间的互锁。数据库提供的主键生成机制。往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言。此内部表中就维护着当前的最大值和递增量）。之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键。之后再把这个新的最大值更新回内部表中，这样。一次Insert操作可能导致数据库内部多次表读写操作，同一时候伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。因此，对于并发Insert要求较高的系统，推荐採用uuid.hex 作为主键生成机制


    myeclipse 增加Hibernate的全过程


    1.Db-browers增加配置连接
    2.新建project
    3.增加hibernate环境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置


    hibernate的核心类是什么，它们的相互关系是什么?

    重要的方法是什么?


    Configuration
    SessionFactory
    Session例如以下方法
    Save
    load
    Update
    Delete
    Query q=CreateQuery(“from Customer where customerName=:customerName”)
    beginTransaction
    close
    Transaction
    Commit()


    Hibernate中数据表映射关系主要有什么类型


    one-to-many
    inverse:主控方。外键的关系有谁控制
    inverse=false 是主控方，外键是由它控制的
    inverse=true 是被控方。外键与它没关系
    要想实现主控方的控制必须将被控方作为主控方的属性
    cascade:级联
    主表增从表增
    主表修从表修
    主表删从表删
    lazy:延迟
    lazy=false：一下将全部的内容取出，不延时(经常使用)
    lazy=true：取出部分内容。其余内容动态去取
    通过get能够取出对方的全部内容


    Hibernate中Criteria和DetachedCriteria的作用是什么


    Criteria c=session.createCriteria(Customer.class);
    //设置条件
    c.add(Expression.ge(“字段名”,”值对象”))
    ge:>=
    gt:>
    le:<=
    lt:<
    eq:=
    //排序
    c.addOrder(Order.asc(“字段名”))
    //分页
    c.setFirstResult(1)//从第2行開始提取
    c.setMaxResults(5)//返回5行


    DetachedCriteria产生时不须要session
    DetachedCriteria dc= DetachedCriteria.forClass(Customer.class)
    Criteria c=Dc.getExecutableCriteria(session)


    Hibernate中Query对象的使用


    1 个或多个属性查询:
    Query query=session.createQuery(”select customername,customerid from Customer”)
    List l=query.list();
    For(int i=0;i {
    Obejct[] object=(Object[])l.get(i);
    Object[0] object[1]
    }
    }
    分组: “select count(*),productname from Product group by productname order by productname”
    取值与属性一样
    配置的查询,在*.hbm.xml中


    from Product where productid=:productid
    ]]>


    Query query=session.getNamedQuery(sql);
    联接1
    ”from Customer as customer join fetch customer.buySet”：将多的放到buySet属性中，得出的结是Customer有一个，Buy有多个
    联接2
    “from Customer as customer join customer.buySet”:得出的对象,customer与buy是1对1
    子查询:
    ”from Customer as customer where (select count(*) from customer.buySet)>1″


    Hibernate怎样实现数据表映射的继承关系


    1、两个表。子类反复父类的属性。


    2、一个表，子类父类共用一个表










    3、两个表。子类引用父类的主键，享用公共的字段或属性。














    批量删除
    Query query=session.createQuery(“update”或”delete”);
    query.executeUpdate();
    jdbc、Hibernate、ibatis的差别


    jdbc:手动
    手动写sql
    delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。


    select:返回的是一个resultset。要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。
    ibatis的特点:半自己主动化
    sql要手动写
    delete、insert、update:直接传入一个对象
    select:直接返回一个对象
    hibernate:全自己主动
    不写sql,自己主动封装
    delete、insert、update:直接传入一个对象
    select:直接返回一个对象


    Detached Object（游离对象）能够传递到不论什么层直到表现层而不是用不论什么DTO(Data Transfer Objects). 然后你还能够又一次把游离对象赋给另外一个Session.


    Hibernate的三种状态


    瞬时态(Transient)、 持久态(Persistent)、脱管态(Detached)。处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（Value Object）。




    瞬时态


    由new命令开辟内存空间的java对象，


    eg. Person person = new Person(“amigo”, “女”);


    假设没有变量对该对象进行引用，它将被java虚拟机回收。


    瞬时对象在内存孤立存在。它是携带信息的载体，不和数据库的数据有不论什么关联关系，在Hibernate中，可通过session的save()或 saveOrUpdate()方法将瞬时对象与数据库相关联。并将数据相应的插入数据库中，此时该瞬时对象转变成持久化对象。


    持久态


    处于该状态的对象在数据库中具有相应的记录，并拥有一个持久化标识。假设是用hibernate的delete()方法，相应的持久对象就变成瞬时对象。因数据库中的相应数据已被删除。该对象不再与数据库的记录关联。


    当一个session运行close()或clear()、evict()之后。持久对象变成脱管对象，此时持久对象会变成脱管对象。此时该对象尽管具有数据库识别值，但它已不在HIbernate持久层的管理之下。


    持久对象具有例如以下特点：


    1. 和session实例关联；


    2. 在数据库中有与之关联的记录。




    脱管态


    当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。

    当脱管对象被又一次关联到session上时。并再次转变成持久对象。




    脱管对象拥有数据库的识别值。可通过update()、saveOrUpdate()等方法，转变成持久对象。




    脱管对象具有例如以下特点：


    1. 本质上与瞬时对象同样。在没有不论什么变量引用它时，JVM会在适当的时候将它回收；


    2. 比瞬时对象多了一个数据库记录标识值。




    1. Hibernate有哪几种查询数据的方式


    3种：hql、QBC——Query By Criteria API、原生sql （通过createSQLQuery建立）


    2. 谈谈Hibernate中inverse的作用


    inverse属性默认是false,就是说关系的两端都来维护关系。
    比方Student和Teacher是多对多关系。用一个中间表TeacherStudent维护。

    Gp)i
    假设Student这边inverse=”true”, 那么关系由还有一端Teacher维护，就是说当插入Student时，不会操作TeacherStudent表（中间表）。仅仅有Teacher插入或删除时才会触发对中间表的操作。所以两边都inverse=”true”是不正确的。会导致不论什么操作都不触发对中间表的影响。当两边都inverse=”false” 或默认时，会导致在中间表中插入两次关系。


    3. 说说Hibernate中的update()和saveOrUpdate()的差别。session的load()和get()的差别。


    saveOrUpdate()方法能够实现update()的功能，但会多些步骤。详细例如以下：
    假设对象在该session中已经被持久化，不进行操作。对象的标识符属性(identifier property)在数据库中不存在或者是个临时的值。调用save()方法保存它。假设session中的还有一个对象有同样的标识符抛出一个异常；以上皆不符合则调用update()更新之。


    Session.load/get方法均能够依据指定的实体类和id从数据库读取记录，并返回与之相应的实体对象。

    其差别在于：
    假设未能发现符合条件的记录，get方法返回null。而load方法会抛出一个ObjectNotFoundException；load方法可返回实体的代理类实例，而get方法永远直接返回实体类。load方法能够充分利用内部缓存和二级缓存中的现有数据。而get方法则只在内部缓存中进行数据查找，如没有发现相应数据，将越过二级缓存，直接调用SQL完毕数据读取。


    Hibernate工作原理及为什么要用？
    原理：
    1.读取并解析配置文件
    2.读取并解析映射信息。创建SessionFactory
    3.打开Sesssion
    4.创建事务Transation
    5.持久化操作
    6.提交事务
    7.关闭Session
    8.关闭SesstionFactory


    为什么要用：
    1. 对JDBC訪问数据库的代码做了封装，大大简化了数据訪问层繁琐的反复性代码。




    2. Hibernate是一个基于JDBC的主流持久化框架。是一个优秀的ORM实现。他非常大程度的简化DAO层的编码工作


    3. hibernate使用Java反射机制。而不是字节码增强程序来实现透明性。


    4. hibernate的性能非常好，由于它是个轻量级框架。

    映射的灵活性非常出色。它支持各种关系数据库。从一对一到多对多的各种复杂关系。


    2． Hibernate是怎样延迟载入?


    1. Hibernate2延迟载入实现：a)实体对象 b)集合（Collection）


    2. Hibernate3 提供了属性的延迟载入功能


    当Hibernate在查询数据的时候。数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟载入，他节省了server的内存开销。从而提高了server的性能。




    3．Hibernate中如何实现类之间的关系?(如：一对多、多对多的关系)


    类与类之间的关系主要体如今表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把全部的表与类都映射在一起，它们通过配置文件里的many-to-one、one-to-many、many-to-many、


    4． 说下Hibernate的缓存机制


    1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存


    2. 二级缓存：
    a) 应用及缓存
    b) 分布式缓存
    条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据
    c) 第三方缓存的实现


    5． Hibernate的查询方式
    Sql、Criteria,object comptosition
    Hql：
    1、 属性查询
    2、 參数查询、命名參数查询
    3、 关联查询
    4、 分页查询
    5、 统计函数


    6． 怎样优化Hibernate？
    1.使用双向一对多关联，不使用单向一对多
    2.灵活使用单向一对多关联
    3.不用一对一。用多对一代替
    4.配置对象缓存，不使用集合缓存
    5.一对多集合使用Bag,多对多集合使用Set
    6. 继承类使用显式多态
    7. 表字段要少，表关联不要怕多。有二级缓存撑腰
    7． Struts工作机制？为什么要使用Struts？
    工作机制：
    Struts的工作流程:
    在web应用启动时就会载入初始化ActionServlet,ActionServlet从
    struts-config.xml文件里读取配置信息,把它们存放到各种配置对象
    当ActionServlet接收到一个客户请求时,将运行例如以下流程.
    -(1)检索和用户请求匹配的ActionMapping实例,假设不存在,就返回请求路径无效信息;
    -(2)假设ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
    -(3)依据配置信息决定是否须要表单验证.假设须要验证,就调用ActionForm的validate()方法;
    -(4)假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActuibErrors对象, 就表示表单验证成功;
    -(5)ActionServlet依据ActionMapping所包括的映射信息决定将请求转发给哪个Action,假设对应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
    -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;
    -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;


    为什么要用：
    JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统很的繁乱。所以在此之上。我们须要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。


    基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件


    8． Struts的validate框架是怎样验证的？
    在struts配置文件里配置详细的错误提示，再在FormBean中的validate()方法详细调用。




    9． 说下Struts的设计模式
    MVC模式: web应用程序启动时就会载入并初始化ActionServler。用户提交表单时。一个配置好的ActionForm对象被创建。并被填入表单对应的数 据，ActionServler依据Struts-config.xml文件配置好的设置决定是否须要表单验证。假设须要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action，假设Action不存在，ActionServlet会先创建这个对象，然后调用 Action的execute（）方法。

    Execute（）从ActionForm对象中获取数据。完毕业务逻辑。返回一个ActionForward对 象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动 态的网页。返回给客户。


    10． spring工作机制及为什么要用?


    1.spring mvc请全部的请求都提交给DispatcherServlet,它会托付应用系统的其它模块负责负责对请求进行真正的处理工作。


    2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
    3.DispatcherServlet请请求提交到目标Controller
    4.Controller进行业务逻辑处理后，会返回一个ModelAndView
    5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
    6.视图对象负责渲染返回给client。


    为什么用：
    {AOP 让开发者能够创建非行为性的关注点，称为横切关注点。并将它们插入到应用程序代码中。

    使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就能够分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。


    IOC 同意创建一个能够构造对象的应用环境。然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每个对象都是用其协作对象构造的。

    因此是由容器管理协作对象（collaborator）。


    Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。

    有了 Spring，仅仅要用 JavaBean 属性和配置文件增加依赖性（协作对象）。

    然后能够非常easy地在须要时替换具有类似接口的协作对象。}


    同类其它面试题 点击新一篇或旧一篇可浏览所有同类面试题


    Hibernate里面sorted collection和ordered collection有什么差别


    sorted collection是在内存中通过java比較器进行排序的
    ordered collection是在数据库中通过order by进行排序的


    Hibernate都支持哪些缓存策略


    Read-only: 这样的策略适用于那些频繁读取却不会更新的数据。这是眼下为止最简单和最有效的缓存策略
    * Read/write:这样的策略适用于须要被更新的数据，比read-only更耗费资源，在非JTA环境下，每一个事务须要在session.close和session.disconnect()被调用
    * Nonstrict read/write: 这样的策略不保障两个同一时候进行的事务会改动同一块数据，这样的策略适用于那些常常读取可是极少更新的数据
    * Transactional: 这样的策略是全然事务化得缓存策略。能够用在JTA环境下


    怎样查看Hibernate生成并运行的sql


    在定义数据库和数据库属性的文件applicationConfig.xml里面，把hibernate.show_sql 设置为true
    这样生成的SQL就会在控制台出现了
    注意：这样做会加重系统的负担，不利于性能调优


    比較Hibernate的三种检索策略优缺点


    1马上检索；
    长处：相应用程序全然透明，无论对象处于持久化状态，还是游离状态。应用程序都能够方便的从一个对象导航到与它关联的对象；
    缺点：1.select语句太多；2.可能会载入应用程序不须要訪问的对象白白浪费很多内存空间；
    2延迟检索：
    长处：由应用程序决定须要载入哪些对象，能够避免可运行多余的select语句。以及避免载入应用程序不须要訪问的对象。

    因此能提高检索性能，而且能节省内存空间；
    缺点：应用程序假设希望訪问游离状态代理类实例，必须保证他在持久化状态时已经被初始化。
    3 迫切左外连接检索
    长处：1相应用程序全然透明，无论对象处于持久化状态。还是游离状态，应用程序都能够方便地冲一个对象导航到与它关联的对象。2使用了外连接，select语句数目少；
    缺点：1 可能会载入应用程序不须要訪问的对象。白白浪费很多内存空间；2复杂的数据库表连接也会影响检索性能；


    ssh面试精华


    Hibernate工作原理及为什么要用？
    原理：
    1.读取并解析配置文件
    2.读取并解析映射信息，创建SessionFactory
    3.打开Sesssion
    4.创建事务Transation
    5.持久化操作
    6.提交事务
    7.关闭Session
    8.关闭SesstionFactory


    为什么要用：
    1. 对JDBC訪问数据库的代码做了封装。大大简化了数据訪问层繁琐的反复性代码。
    2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。

    他非常大程度的简化DAO层的编码工作
    3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。


    4. hibernate的性能非常好，由于它是个轻量级框架。

    映射的灵活性非常出色。

    它支持各种关系数据库。从一对一到多对多的各种复杂关系。


    2． Hibernate是怎样延迟载入?
    1. Hibernate2延迟载入实现：a)实体对象 b)集合（Collection）
    2. Hibernate3 提供了属性的延迟载入功能。当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟载入，他节省了server的内存开销，从而提高了server的性能。
    3．Hibernate中如何实现类之间的关系?

    (如：一对多、多对多的关系)
    类与类之间的关系主要体如今表与表之间的关系进行操作，它们都市对对象进行操作。我们程序中把全部的表与类都映射在一起。它们通过配置文件里的many-to-one、one-to-many、many-to-many、


    4． 说下Hibernate的缓存机制
    1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
    2. 二级缓存：
    a) 应用及缓存
    b) 分布式缓存
    条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据
    c) 第三方缓存的实现


    5． Hibernate的查询方式
    Sql、Criteria,object comptosition
    Hql：
    1、 属性查询
    2、 參数查询、命名參数查询
    3、 关联查询
    4、 分页查询
    5、 统计函数


    6． 怎样优化Hibernate？
    1.使用双向一对多关联，不使用单向一对多
    2.灵活使用单向一对多关联
    3.不用一对一，用多对一代替
    4.配置对象缓存，不使用集合缓存
    5.一对多集合使用Bag,多对多集合使用Set
    6. 继承类使用显式多态
    7. 表字段要少，表关联不要怕多，有二级缓存撑腰


    7． Struts工作机制？为什么要使用Struts？
    工作机制：
    Struts的工作流程:
    在web应用启动时就会载入初始化ActionServlet,ActionServlet从
    struts-config.xml文件里读取配置信息,把它们存放到各种配置对象
    当ActionServlet接收到一个客户请求时,将运行例如以下流程.
    -(1)检索和用户请求匹配的ActionMapping实例,假设不存在,就返回请求路径无效信息;
    -(2)假设ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
    -(3)依据配置信息决定是否须要表单验证.假设须要验证,就调用ActionForm的validate()方法;
    -(4)假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActuibErrors对象, 就表示表单验证成功;
    -(5)ActionServlet依据ActionMapping所包括的映射信息决定将请求转发给哪个Action,假设对应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
    -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;
    -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;


    为什么要用：
    JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。

    但用这些技术构建的系统很的繁乱，所以在此之上。我们须要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
    基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件


    8． Struts的validate框架是怎样验证的？
    在struts配置文件里配置详细的错误提示，再在FormBean中的validate()方法详细调用。


    9． 说下Struts的设计模式
    MVC 模式: web应用程序启动时就会载入并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建。并被填入表单对应的数据，ActionServler依据Struts-config.xml文件配置好的设置决定是否须要表单验证，假设须要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action。假设Action不存在。ActionServlet会先创建这个对象，然后调用 Action的execute（）方法。

    Execute（）从ActionForm对象中获取数据。完毕业务逻辑。返回一个ActionForward对象。ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页。返回给客户。


    10． spring工作机制及为什么要用?
    1.spring mvc请全部的请求都提交给DispatcherServlet,它会托付应用系统的其它模块负责负责对请求进行真正的处理工作。
    2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
    3.DispatcherServlet请请求提交到目标Controller
    4.Controller进行业务逻辑处理后，会返回一个ModelAndView
    5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
    6.视图对象负责渲染返回给client。


    为什么用：
    {AOP 让开发者能够创建非行为性的关注点，称为横切关注点。并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就能够分解成方面并应用到域对象上，同一时候不会添加域对象的对象模型的复杂性。
    IOC 同意创建一个能够构造对象的应用环境。然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction）。每个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。


    Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，仅仅要用 JavaBean 属性和配置文件增加依赖性（协作对象）。然后能够非常easy地在须要时替换具有类似接口的协作对象。}


    面试中常出现的Hibernate试题


    1.在数据库中条件查询速度非常慢的时候,怎样优化?




    1.建索引


    2.降低表之间的关联


    3.优化sql，尽量让sql非常快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面


    4.简化查询字段，无用的字段不要。已经对返回结果的控制，尽量返回少量数据


    2.在hibernate中进行多表查询,每一个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之相应,怎样解决问题?


    解决方式一，依照Object[]数据取出数据，然后自己组bean


    解决方式二，对每一个表的bean写构造函数，比方表一要查出field1,field2两个字段。那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，然后在hql里面就能够直接生成这个bean了。详细怎么用请看相关文档，我说的不是非常清楚。


    3.session.load()和session.get()的差别


    Session.load/get方法均能够依据指定的实体类和id从数据库读取记录，并返回与之相应的实体对象。其差别在于：


    假设未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。


    Load方法可返回实体的代理类实例，而get方法永远直接返回实体类。




    load方法能够充分利用内部缓存和二级缓存中的现有数据，而get方法则只在内部缓存中进行数据查找，如没有发现相应数据，将越过二级缓存。直接调用SQL完毕数据读取。


    Session在载入实体对象时，将经过的过程：


    首先，Hibernate中维持了两级缓存。第一级缓存由Session实例维护，当中保持了Session当前全部关联实体的数据。也称为内部缓存。

    而第二级缓存则存在于


    SessionFactory层次，由当前全部由本SessionFactory构造的Session实例共享。出于性能考虑，避免无谓的数据库訪问，Session在调用数据库查询功能之前，会


    先在缓存中进行查询。首先在第一级缓存中。通过实体类型和id进行查找，假设第一级缓存查找命中，且数据状态合法。则直接返回。




    之后，Session会在当前“NonExists”记录中进行查找，假设“NonExists”记录中存在相同的查询条件。则返回null。 “NonExists”记录了当前Session实例在之前全部查询操作中。未能查询到有效数据的查询条件（相当于一个查询黑名单列表）。如此一来，假设 Session中一个无效的查询条件反复出现，就可以迅速作出推断，从而获得最佳的性能表现。


    对于load方法而言，假设内部缓存中未发现有效数据，则查询第二级缓存，假设第二级缓存命中，则返回。




    如在缓存中未发现有效数据，则发起数据库查询操作（Select SQL），如经过查询未发现相应记录，则将此次查询的信息在“NonExists”中加以记录，并返回null。


    依据映射配置和Select SQL得到的ResultSet，创建相应的数据对象。


    将其数据对象纳入当前Session实体管理容器（一级缓存）。


    运行Interceptor.onLoad方法（假设有相应的Interceptor）。


    将数据对象纳入二级缓存。


    假设数据对象实现了LifeCycle接口。则调用数据对象的onLoad方法。




    返回数据对象。


    Hibernate的主键生成机制


    1) assigned


    主键由外部程序负责生成，无需Hibernate參与。


    2) hilo


    通过hi/lo 算法实现的主键生成机制。须要额外的数据库表保存主键生成历史状态。


    3) seqhilo


    与hilo 类似，通过hi/lo 算法实现的主键生成机制，仅仅是主键历史状态保存在Sequence中。适用于支持Sequence的数据库，如Oracle。


    4) increment


    主键按数值顺序递增。

    此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次须要生成主键的时候将此值加1作为主键。这样的方式可能产生的问题是：假设当前有多个实例訪问同一个数据库，那么因为各个实例各自维护主键状态。不同实例可能生成相同的主键。从而造成主键反复异常。因此。假设同一数据库有多个实例訪问。此方式必须避免使用。




    5) identity


    採用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。




    6) sequence


    採用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。




    7) native


    由Hibernate依据底层数据库自行推断採用identity、hilo、sequence当中一种作为主键生成方式。


    8) uuid.hex


    由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）作为主键。


    9) uuid.string


    与uuid.hex 类似，仅仅是生成的主键未进行编码（长度16）。

    在某些数据库中可能出现故障（如PostgreSQL）。


    10) foreign


    使用外部表的字段作为主键。一般而言。利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。


    这10中生成OID标识符的方法,increment 比較经常使用,把标识符生成的权力交给Hibernate处理.可是当同一时候多个Hibernate应用操作同一个数据库,甚至同一张表的时候.就推荐使用identity 依赖底层数据库实现,可是数据库必须支持自己主动增长,当然针对不同的数据库选择不同的方法.假设你不能确定你使用的数据库详细支持什么的情况下.能够选择用native 让Hibernate来帮选择identity,sequence,或hilo.


    另外因为经常使用的数据库。如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。

    我们能够在数据库提供的主键生成机制上，採用generator-class=native的主键生成方式。




    只是值得注意的是。一些数据库提供的主键生成机制在效率上未必最佳。大量并发insert数据时可能会引起表之间的互锁。

    数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言。此内部表中就维护着当前的最大值和递增量），之后每次插入数据会读取这个最大值。然后加上递增量作为新记录的主键。之后再把这个新的最大值更新回内部表中，这样。一次Insert操作可能导致数据库内部多次表读写操作，同一时候伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。因此，对于并发Insert要求较高的系统。推荐採用uuid.hex 作为主键生成机制。


    三框架整合连接数据库的方法


    第一种在Spring applicationContext.xml中连接：




    oracle.jdbc.driver.OracleDriver


    jdbc:oracle:thin:@localhost:1521:test


    cpiclh


    cpiclh






    com/Hibernate/Pojo/FactUsers.hbm.xml


    org.hibernate.dialect.Oracle9Dialect true
    另外一种在Hibernate hibernate.cfg.xml中连接：




    root
    jdbc:oracle:thin:@192.168.0.1:1521:test


    org.hibernate.dialect.Oracle9Dialect root
    oracle.jdbc.driver.OracleDriver


    第三种在Tomcat中的 apache-tomcat-5.5.17confCatalina文件夹下放一个


    和文件夹同名的XML。内容例如以下






    username="root" password="root" driverClassName="oracle.jdbc.driver.OracleDriver"


    url="jdbc:oracle:thin:@192.168.0.1:1521:test"/>


    什么是Hibernate并发机制 怎么处理并发问题


    Hibernate并发机制：
    a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工作单元(即单个事务,单个线程),它通常仅仅使用一次,
    然后就丢弃。


    假设一个Session 实例同意共享的话，那些支持并发执行的,比如Http request,session beans将会导致出现资源争用。
    假设在Http Session中有hibernate的Session的话,就可能会出现同步訪问Http Session。

    仅仅要用户足够快的点击浏览器的“刷新”,
    就会导致两个并发执行的线程使用同一个Session。


    b、多个事务并发訪问同一块资源,可能会引发第一类丢失更新，脏读。幻读，不可反复读，第二类丢失更新一系列的问题。


    解决方式：设置事务隔离级别。


    Serializable：串行化。

    隔离级别最高
    Repeatable Read：可反复读
    Read Committed：已提交数据读
    Read Uncommitted：未提交数据读。

    隔离级别最差
    设置锁：乐观锁和悲观锁。


    乐观锁：使用版本号号或时间戳来检測更新丢失,在的映射中设置 optimistic-lock=”all”能够在没有版本号或者时间戳属性映射的情况下实现 版本号检查，此时Hibernate将比較一行记录的每一个字段的状态 行级悲观锁：Hibernate总是使用数据库的锁定机制，从不在内存中锁定对象！仅仅要为JDBC连接指定一下隔 离级别，然后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不同的锁定级别：LockMode.UPGRADE,LockMode.UPGRADE_NOWAIT,LockMode.READ;


    Hibernate工作原理及为什么要用


    原理：
    1. 读取并解析配置文件
    2. 读取并解析映射信息，创建SessionFactory
    3. 打开Sesssion
    4. 创建事务Transation
    5. 持久化操作
    6. 提交事务
    7. 关闭Session
    8. 关闭SesstionFactory
    为什么要用：
    1. 对JDBC訪问数据库的代码做了封装，大大简化了数据訪问层繁琐的反复性代码。
    2. Hibernate是一个基于JDBC的主流持久化框架。是一个优秀的ORM实现。

    他能非常大程度的简化DAO 层的编码工作
    3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
    4. hibernate的性能非常好，由于它是个轻量级框架。

    映射的灵活性非常出色。它支持各种关系数据库。从 一对一到多对多的各种复杂关系。


    Hibernate缓存机制


    1. 内部缓存存在Hibernate中又叫一级缓存。属于应用事物级缓存
    2. 二级缓存：
    a) 应用及缓存
    b) 分布式缓存
    条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据
    c) 第三方缓存的实现


    Hibernate的查询方式


    Sql、Criteria,object comptosition
    Hql：
    1、 属性查询
    2、 參数查询、命名參数查询
    3、 关联查询
    4、 分页查询
    5、 统计函数


    怎样优化Hibernate


    1. 使用双向一对多关联。不使用单向一对多
    2. 灵活使用单向一对多关联
    3. 不用一对一，用多对一代替
    4. 配置对象缓存，不使用集合缓存
    5. 一对多集合使用Bag,多对多集合使用Set
    6. 继承类使用显式多态
    7. 表字段要少，表关联不要怕多，有二级缓存撑腰


    Hibernate拒接连接、server崩溃的原因


    1. db没有打开
    2. 网络连接可能出了问题
    3. 连接配置错了
    4. 驱动的driver，url是否都写对了
    5. LIB下增加对应驱动，数据连接代码是否有误
    6. 数据库配置可能有问题
    7. 当前联接太多了。server都有訪问人数限制的
    8. server的对应port没有开，即它不提供对应的服务
    9 hibernate有哪些缓存。分别怎么使用?
    10 你对hibernate的了解到了一个什么样的程度？
    11 写出一个sql语句体现hibernate中一对多的关系


    常见的Hibernate面试题


    1.Hibernate有哪几种查询数据的方式
    (1)导航对象图查询
    (2)OID查询
    (3)HQL
    (4)QBC
    (5)本地SQL
    2.load()和get()的差别
    load载入方法：
    Java代码
    Users user = (Users)session.load(Users.class, userId);
    get载入方法：
    Java代码
    Users user = (Users)session.get(Users.class, userId);
    两载入方法差别：
    差别1：假设数据库中，没有userId的对象。假设通过get方法载入。则返回的是一个null；假设通过load载入，则返回一个代理对象，假设后面代码假设调用user对象的某个属性（比方user.getPassword()）会抛出异常：org.hibernate.ObjectNotFoundException。


    差别2：load支持延迟载入。get不支持延迟载入。


    也就是说：
    Java代码
    Users user = (Users)session.load(Users.class, userId);
    这句代码不会去运行数据库查询。仅仅实用到user时才会去运行数据库查询。
    而Java代码
    Users user = (Users)session.get(Users.class, userId);
    则马上去运行数据库查询。 所以Users user = (Users)session.load(Users.class, userId);不会运行不论什么sql。




    注意Java代码


    Users user = (Users)session.load(Users.class, userId);
    System.out.println(user.getId());
    Users user = (Users)session.load(Users.class, userId);
    System.out.println(user.getId());


    上面这2句代码，不会去运行数据库操作。由于load后会在hibernate的一级缓存里存放一个map对象。该map的key就是userId的值，可是当你getId()时，它会去一级缓存里拿map的key值，而不去运行数据库查询。所以不会报不论什么错。不会运行不论什么数据库操作。




    3. Hibernate工作原理及为什么要用？
    原理：
    1. 读取并解析配置文件
    2. 读取并解析映射信息。创建SessionFactory
    3. 打开Sesssion
    4. 创建事务Transation
    5. 持久化操作
    6. 提交事务
    7. 关闭Session
    8. 关闭SesstionFactory


    为什么要用：
    1. 对JDBC訪问数据库的代码做了封装，大大简化了数据訪问层繁琐的反复性代码。
    2. Hibernate是一个基于JDBC的主流持久化框架。是一个优秀的ORM实现。他非常大程度的简化DAO层的编码工作
    3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
    4. hibernate的性能非常好。由于它是个轻量级框架。映射的灵活性非常出色。它支持各种关系数据库。从一对一到多对多的各种复杂关系。
    4． Hibernate是怎样延迟载入?


    1. Hibernate2延迟载入实现：a)实体对象 b)集合（Collection）
    2. Hibernate3 提供了属性的延迟载入功能
    当Hibernate在查询数据的时候，数据并没有存在与内存中。当程序真正对数据的操作时。对象才存在与内存中，就实现了延迟载入。他节省了server的内存开销，从而提高了server的性能。


    5． Hibernate中如何实现类之间的关系?

    (如：一对多、多对多的关系)
    类与类之间的关系主要体如今表与表之间的关系进行操作。它们都市对对象进行操作，我们程序中把全部的表与类都映射在一起，它们通过配置文件里的many-to-one、one-to-many、many-to-many、


    5． 说下Hibernate的缓存机制
    1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
    2. 二级缓存：
    a) 应用及缓存
    b) 分布式缓存
    条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非重要数据
    c) 第三方缓存的实现


    6． Hibernate的查询方式


    Sql、Criteria,object comptosition


    Hql：


    1、 属性查询


    2、 參数查询、命名參数查询


    3、 关联查询


    4、 分页查询


    5、 统计函数


    7． 怎样优化Hibernate？


    1. 使用双向一对多关联，不使用单向一对多


    2. 灵活使用单向一对多关联


    3. 不用一对一，用多对一代替


    4. 配置对象缓存，不使用集合缓存


    5. 一对多集合使用Bag,多对多集合使用Set


    6. 继承类使用显式多态


    7. 表字段要少，表关联不要怕多。有二级缓存撑腰


    =====================Hibernate笔试题==========================


    (1)普通情况下。关系数据模型与对象模型之间有哪些匹配关系（多选）
    A)表相应类
    B)记录相应对象
    C)表的字段相应类的属性
    D)表之间的參考关系相应类之间的依赖关系


    (2)下面关于SessionFactory的说法哪些正确？（多选）
    A)对于每一个数据库事务，应该创建一个SessionFactory对象
    B)一个SessionFactory对象相应一个数据库存储源。


    C)SessionFactory是重量级的对象。不应该任意创建。假设系统中仅仅有一个数据库存储源。仅仅须要创建一个。


    D)SessionFactory的load()方法用于载入持久化对象


    (3)Customer类中有一个Set类型的orders属性。用来存放Order订单对象，在Customer.hbm.xml文件里。用哪个元素映射orders属性？
    A) B) C) D)


    (4)元素有一个cascade属性。假设希望Hibernate级联保存集合中的对象，casecade属性应该取什么值？（单选）
    A)none
    B)save
    C)delete
    D)save-update


    (5)下面哪些属于Session的方法？
    A)load()
    B)save()
    C)delete()
    D)update()
    E)open()
    F)close()


    (6)下面程序的打印结果是什么？（单选）


    tx = session.beginTransaction();
    Customer c1=(Customer)session.load(Customer.class,new Long(1));
    Customer c2=(Customer)session.load(Customer.class,new Long(1));
    System.out.println(c1==c2);
    tx.commit();
    session.close();


    A)执行出错。抛出异常
    B)打印false
    C)打印true


    (7)下面程序代码对Customer的name属性改动了两次：
    tx = session.beginTransaction();
    Customer customer=(Customer)session.load(Customer.class,
    new Long(1));
    customer.setName(”Jack”);
    customer.setName(”Mike”);
    tx.commit();


    运行以上程序，Hibernate须要向数据库提交几条update语句？（单选）
    A)0 B)1 C)2 D)3


    (8)在持久化层，对象分为哪些状态？（多选）
    A)暂时状态
    B)独立状态
    C)游离状态
    D)持久化状态


    (9)对于下面程序，Customer对象在第几行变为持久化状态？（单选）
    Customer customer=new Customer(); //line1
    customer.setName(”Tom”); //line2
    Session session1=sessionFactory.openSession(); //line3
    Transaction tx1 = session1.beginTransaction(); //line4
    session1.save(customer); //line4
    tx1.commit(); //line5
    session1.close(); //line6


    A) line1 B)line2 C)line3 D)line4 E)line5 F)line6


    (10)对于下面程序，Customer对象在第几行变为游离状态？（单选）
    Customer customer=new Customer(); //line1
    customer.setName(”Tom”); //line2
    Session session1=sessionFactory.openSession(); //line3
    Transaction tx1 = session1.beginTransaction(); //line4
    session1.save(customer); //line4
    tx1.commit(); //line5
    session1.close(); //line6


    A) line1 B)line2 C)line3 D)line4 E)line5 F)line6


    (11)下面哪一种检索策略利用了外连结查询？（单选）
    A)马上检索 B)延迟检索 C)迫切左外连结检索


    (12)如果对Customer类的orders集合採用延迟检索策略，编译或执行下面程序，会出现什么情况（单选）
    Session session=sessionFactory.openSession();
    tx = session.beginTransaction();
    Customer customer=(Customer)session.get(Customer.class,new Long(1));
    tx.commit();
    session.close();
    Iterator orderIterator=customer.getOrders().iterator();


    A)编译出错 B)编译通过。并正常执行 C)编译通过。但执行时抛出异常


    (13)关于HQL与SQL，下面哪些说法正确？（多选）
    A)HQL与SQL没什么区别
    B)HQL面向对象，而SQL操纵关系数据库
    C)在HQL与SQL中，都包括select,insert,update,delete语句
    D)HQL仅用于查询数据。不支持insert,update和delete语句


    (14)事务隔离级别是由谁实现的？（单选）
    A)Java应用程序 B)Hibernate C)数据库系统 D)JDBC驱动程序


    (15)悲观锁与乐观锁，哪个具有较好的并发性能？（单选）
    A)悲观锁 B)乐观锁


    答案：
    (1)A,B,C (2)B,C (3)A (4)D (5)A,B,C,D,F (6)C (7)B (8)A,C,D (9)D (10)F (11)C (12)C (13)B,D (14)C (15)B


    1.strust的。


    Action是不是线程安全的？假设不是
    有什么方式能够保证Action的线程安全？假设是，说明原因


    2.MVC，分析一下struts是怎样实现MVC的


    3.struts中的几个关键对象的作用(说说几个关键对象的作用)


    4.spring
    说说AOP和IOC的概念以及在spring中是怎样应用的


    5.Hibernate有哪几种查询数据的方式


    6.load()和get()的差别


    1. Struts的工作原理
    在Struts中，用户的请求一般以*.do作为请求服务名。全部的*.do请求均被指向ActionSevlet， ActionSevlet依据Struts-config.xml中的配置信息，将用户请求封装成一个指定名称的FormBean，并将此 FormBean传至指定名称的ActionBean，由ActionBean完毕相应的业务操作，如文件操作，数据库操作等。每个*.do均有相应的 FormBean名称和ActionBean名称。这些在Struts-config.xml中配置。


    2. Struts长处与缺点
    Struts是开源软件。使开发人员能更深入的了解其内部实现机制。
    Struts 长处：业界”标准”（非常多成功案例），学习资源丰富。
    Struts的长处主要集中体如今两个方面：Taglib和页面导航。


    a、利用Struts提供的taglib能够大大节约开发时间。
    b、维护扩展比較方便。通过一个配置文件。就可以把握整个系统各部分之间的联系，这对于后期的维护有着莫大的优点。
    c、表现与逻辑分离
    d、表单验证攻克了请求数据的验证问题，增强了系统健壮性。
    e、便于团队开发


    Struts缺点：a、大量的使用标签，对于刚開始学习的人难度较大。
    b、ActionForms使用不便、无法进行单元測试（StrutsTestCase仅仅能用于集成）


    3. Struts提供了几个标签库？都是什么标签库？
    Struts提供了五个标签库，即：HTML、Bean、Logic、Template和Nested。


    HTML 标签 用来创建可以和Struts 框架和其它对应的HTML 标签交互的HTML 输入表单
    Bean 标签 在訪问JavaBeans 及其属性。以及定义一个新的bean 时使用
    Logic 标签 管理条件产生的输出和对象集产生的循环
    Template 标签 随着Tiles框架包的出现。此标记已開始降低使用
    Nested 标签 增强对其它的Struts 标签的嵌套使用的能力


    4. Tiles框架是什么？
    Tiles框架为创建Web页面提供了一种模板机制，它能将网页的布局和内容分离。


    1、MVC的各个部分都有那些技术来实现?

    怎样实现?
    答：MVC是Model－View－Controller的简写。“Model”代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）,“View”是应用的表示面（由JSP页面产生）。“Controller”是提供应用的处理过程控制（通常是一个Servlet），通过这样的设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。

    这些组件能够进行交互和重用。


    2、说说Struts的应用。
    答：Struts 是採用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源代码的framework。

    採用Struts能开发出基于MVC设计模式的应用构架。 Struts的主要功能包括：一包括一个controller servlet，能将用户的请求发送到对应的Action对象。二JSP自由tag库，而且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。

    三提供了一系列有用对象：XML处理、通过Java reflection APIs自己主动处理JavaBeans属性、国际化的提示和消息。


    3、strust的Action是不是线程安全的？假设不是有什么方式能够保证Action的线程安全？假设是请说明原因。
    答：不是线程安全的，仅仅要不申明类变量就能够保证线程安全。由于仅仅存在一个Action类实例。全部线程会共享类变量。


    4、应用server详细包含那些？
    答：应用server详细包含：BEA WebLogic Server、IBM WebSphere Application Server、Oracle9i Application Server、JBoss和Tomcat等。


    Hibernate工作原理及为什么要用？
    原理：
    1.读取并解析配置文件
    2.读取并解析映射信息。创建SessionFactory
    3.打开Sesssion
    4.创建事务Transation
    5.持久化操作
    6.提交事务
    7.关闭Session
    8.关闭SesstionFactory
    为什么要用：
    1. 对JDBC訪问数据库的代码做了封装，大大简化了数据訪问层繁琐的反复性代码。
    2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。

    他非常大程度的简化DAO层的编码工作
    3. hibernate使用Java反射机制。而不是字节码增强程序来实现透明性。
    4. hibernate的性能非常好，由于它是个轻量级框架。映射的灵活性非常出色。

    它支持各种关系数据库。从一对一到多对多的各种复杂关系。


    2． Hibernate是怎样延迟载入?
    1. Hibernate2延迟载入实现：a)实体对象 b)集合（Collection）
    2. Hibernate3 提供了属性的延迟载入功能
    当Hibernate在查询数据的时候。数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟载入。他节省了服务 器的内存开销，从而提高了server的性能。
    3．Hibernate中如何实现类之间的关系?(如：一对多、多对多的关系)
    类与类之间的关系主要体如今表与表之间的关系进行操作。它们都市对对象进行操作，我们程序中把全部的表与类都映射在一起，它们通过配置文件里的 many-to-one、one-to-many、many-to-many、
    4． 说下Hibernate的缓存机制
    1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
    2. 二级缓存：
    a) 应用及缓存
    b) 分布式缓存
    条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据
    c) 第三方缓存的实现
    5． Hibernate的查询方式
    Sql、Criteria,object comptosition
    Hql：
    1、 属性查询
    2、 參数查询、命名參数查询
    3、 关联查询
    4、 分页查询
    5、 统计函数
    6． 怎样优化Hibernate？
    1.使用双向一对多关联。不使用单向一对多
    2.灵活使用单向一对多关联
    3.不用一对一，用多对一代替
    4.配置对象缓存，不使用集合缓存
    5.一对多集合使用Bag,多对多集合使用Set
    6. 继承类使用显式多态
    7. 表字段要少，表关联不要怕多。有二级缓存撑腰
    7． Struts工作机制？为什么要使用Struts？
    工作机制：
    Struts的工作流程:
    在web应用启动时就会载入初始化ActionServlet,ActionServlet从
    struts-config.xml文件里读取配置信息,把它们存放到各种配置对象
    当ActionServlet接收到一个客户请求时,将运行例如以下流程.
    -(1)检索和用户请求匹配的ActionMapping实例,假设不存在,就返回请求路径无效信息;
    -(2)假设ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
    -(3)依据配置信息决定是否须要表单验证.假设须要验证,就调用ActionForm的validate()方法;
    -(4)假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActuibErrors对象, 就表示表单验证成功;
    -(5)ActionServlet依据ActionMapping所包括的映射信息决定将请求转发给哪个Action,假设对应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
    -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;
    -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
    为什么要用：
    JSP、Servlet、JavaBean技术的出 现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统很的繁乱，所以在此之上，我们须要一个规则、一个把这些技术组织起来的规则，这就是 框架。Struts便应运而生。
    基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件
    8． Struts的validate框架是怎样验证的？
    在struts配置文件里配置详细的错误提示，再在FormBean中的validate()方法详细调用。
    9． 说下Struts的设计模式
    MVC模式: web应用程序启动时就会载入并初始化ActionServler。

    用户提交表单时，一个配置好的ActionForm对象被创建。并被填入表单对应的数 据，ActionServler依据Struts-config.xml文件配置好的设置决定是否须要表单验证，假设须要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action。假设Action不存在，ActionServlet会先创建这个对象，然后调用 Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完毕业务逻辑，返回一个ActionForward对 象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动 态的网页，返回给客户。
    10． spring工作机制及为什么要用?
    1.spring mvc请全部的请求都提交给DispatcherServlet,它会托付应用系统的其它模块负责负责对请求进行真正的处理工作。
    2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
    3.DispatcherServlet请请求提交到目标Controller
    4.Controller进行业务逻辑处理后，会返回一个ModelAndView
    5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
    6.视图对象负责渲染返回给client。
    为什么用：
    {AOP 让开发者能够创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后。公共服务 （比方日志、持久性、事务等）就能够分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。
    IOC 同意创建一个能够构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。

    没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。


    Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。

    有了 Spring。仅仅要用 JavaBean 属性和配置文件增加依赖性（协作对象）。然后能够非常easy地在须要时替换具有类似接口的协作对象。}
    Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所看到的。
    组成 Spring 框架的每一个模块（或组件）都能够单独存在，或者与其它一个或多个模块联合实现。

    每一个模块的功能例如以下：
    ☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
    ☆ Spring 上下文：Spring 上下文是一个配置文件。向 Spring 框架提供上下文信息。

    Spring 上下文包含企业服务，比如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
    ☆ Spring AOP：通过配置管理特性。Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，能够非常easy地使 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 框架的功能能够用在不论什么 J2EE server中。大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据訪问对象。

    毫无疑问。这种对象能够在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、測试环境之间重用。


    IOC 和 AOP
    控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，可是描写叙述创建它们的方式。在代码中不直接与对象和服务连接。但在配置文件里描写叙述哪一个 组件须要哪一项服务。容器（在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。


    在典型的 IOC 场景中，容器创建了全部对象。并设置必要的属性将它们连接在一起，决定什么时间调用方法。

    下表列出了 IOC 的一个实现模式。
    Spring 框架的 IOC 容器採用类型 2 和类型3 实现。


    面向方面的编程
    面向方面的编程。即 AOP，是一种编程技术，它同意程序猿对横切关注点或横切典型的职责分界线的行为（比如日志和事务管理）进行模块化。

    AOP 的核心构造是方面。它将那些影响多个类的行为封装到可重用的模块中。
    AOP 和 IOC 是补充性的技术。它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在全部方法和 Java 类中才干实现日志功能。在 AOP 方式中，能够反过来将日志服务模块化，并以声明的方式将它们应用到须要日志的组件上。

    当然，优势就是 Java 类不须要知道日志服务的存在，也不须要考虑相关的代码。

    所以。用 Spring AOP 编写的应用程序代码是松散耦合的。
    AOP 的功能全然集成到了 Spring 事务管理、日志和其它各种特性的上下文中。
    IOC 容器
    Spring 设计的核心是 org.springframework.beans 包。它的设计目标是与 JavaBean 组件一起使用。

    这个包通常不是由用户直接使用，而是由server将其用作其它多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现。同意通过名称创建和检索对象。

    BeanFactory 也能够管理对象之间的关系。


    BeanFactory 支持两个对象模型。


    □ 单态 模型提供了具有特定名称的对象的共享实例，能够在查询时对其进行检索。Singleton 是默认的也是最经常使用的对象模型。对于无状态服务对象非常理想。
    □ 原型 模型确保每次检索都会创建单独的对象。

    在每一个用户都须要自己的对象时，原型模型最适合。


    bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个演示样例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。










      
    1.  BeanFactory的作用是什么？   [中]   
    BeanFactory是配置、创建、管理bean的容器。有时候也称为bean上下文。Bean与bean的依赖关系，也是由BeanFactory负责维护的。

      
    2.  bean在spring的容器中两种基本行为是什么? [中]   
    Singleton:单态   
    Non-singleton或prototype:原型   
    3.  spring配置文件里的ref元素的作用是什么?它的两个基本属性是什么?  [中]   
    用于指定属性值为spring容器中的其他bean.两个基本属性是bean和local   
    4.  什么是DWR?它有哪些功能？  [中]   
    DWR(Direct Web Remoting)是一个WEB远程调用框架.   
    能够在client利用JavaScript直接调用服务端的Java方法并返回值给JavaScript   
    DWR依据Java类来动态生成JavaScrip代码.   
    支持Dom Trees,支持Spring,支持commons-logging   
    5.  Ajax的工作原理 ？　［难］   
    在会话的開始，浏览器载入Ajax引擎   
    请求动作通过JavaScript调用Ajax引擎来取代.    
    引擎负责绘制用户界面以及与server端通讯。   
    Ajax引擎採用异步交互过程－－不用等待server的通讯。   
    6.  XMLHttpRequest对象是什么，它有哪些经常用法？ [难]      
    一个 JavaScript 对象。

    是Ajax 的核心。   
    该对象的方法和属性。

      
        open()：建立到server的新请求。

       
        send()：向server发送请求。    
        abort()：退出当前请求。    
        readyState：提供当前 HTML 的就绪状态。    
        responseText：server返回的请求响应文本。.   
      
    7.  XMLHttpRequest有哪些属性， 它的值分代表什么？[ 中]   
      
        
      
    8.  什么是Ajax?

     [易]   
    AJAX（Asynchronous JavaScript and XML）。它不是一门新的语言或技术，而是多种技术的综合，包含：   
    Javascript   
    XHTML   
    CSS   
    DOM   
    XML   
    XSTL   
    XMLHttpRequest   
      
    9.  同步与异步的差别？ [ 难]   
    普通B/S模式（同步）AJAX技术（异步）   
    同步：提交请求->等待server处理->处理完成返回 这个期间client浏览器不能干不论什么事，而异步则是 请求通过事件触发->server处理->处理完成   
    同步是堵塞模式。异步是非堵塞模式。     
    同步(发送方发出数据后，等接收方发回) 异步(发送方发出数据后。不等接收方发回响应)   
      
    10. Struts+Hibernate+Spring开发模式中Hibernate扮演的角色  [中]   
      答：Hibernate扮演的是数据持久层 它的作用是实现持久化对象和数据库表   
    之间的映射，形成持久化对象和数据库表中数据的一个转换平台   
      
    11. 什么是Hibernate 的抓取策略  [难]   
      抓取策略是指当应用程序须要利用关联关系进行对象获取的时候。   
    12. 何为容器  [中]   
      容器就是符合某种规范的可以提供一系列服务的管理器。

      
    13. Spring实现了那几种模式  [中]   
    答: 工厂模式 和 单例模式   
      
    14 :Hibernate实体对象生命周期的三种状态  [难]   
    答 Transient(瞬态) ，persistent(持久态)和Detached(游历态)   
      
    15: HQL查询參数的处理方法  [中]   
    答：直接将參数拼写为HQL语句   
    通过參数名称来标识參数   
      
    16. Hibernate实体之间的关联关系的三种形式  [中]   
       答  一对一关联   
           一对多关联   
           多对多关联   
      
    17.  Hibernate具用的三种检索方式  [难]   
    答：HQL检索方式   
        QBC检索方式   
        SQL检索方式   
    18. spring 中<Bean>的depends-on属性是什么  [中]   
    Depends-on用于当前Bean初始化之前显示的强制一个或多个bean被初始化   
    19.  spring 中的BeanWrapper类是什么  [难]   
    BeanWrapper类是一个对JavaBean进行各种操作的工具类   
    BeanWrapper本身是一个接口BeanWrapperImpl实现了BeanWrapper   
    20 . <set>元素有一个cascade属性，假设希望Hibernate级联保存集合中的对象，casecade属性应该取什么值？  [难]   
       答:save-update   
    21.  Hibernate中session什么时候是游离态  [中]   
    答:session.close();方法后    
    22. Hibernate中映射文件<hibernate-mapping> inverse属性和cascade属性的差别  [中]   
       答:inverse属性仅仅存在于集合标记的元素中集合元素包含<set/>,<map/>,<list/>,<array/>,<bag/>   
      Inverse属性的作用是是否将对集合对象的改动反射到数据库中 inverse=”false”时改动反射到数据库中 inverse=”true” 时改动不反射到数据库中   
      Cascade属性的作用是描写叙述关联对象进行操作时的级联特性。因此仅仅有涉及到关系的元素才有cascade属性   
      
    23. : Hibernate中Session对象的load()方法和get()方法的差别（请列举出两点）[难]   
    答：①记录不存在时 get()方法会返回空（null），而load()方法将会抛出一个HibernateException异常 ② load()方法查询数据时会先找Hibernate的内部缓存和二级缓   
    存中的现有数据。get()方法在内部缓存中没有打到相相应的数据时装直接运行SQL语句   
    进行查询   
    24. : Hibernate中HQL属于什么语言  [易]   
      答：HQL是面向对象的查询语言，它能够查询以对象形式存在的数据。   
      
    25.  Hibernate简单介绍以及主要功能  [中]   
      答：Hibernate是採用ORM模式实现数据持久层的一个优秀的JAVA组件，它提供了   
    强大，高效的将JAVA对象进行持久化操作的服务   
      
    26. 简述Hibernate的长处 [难]   
     答：开源和免费的License，我能够在须要的时候研究源码，改写源码，进行功能的定制。轻量级封装，避免引入过多复杂的问题。调试easy，也减轻程序猿的负担。

       
    具有可扩展性。API开放，当本身功能不够用的时候，能够自己编码进行扩展。   
      
    27. 如何构建SessionFactory  [难]   
      答: Hibernate的SessionFactory接口提供Session类的实例，Session类用于完毕对数据库的操作。   
    因为SessionFactory实例是线程安全的（而Session实例不是线程安全的）。所以每一个操作都能够共用同一个SessionFactory来获取Session。Hibernate配置文件分为两种格式，一种是xml格式的配置文件。还有一种是Java属性文件格式的配置文件   
    28. :从XML文件读取配置信息构建SessionFactory的详细过程例如以下。  [难]   
    （1）创建一个Configuration对象，并通过该对象的configura()方法载入Hibernate配置文件，代码例如以下。

      
    Configuration config = new Configuration().configure();   
    configura()方法：用于告诉Hibernate载入hibernate.cfg.xml文件。

    Configuration在实例化时默认载入classpath中的hibernate.cfg.xml，当然也能够载入名称不是hibernate.cfg.xml的配置文件。比如wghhibernate.cfg.xml，能够通过下面代码实现。

      
    Configuration config = new Configuration().configure("wghhibernate.cfg.xml");   
    （2）完毕配置文件和映射文件的载入后，将得到一个包含全部Hibernate执行期參数的Configuration实例，通过Configuration实例的buildSessionFactory()方法能够构建一个惟一的SessionFactory，代码例如以下:   
    SessionFactory sessionFactory = config.buildSessionFactory();   
    构建SessionFactory要放在静态代码块中，由于它仅仅在该类被载入时运行一次。   
      
    29. 写出使用构造方法进行注入的关键代码  [难]   
    <bean id=”constructBean” class=”com.huang.ConstructBean”>   
     <constructor-arg><ref  bean=”bean_1”/></ constructor-arg >   
    <constructor-arg><ref  bean=”bean_2”/></ constructor-arg >   
    <constructor-arg><ref  bean=”bean_3”/></ constructor-arg >   
    </bean>   
      
      
    30. 什么是IOC？  [难]   
    不创建对象，可是描写叙述创建它们的方式。

    在代码中不直接与对象和服务连接，但在配置文件里描写叙述哪一个组件须要哪一项服务。容器（在Spring 框架中是 IOC 容器） 负责将这些联系在一起。    
    就是由容器控制程序之间的关系。而非传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器。控制权的转移，就是所谓的反转。

      
      
    31. 编程题: 写一个Singleton出来。  [难]   
    Singleton模式主要作用是保证在Java应用程序中。一个类Class仅仅有一个实例存在。

      
      
    第一种形式: 定义一个类，它的构造函数为private的。它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用当中的方法。

      
    public class Singleton {   
    private Singleton(){}   
    　　    private static Singleton instance = new Singleton();   
    　　    public static Singleton getInstance() {   
    　　　　    return instance; 　　   
    　　    }    
        }    
        另外一种形式:    
    public class Singleton {    
    　　private static Singleton instance = null;   
    　　public static synchronized Singleton getInstance() {   
    　　if (instance==null)   
    　　　　instance＝new Singleton();   
            return instance; 　　}    
    }   
      
      
        String tempStr = "";   
        try {   
          tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");   
          tempStr = tempStr.trim();   
        }   
        catch (Exception e) {   
          System.err.println(e.getMessage());   
        }   
        return tempStr;   
      }   
    32. J2EE是技术还是平台还是框架？  [中]   
        J2EE本身是一个标准。一个为企业分布式应用的开发提供的标准平台。   
        J2EE也是一个框架。包含JDBC、JNDI、RMI、JMS、EJB、JTA等技术。   
      
    33. 我们在web应用开发过程中常常遇到输出某种编码的字符，如iso8859-1等，怎样输出一个某种编码的字符串？  [难]   
      Public String translate (String str) {   
        String tempStr = "";   
        try {   
          tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");   
          tempStr = tempStr.trim();   
        }   
        catch (Exception e) {   
          System.err.println(e.getMessage());   
        }   
        return tempStr;   
      }   
    ３４．怎样使用静态工厂方法来创建Bean的实例  [易]   
       <bean id=”staticFactoryBean” class=”com.huang.StaticFactoryBean”   
    factory-method=”静态方法名”/>   
    相当于: StaticFactoryBean staticFactoryBean=StaticFactoryBean.静态方法名   
      
    使用实例化的工厂方法来创建Bean的实例   
       <!—注意此时bean的class属性为空-->   
      <bean id=”dynamicFactory”class=”com.huang.DynamicFactory”/>   
      <bean id=”dynamiceFactoryBean” factory-bean=”dynamicFactory”   
       Factory-method=”方法名”/>   
    相当于: DynamicFactory dynamicFactory=new DynamicFactory();   
          DynamiceFactoryBean dynamiceFactoryBean=dynamicFactory.方法名   
    35.  从Java属性文件读取配置信息构建SessionFactory的详细过程例如以下:  [难]   
       （1）创建一个Configuration对象，此时Hibernate会默认载入classpath中的配置文件hibernate.properties。代码例如以下。   
    Configuration config = new Configuration();   
    （2）因为在配置文件里缺少对应的配置映射文件的信息，所以此处须要通过编码方式载入。这能够通过Configuration对象的addClass()方法实现，详细代码例如以下。   
    config.addClass(BranchForm.class);   
    addClass()方法用于载入实体类。   
    （3）完毕配置文件和映射文件的载入后，将得到一个包含全部Hibernate执行期參数的Configuration实例。通过Configuration实例的buildSessionFactory()方法能够构建一个惟一的SessionFactory，代码例如以下。   
    SessionFactory sessionFactory = config.buildSessionFactory();   
      
      
      
    36. spring框架的7个模块是什么？   [ 难]   
    答: (1) spring  AOP  --面象切面编程   
       (2)spring  DAO  --数据訪问对象   
       (3)spring ORM   --对象关系影射   
    (4)spring Contect  -- 上下文配置，向Spring框架提供上下文信息   
    (5)spring WEB  - -WEB上下文模块   
    (6)spring WEB-MVC  --实现了MVC   
    (7)spring CORE –核心容器提供Spring框架基本功能   
      
    37. 什么是AOP 请祥述  [中]   
      答: 是面向切面编程    
         AOP 把软件系统分为两个部分：核心关注点和横切关注点。

    所谓的核心关注点。是业务处理的主要流程。也就是说这个解决方式要做的事。所谓横切关注点，是与核心业务无关的部分。它把常发生在核心关注点的多处，而各处基本相似。如日志，事务，权限等 。   
      
    38.  Hinbernate和EJB的差别  [中]   
     答：Hibernate能够用在不论什么JDBC使用的场合，比如Java应用程序的数据库訪问代码，DAO接口的实现类，甚至能够是BMP里面的訪问数据库的代码。

    从这个意义上来说，Hibernate和EB不是一个范畴的东西，也不存在非此即彼的关系。   
      
    39.  普通情况下，关系数据模型与对象模型之间有哪些匹配关系 [难]   
       答：表相应类   
    记录相应表的对象   
    表的字段相应类的属性   
      
    40.  事务隔离级别是由谁实现的？  [难]   
     答：数据库系统‘   
      
    41. 什么是IOC  [难]   
    答：IOC 是控制反转。实现了对象之间的依赖关系的转移成而使程序的菘耦合   
    42. 在Spring中给属性有几种赋值方式 请祥叙   [难]   
      答：有四种 各自是   
    (1)普通属性赋值    
    （2）集合属性赋值   
    （3）Properties赋值   
    (4)Map 属性赋值     
      
    43.  在Spring说说Bean的alias元素和name属性有什么差别  [难]   
     答: <bean>元素name属性能够一次为<bean>定义多个别名   
           例：<bean id=”beanName” name=”alias_1,alias_2”/>   
           <alias>元素一次仅仅能定义一个别名   
             例：<alias name=”beanName” alias=”toName”/>   
          注意: alias元素name属性是bean实例名   
    44. Bean 的作用域用几种。请祥叙  [难]   
        答: 用5种    
    各自是:    
    1. singleton  IOC容器仅仅会创建一个Bean的唯一的实例   
    2. prototype  IOC容器在每次请求该Bean的时候都创建一个新的实例   
    3. request 在一次Http请求中 IOC容器会返回该Bean的同一个实例。而对于不同的用户请求。则会返回不同的实例   
    4. session 在一次Http请求Session 中 IOC容器会返回该Bean的同一个实例，而对于不同的用户Session，则会返回不同的实例   
    5. global session在一个全局Http请求Session 中   
      
    45. 简述什么是ORM   [中]   
    答：ORM的全称是Object-Relational Mapping 翻译成中文就是“对象－关系映射”   
    ORM组件的主要功能就是实现实体域对象的持久化并封装数据库訪问的细节   
       ORM本身并非一个组件，它是具用某种功能的组件的总称，也能够说是一种框   
    架结构   
      
    46.：struts中的几个关键对象的作用(说说几个关键对象的作用)  [中]   
     struts中的几个关键对象:Action Global(设置语言靠它了) ModuleConfig(获取mapping)，   
    47．Action的作用  [中]   
       Action的作用是接受用户的请求，通过调用业务方法实现业务处理的功能。   
    48. 在通常情况下软件系统由表示层，业务层，持久层和数据库层组成，Struts属于哪一层？ [难]   
       Struts属于表示层组件，它的作用主要体如今下面几个方面：   
    1)     输出用户界面和接收用户的输入。实现与用户的交互。   
    2) 调用业务方法，完毕业务处理，还要包含处理后的显示工作。

      
      
    48：Struts标签库由哪些组件组成？  [难]   
    标签库是组合在一起的一组JSP自己定义标签。   
         标签库由下面组件组成：   
    1) 标签处理程序   
    2) 标签库描写叙述符(TLD)文件   
    3) 应用程序部署描写叙述符(web.xml)文件   
    4) JSP页面中标签库的声明   
    49. 用<bean:write>读出一个URL和一个名称。    [难]    
      用<html:link>的话怎么组合起来。

       
      即要达到这种效果      
      <a   href="<bean:write   name="data"   property="url">">      
               <bean:write   name="data"   property="tilte">      
      </a>   
    <html:link   page="<bean:write   name="data"   property="url">">      
          <bean:write   name="data"   property="title"/>      
      </html:link>     会报出属性data无值的错误!(page="<bean:write   name="data"   property="url">"中的data无值。）     
    50：如何才干配置＜html:button＞的资源文件？ [难]   
       在资源文件 ApplicationResourses.properties 中增加  label.login=login      
      在jsp页面写：      
      <html:button   name="btn_login"><bean:message   key="label.login"/></html:button>      
      这样显示页面时，button上就会显示label.login的相应内容“login”   
      
      
    51. 说说struts框架,的方法的工作原理或流程   [易]   
      答: 对于採用Struts框架的web应用， 在web应用启动时会载入并初始化ActionServlet。ActionServlet从struts-config.xml中读取配置信息，   
     把它们存放到各种配置对象中，比如把Action的映射信息存放在ActionMapping对象中。   
     当ActionServlet接收到客户请求时。运行下面流程：      
        1.检索和用户请求匹配的ActionMapping实例，假设不存在。就返回用户请求路径无效信息。        
         2.假设ActionForm实例不存在，就创建一个ActionForm对象并在当中保存客户提交的表单内容。        
         3.依据配置信息决定是否调用ActionForm的validate()方法；      
         4.假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActionErrors对象。就表示表单验证成功；      
         5.ActionServlet依据ActionMapping实例包括的映射信息将请求转发给Action（假设Action实例不存在，就先创建Action实例），然后调用Action的excute()方法；        
       6.Action的excute()方法返回一个ActionForward对象。ActionServlet再把客户请求转发给ActionForward对象指向的JSP组件；    
    7.ActionForward对象指向的JSP组件生成动态网页。返回给客户。    
      
    52： strust的Action是不是线程安全的？ [难]   
        答：线程安全就是你能够在多线程环境下使用它。而不须要你来对它进行特殊的处理。action都是继承至servlet的。因为servlet就是线程不安全的（指多个线程共享一个servlet对象。所以），所以不要再action中定义类变量和实例变量，否则其它线程改变了这些值，可本线程还在使用   
    53 ：MVC，分析一下struts是怎样实现MVC的 [难]   
    从MVC角度来看看struts的体系结构（Model 2）与工作原理：   
    　　1）模型（Model）   
    　　在Struts的体系结构中。模型分为两个部分：系统的内部状态和能够改变状态的操作（事务逻辑）。

    内部状态通常由一组ActinForm Bean表示。依据设计或应用程序复杂度的不同，这些Bean能够是自包括的并具有持续的状态。或仅仅在须要时才获得数据（从某个数据库）。大型应用程序通常在方法内部封装事务逻辑（操作），这些方法能够被拥有状态信息的bean调用。

    比方购物车bean。它拥实用户购买商品的信息，可能还有checkOut()方法用来检查用户的信用卡，并向仓库发定货信息。 小型程序中。操作可能会被内嵌在Action类，它是struts框架中控制器角色的一部分。当逻辑简单时这种方法非常适合。

    建议用户将事务逻辑（要做什么）与Action类所扮演的角色（决定做什么）分开。   
    2）视图（View）   
    　　视图主要由JSP建立，struts包括扩展自己定义标签库（TagLib），能够简化创建全然国际化用户界面的过程。

    眼下的标签库包括：Bean Tags、HTML tags、Logic Tags、Nested Tags 以及Template Tags等。   
    　3）控制器（Controller）   
      
    　　在struts中。主要的控制器组件是ActionServlet类中的实例servelt，实际使用的servlet在配置文件里由一组映射（由ActionMapping类进行描写叙述）进行定义。

    对于业务逻辑的操作则主要由Action、ActionMapping、ActionForward这几个组件协调完毕的，当中Action扮演了真正的业务逻辑的实现者。ActionMapping与ActionForward则指定了不同业务逻辑或流程的执行方向。

    struts-config.xml 文件配置控制器。

      
    54  ：简述什么是Struts  [中]   
     Struts仅仅是一个MVC框架（Framework）,用于高速开发Java Web应用。

    Struts实现的重点在C(Controller)，包含ActionServlet/RequestProcessor和我们定制的Action,也为V(View)提供了一系列定制标签（Custom Tag）。但Struts差点儿没有涉及M(Model),所以Struts能够採用JAVA实现的不论什么形式的商业逻辑。    
    Spring是一个轻型容器(light-weight container)。其核心是Bean工厂(Bean Factory)，用以构造我们所须要的M(Model)。

    在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现。用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现J2EE的应用；DAO/ORM的实现方便我们进行数据库的开发；Web MVC和Spring Web提供了Java Web应用的框架或与其它流行的Web框架进行集成。    
    就是说可将两者一起使用。达到将两者自身的特点进行互补。   
      
    55   ：Struts有哪些主要功能：[难]   
    1.包括一个controller　servlet，能将用户的请求发送到对应的Action对象。   
    2. JSP自由tag库，而且在controller　servlet中提供关联支持，帮助开发员创建交互式表单应用。   
    3. 提供了一系列有用对象：XML处理、通过Java　reflection　APIs自己主动处理JavaBeans属性、国际化的提示和消息。

      
    Struts项目的目标是为创建Java web应用提供一个开放源码的framework。Struts framework的内核是基于比如Java Servlets, JavaBeans, ResourceBundles, 和 XML。以及各种 Jakarta Commons包的标准技术的灵活的控制层。   
    Struts提供了它自身的控制器组件。并整合了其它技术，以提供模型和视图。对于模型。同大多数的第三方软件包一样。如Hibernate, iBATIS, 或者 Object Relational Bridge，Struts可以和标准数据连接技术相结合。如JDBC和EJB。对于视图，Struts与JavaServer Pages协同工作，包括JSTL和JSF。   
    56   ：Stuts框架中控制器组件的类主要有哪些？  [难]   
    ActionServlet ,   
    RequestProcessor   
    , Action,    
     ActionMapping,   
    ActionForward   
    41：Validator的组成与作用  [难]   
    Validator框架主要包含下面几个部分：   
    1) 实现各种验证规则的Java类   
    2) 配置文件   
    3) 资源文件   
    4) JSP自己定义标签   
    Validator组件能够非常好地解决用户输入数据的验证问题，但它并非一个独立执行的组件，它能够被嵌入到眼下大部分的Web应用开发框架中。Validator组件的验证方式有多种，既能够通过JavaScript脚本实现用户输入数据的页面验证，也能够实如今后台处理程序中的Java验证   
    57. ActionForm的作用？[难]   
      ActionForm属于一种传输数据对象，联系了前台页面与后台的Action方法，实现了前台与后台之间的数据转换和传递。它的作用主要体如今下面几个方面：    
    1) 在显示页面的时候用于完毕页面中各种控件的初始化工作。   
    2) 在用户提交请求的时候。ActionForm又代表了用户所提交的数据。供Action以及兴许的业务处理方法使用   
    ActionForm还有另外一个作用就是对用户提交数据的合法性进行验证   
                  Java  基础就业题库   
      
    1.  类和对象的差别?

       [易]   
    类是对象的抽象,是模型概念,而对象是实实在在存在的事物,是现实中存在的实体   
    2.  Java类库中八个标准包各自是什么?

     [易]   
    java.lang    提供经常使用的类、接口、一般异常、系统等编程语言的核心内容。

       
    java.util    包括日期、日历、向量、堆栈等有用工具。

       
    java.io      包括输入输出流类、文件类等与输入输出I/O有关的类。        
    java.awt     包括窗体和屏幕元素类。事件处理接口等与图形用户界面有关的内容。

          
    java.applet  提供为编写applet小程序所须要的类。    
    java.text    提供与文本有关的类。

       
    java.net     包括url类等与网络传输有关的东西。        
    java.sql     提供与数据库应用相关的类和接口。   
      
    3.  接口和抽象类有什么差别?    [中]   
      
    接口是公开的，不能包括私有的方法或变量。而抽象类是能够有私有方法或私有变量的，    
    实现接口的一定要实现接口里定义的全部方法。而实现抽象类能够有选择地重写须要用到的方法，   
    接口能够实现多重继承，而一个类仅仅能继承一个超类。但能够通过继承多个接口实现多重继承。   
    接口还有标识（里面没有不论什么方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.   
    一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到详细类实现。   
      
      
    4.  说说java中的内存分配?  [难]   
    Java把内存分成两种，一种叫做栈内存，一种叫做堆内存   
    在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。

    当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间。当超过变量的作用域后，java会自己主动释放掉为该变量分配的内存空间，该内存空间能够立马被另作他用。    
      
    堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自己主动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还能够在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量。以后就能够在程序中使用栈内存中的引用变量来訪问堆中的数组或者对象。引用变量相当于为数组或者对象起的一个别名。或者代号。    
      
    引用变量是普通变量。定义时在栈中分配内存，引用变量在程序执行到作用域外释放。

    而数组＆对象本身在堆中分配。即使程序执行到使用new产生数组和对象的语句所在地代码块之外。数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，可是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。

    这个也是java比較占内存的主要原因。可是在敲代码的时候，能够人为的控制   
      
    5.  Character类有哪些经常用法?  [难]   
    charValue()    
    返回字符对象相应的值。

       
    digit(char, int)    
    以指定基数返回字符 ch 相应的数值。    
    equals(Object)    
    比較该对象和指定对象。    
    forDigit(int, int)    
    确定以指定基数指定的数相应的字符。    
    getNumericValue(char)    
    返回此字符相应的 Unicode 的非负整型值。

       
    getType(char)    
    返回一个表示字符种类的值。    
    hashCode()    
    返回此字符相应的哈希码。    
    isDefined(char)    
    判定一个字符在 Unicode 中是否有定义。    
    isDigit(char)    
    判定指定字符是否为数字。    
    isIdentifierIgnorable(char)    
    判定指定字符在 Java 标识符中或 Unicode 标识符中是否应看作是一个可忽略字符。

       
    isISOControl(char)    
    判定指定字符是否为 ISO 控制字符。

       
    isJavaIdentifierPart(char)    
    判定指定字符是否为 Java 标识符中除首字符外的字符。    
    isJavaIdentifierStart(char)    
    判定指定字符是否可作为 Java 标识符的首字符。    
    isJavaLetter(char)    
    判定指定字符是否为 Java 字母，若是。它可作为 Java 语言中一个标识符的首字符。 不推荐使用该方法。

       
    isJavaLetterOrDigit(char)    
    判定指定字符是否为 Java 字母或数字，若是。它可作为 Java 语言中的一个标识符除首字符外的字符。

    不推荐使用该方法。    
    isLetter(char)    
    判定指定字符是否为字母。

       
    isLetterOrDigit(char)    
    判定指定字符是否为字母或数字。

       
    isLowerCase(char)    
    判定指定字符是否为小写字符。    
    isSpace(char)    
    判定指定字符是否为 ISO-LATIN-1 空格。

    不推荐使用该方法。    
    isSpaceChar(char)    
    判定指定字符是否为 Unicode 空白字符。

       
    isTitleCase(char)    
    判定指定字符是否为标题字符。    
    isUnicodeIdentifierPart(char)    
    判定指定字符是否为 Unicode 标识符中除首字符外的字符。

       
    isUnicodeIdentifierStart(char)    
    判定指定字符是否可作为 Unicode 标识符首字符。

       
    isUpperCase(char)    
    判定指定字符是否为大写字符。    
    isWhitespace(char)    
    据 Java 语言，判定指定字符是否为空格。

       
    toLowerCase(char)    
    将给定字符映射为相应的小写字符，若没有相应的小写字符，返回此字符本身。    
    toString()    
    返回表示此字符值的串对象。

       
    toTitleCase(char)    
    将字符參数转换为标题字符。    
    toUpperCase(char)    
    将字符參数转换为大写字符。    
    5.Boolean类有哪些方法?

      
    booleanValue()    
    返回 Boolean 对象相应的布尔值。    
    equals(Object)    
    当且仅当參数非空，且是包括与此对象同样的布尔值的布尔对象时，返回 true。    
    getBoolean(String)    
    当且仅当以參数命名的系统属性存在，且等于 "true" 时，返回为 true。

       
    hashCode()    
    返回此布尔值相应的哈希码。    
    toString()    
    返回表示当前布尔值的一个串对象。

       
    valueOf(String)    
    返回表示指定串的布尔值。   
      
    6.  String s = new String("xyz");创建了几个String Object?    [中]   
       两个对象。一个是“xyx”,一个是指向“xyx”的引用对象s。    
    7.  String与StringBuffer有什么差别?    [难]   
    从表面看来String类仅仅用一个加号（+）便完毕了字符串的拼接，而StringBuffer类却要调用一个append()方法，是否实现起来更简洁，更单纯呢？事实上不然，让我们了解一下程序执行内部发生了哪些事情：    
      
    经编译后程序的bytecode（字节码）展示出了实质： 在用String类对象直接拼接时，JVM会创建一个暂时的StringBuffer类对象。并调用其append()方法完毕字符串的拼接，这是由于String类是不可变的。拼接操作不得不使用StringBuffer类（而且－－JVM会将"You are nice."和"I love you so much."创建为两个新的String对象）。

    之后。再将这个暂时StringBuffer对象转型为一个String，代价不菲！可见，在这一个简单的一次拼接过程中，我们让程序创建了四个对象：两个待拼接的String，一个暂时StringBuffer，和最后将StringBuffer转型成为的String－－它当然不是最初的str了。这个引用的名称没变。但它指向了新的String对象。    
      
    而假设直接使用StringBuffer类。程序将仅仅产生两个对象：最初的StringBuffer和拼接时的String（"I love you so much."）。也不再须要创建暂时的StringBuffer类对象而后还得将其转换回String对象。   
      
    short s1 = 1; s1 = s1 + 1;有什么错?

      
    short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，须要强制转换类型）   
        short s1 = 1; s1 += 1;有什么错?

       
    short s1 = 1; s1 += 1;（能够正确编译）    
      
    8.  能否够继承String类?   [难]   
    String类是final类故不能够继承。   
      
      
    9.  throw与throws有什么差别?

       [中]   
      
    throws是用来声明一个方法可能抛出的全部异常信息   
    throw则是指抛出的一个详细的异常类型。   
    通常在一个方法（类）的声明处通过throws声明方法（类）可能抛出的异常信息，而在方法（类）内部通过throw声明一个详细的异常信息。   
    throws通常不用显示的捕获异常，可由系统自己主动将全部捕获的异常信息抛给上级方法；   
    throw则须要用户自己捕获相关的异常。而后在对其进行相关包装，最后在将包装后的异常信息抛出。

      
      
    throws语句   
    throws用来标明一个成员函数可能抛出的各种"异常"。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的"异常"的类型。假设"异常"的类型是Error或RuntimeException。或它们的子类，这个规则不起作用，由于这copy;在程序 的正常部分中是不期待出现的。假设你想明白地抛出一个RuntimeException。你必须用throws语句来声明它的类型。这就又一次定义了成员函数的定义语法：type method-name(arg-list) throws exception-list { }以下是一段程序，它抛出了一个"异常"， 但既没有捕捉它，也没实用throws来声明。这在编译时将不会通过。   
      
    try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被运行，什么时候被运行。在return前还是后?

      
    会运行。在return前运行。   
      
    10. 常见的runtime exception有哪些?。   [中]   
    ArithmeticException,    
    ArrayStoreException,    
    BufferOverflowException,    
    BufferUnderflowException,    
    CannotRedoException, CannotUndoException,   
    ClassCastException,   
    CMMException,    
    ConcurrentModificationException,   
    DOMException,    
    EmptyStackException, IllegalArgumentException,    
    IllegalMonitorStateException,    
    IllegalPathStateException,    
    IllegalStateException,    
    ImagingOpException, IndexOutOfBoundsException,    
    MissingResourceException,    
    NegativeArraySizeException,    
    NoSuchElementException, NullPointerException,    
    ProfileDataException,    
    ProviderException,    
    RasterFormatException,    
    SecurityException,    
    SystemException, UndeclaredThrowableException,    
    UnmodifiableSetException,    
    UnsupportedOperationException   
    NullPointException   
      
    11. 介绍JAVA中的Collection FrameWork(包含怎样写自己的数据结构)?    [难]   
    答：Collection FrameWork例如以下：    
    Collection    
    ├List    
    │├LinkedList    
    │├ArrayList    
    │└Vector    
    │　└Stack    
    └Set    
    Map    
    ├Hashtable    
    ├HashMap    
    └WeakHashMap    
    Collection是最主要的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）    
    Map提供key到value的映射    
      
      
    12. ArrayList和Vector的差别,HashMap和Hashtable的差别  [难]   
    答：就ArrayList与Vector主要从二方面来说.    
    一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的    
    二.数据增长:当须要增长时,Vector 默认增长为原来一培，而ArrayList却是原来的一半    
    就HashMap与HashTable主要从三方面来说。   
    一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现    
    二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的。不是同步的    
    三.值：仅仅有HashMap能够让你将空值作为一个表的条目的key或value   
      
      
    13. Math.round(11.5)等於多少? Math.round(-11.5)等於多少?    [难]   
    Math.round(11.5)==12  
    Math.round(-11.5)==-11  
    round方法返回与參数最接近的长整数.   
    14. swtich能否作用在byte上。能否作用在long上。能否作用在String上?  [难]   
    switch（expr1）中，expr1是一个整数表达式。

    应该是 int、 short、 char byte。   
    long,string 都不能作用于swtich。   
      
      
    15. GC是什么?

    为什么要有GC?

       [难]   
    GC是垃圾收集的意思（Gabage Collection）   
    Java提供的GC功能能够自己主动监測对象是否超过作用域从而达到自己主动回收内存的目的，   
    Java语言没有提供释放已分配内存的显示操作方法。   
      
      
      
    16. 什么叫方法重载   [中]   
    方法重载就是一个同名方法。有多种不同的签名    
    说白了就是一个同名方法能够传入不同个数或类型的參数    
    之间能够互相调用   
      
      
    17. 数组有没有length()这种方法? String有没有length()这种方法？  [中]   
    数组没有length()这种方法，有length的属性。

    String有有length()这种方法   
      
    18.   什么是抽象类抽象类  [中]   
    仅提供一个类型的部分实现。抽象类能够有实例变量，以及一个或多个构造函数。

    抽象类能够同一时候有抽象方法和详细方法。一个抽象类不会有实例，这些构造函数不能被client调用来创建实例。一个抽象类的构造函数能够被其子类调用，从而使一个抽象类的全部子类都能够有一些共同的实现，而不同的子类能够在此基础上有其自己的实现。

      
      
    19．  抽象类的用途　　［中］   
    1）  详细类不是用来继承的。 Scott Meyers曾指出。仅仅要有可能，不要丛详细类继承。

    2）  如果有2个详细类。类A和类B，类B是类A 的子类，那么一个最简单的改动方案是应当建立一个抽象类（或java接口）C，然后让类A和类B成为抽象类C的子类。3）  抽象类应当拥有尽可能多的共同代码。以提高代码的复用率。

    4）  抽象类应当拥有尽可能少的数据。

      
    20  .java中接口有什么用?

      [难]   
    java不同意多重继承，也就是说一个子类仅仅能有一个父类，Son extends FatherA,FatherB 是错误的    
    为了弥补这点不足，java同意实现多个接口。Son extends FatherA implements AnotherFatherA,AnotherFatherB是同意的    
    接口中的方法没有实体。就这一点而言就相当于abstact class。如：    
    interface ainter{    
    void dosth(int i);    
    }    
    ainter是一个接口。它只声明了一个方法dosth，而没有详细实现它    
    class aclass implements ainter    
    {    
    public void dosth(int i) {    
      
    //在这里你能够不作不论什么处理，可是必须实现方法体    
    }    
    }    
    aclass实现了ainter这个接口，因此它必须实现ainter中的方法dosth   
      
    21. 什么叫方法重载  [易]   
    方法重载就是一个同名方法。有多种不同的签名    
    说白了就是一个同名方法能够传入不同个数或类型的參数    
    之间能够互相调用   
      
      
    22. 垃圾回收机制的原理？  [难]   
    在JAVA中 ,JAVA VM 每隔一段时间就会查看每一块由NEW分配的内存空间,看指向它的有效引用是否存在,假设这个引用不存在,系统会自己主动将这块空间归入空暇内存区.这个过程被称为 垃圾收集.   
      
      
    23.. 什么叫面向对象?   [中]   
    面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继承、封装、消息等基本概念来进行程序设计。

    从现实世界中客观存在的事物（即对象）出发来构造软件系统，而且在系统构造中尽可能运用人类的自然思维方式。

    开发一个软件是为了解决某些问题，这些问题所涉及的业务范围称作该软件的问题域。

    其应用领域不不过软件，还有计算机体系结构和人工智能等。   
      
      
      
    24. 面向对象的涉及方法有哪些?

      [中]   
     OOA－Object Oriented Analysis 　　　　面向对象的分析   
    　　   
    　　OOD－Object Oriented Design 　　　　　面向对象的设计   
    　　   
    OOI－Object Oriented Implementation 　面向对象的实现   
      
      
    25. jvm工作原理   [难]   
    执行jvm 字符码的工作是由解释器来完毕的。解释执行过程分三步进行：   
      
    代码的装入、代码的校验、和代码的运行。

      
    装入代码的工作由“类装载器class loader”完毕。类装载器负责装入运   
      
    行一个程序须要的全部代码，这也包含程序代码中的类所继承的类和被调   
      
    用的类。

    当类装载器装入一个类时，该类被放在自己的名字空间中。除了   
      
    通过符号引用自己名字空间以外的类，类之间没有其它办法能够影响其它   
      
    类。在本台计算机的全部类都在同一地址空间中，而全部从外部引进的类   
      
    ，都有一个自己独立的名字空间。这使得本地类通过共享同样的名字空间   
      
    获得较高的执行效率，同一时候又保证它们与从外部引进的类不会相互影响。   
      
    当装入了执行程序须要的全部类后，解释器便可确定整个可执行程序的内   
      
    存布局。解释器为符号引用与特定的地址空间建立相应关系及查询表。

    通   
      
    过在这一阶段确定代码的内布局，java非常好地攻克了由超类改变而使子类   
      
    崩溃的问题。同一时候也防止了代码的非法訪问。   
    随后，被装入的代码由字节码校验器进行检查。校验器能够发现操作数栈   
      
    益处、非法数据类型转化等多种错误。通过校验后，代码便開始运行了。

      
    java字节码的运行有两种方式：   
    1） 即时编译方式：解释器先将字节编译成机器码，然后再运行该机器码   
    。

      
    2）解释运行方式：解释器通过每次解释并运行一小段代码来完毕java字节   
      
    码程序的全部操作。

      
      
      
      
    26. .java中输入输出流有哪些相关的类?

     [难]   
    Input和Output    
    1. stream代表的是不论什么有能力产出数据的数据源。或是不论什么有能力接收数据的接收源。在Java的IO中，全部的stream（包含Input和Out stream）都包含两种类型：    
      
    1.1 以字节为导向的stream    
    以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。

    以字节为导向的stream包含以下几种类型：    
    1) input stream：    
    1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用    
    2) StringBufferInputStream：把一个String对象作为InputStream    
    3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作    
    4) PipedInputStream：实现了pipe的概念，主要在线程中使用    
    5) SequenceInputStream：把多个InputStream合并为一个InputStream    
    2) Out stream    
    1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中    
    2) FileOutputStream：把信息存入文件里    
    3) PipedOutputStream：实现了pipe的概念，主要在线程中使用    
    4) SequenceOutputStream：把多个OutStream合并为一个OutStream    
    1.2 以Unicode字符为导向的stream    
    以Unicode字符为导向的stream。表示以Unicode字符为单位从stream中读取或往stream中写入信息。

    以Unicode字符为导向的stream包含以下几种类型：    
    1) Input Stream    
    1) CharArrayReader：与ByteArrayInputStream相应    
    2) StringReader：与StringBufferInputStream相应    
    3) FileReader：与FileInputStream相应    
    4) PipedReader：与PipedInputStream相应    
    2) Out Stream    
    1) CharArrayWrite：与ByteArrayOutputStream相应    
    2) StringWrite：无与之相应的以字节为导向的stream    
    3) FileWrite：与FileOutputStream相应    
    4) PipedWrite：与PipedOutputStream相应    
    以字符为导向的stream基本上对有与之相相应的以字节为导向的stream。两个相应类实现的功能同样，字是在操作时的导向不同。    
    如CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息。而后者每次从内存中读取一个字符。

       
    1.3 两种不现导向的stream之间的转换    
    InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。    
    2. stream加入属性    
    2.1 “为stream加入属性”的作用    
    运用上面介绍的Java中操作IO的API，我们就可完毕我们想完毕的不论什么操作了。但通过FilterInputStream和FilterOutStream的子类，我们能够为stream加入属性。以下以一个样例来说明这样的功能的作用。    
    假设我们要往一个文件里写入数据，我们能够这样操作：    
    FileOutStream fs = new FileOutStream(“test.txt”);    
    然后就能够通过产生的fs对象调用write()函数来往test.txt文件里写入数据了。可是，假设我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件里”的功能时。上面的API就没有一个能满足我们的需求了。

    可是通过FilterInputStream和FilterOutStream的子类，为FileOutStream加入我们所须要的功能。

       
    2.2 FilterInputStream的各种类型    
    2.2.1 用于封装以字节为导向的InputStream    
    1) DataInputStream：从stream中读取基本类型（int、char等）数据。

       
    2) BufferedInputStream：使用缓冲区    
    3) LineNumberInputStream：会记录input stream内的行数。然后能够调用getLineNumber()和setLineNumber(int)    
    4) PushbackInputStream：非常少用到，一般用于编译器开发    
    2.2.2 用于封装以字符为导向的InputStream    
    1) 没有与DataInputStream相应的类。

    除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream    
    2) BufferedReader：与BufferedInputStream相应    
    3) LineNumberReader：与LineNumberInputStream相应    
    4) PushBackReader：与PushbackInputStream相应    
    2.3 FilterOutStream的各种类型    
    2.2.3 用于封装以字节为导向的OutputStream    
    1) DataIOutStream：往stream中输出基本类型（int、char等）数据。    
    2) BufferedOutStream：使用缓冲区    
    3) PrintStream：产生格式化输出    
    2.2.4 用于封装以字符为导向的OutputStream    
    1) BufferedWrite：与相应    
    2) PrintWrite：与相应    
    3. RandomAccessFile    
    1) 可通过RandomAccessFile对象完毕对文件的读写操作    
    2) 在产生一个对象时，可指明要打开的文件的性质：r。仅仅读。w。仅仅写。rw可读写    
    3) 能够直接跳到文件里指定的位置    
    4. I/O应用的一个样例    
    import java.io.*;    
    public class TestIO{    
    public static void main(String[] args)    
    throws IOException{    
    //1.以行为单位从一个文件读取数据    
    BufferedReader in =    
    new BufferedReader(    
    new FileReader("F:\nepalon\TestIO.java"));    
    String s, s2 = new String();    
    while((s = in.readLine()) != null)    
    s2 += s + " ";    
    in.close();    
      
    //1b. 接收键盘的输入    
    BufferedReader stdin =    
    new BufferedReader(    
    new InputStreamReader(System.in));    
    System.out.println("Enter a line:");    
    System.out.println(stdin.readLine());    
      
    //2. 从一个String对象中读取数据    
    StringReader in2 = new StringReader(s2);    
    int c;    
    while((c = in2.read()) != -1)    
    System.out.println((char)c);    
    in2.close();    
      
    //3. 从内存取出格式化输入    
    try{    
    DataInputStream in3 =    
    new DataInputStream(    
    new ByteArrayInputStream(s2.getBytes()));    
    while(true)    
    System.out.println((char)in3.readByte());    
    }    
    catch(EOFException e){    
    System.out.println("End of stream");    
    }    
      
    //4. 输出到文件    
    try{    
    BufferedReader in4 =    
    new BufferedReader(    
    new StringReader(s2));    
    PrintWriter out1 =    
    new PrintWriter(    
    new BufferedWriter(    
    new FileWriter("F:\nepalon\ TestIO.out")));    
    int lineCount = 1;    
    while((s = in4.readLine()) != null)    
    out1.println(lineCount++ + "：" + s);    
    out1.close();    
    in4.close();    
    }    
    atch(EOFException ex){    
    System.out.println("End of stream");    
    }    
      
    //5. 数据的存储和恢复    
    try{    
    DataOutputStream out2 =    
    new DataOutputStream(    
    new BufferedOutputStream(    
    new FileOutputStream("F:\nepalon\ Data.txt")));    
    out2.writeDouble(3.1415926);    
    out2.writeChars(" Thas was pi:writeChars ");    
    out2.writeBytes("Thas was pi:writeByte ");    
    out2.close();    
    DataInputStream in5 =    
    new DataInputStream(    
    new BufferedInputStream(    
    new FileInputStream("F:\nepalon\ Data.txt")));    
    BufferedReader in5br =    
    new BufferedReader(    
    new InputStreamReader(in5));    
    System.out.println(in5.readDouble());    
    System.out.println(in5br.readLine());    
    System.out.println(in5br.readLine());    
    }    
    catch(EOFException e){    
    System.out.println("End of stream");    
    }    
      
      
    27. 构造器Constructor是否可被(覆盖)override?  [难]   
    构造器Constructor不能被继承，因此不能重写Overriding，但能够被重载Overloading。

      
      
      
    28. JAVA反射机制作用是什么?   [难]   
    能够于执行时载入、探知、使用编译期间全然未知的    
    classes。

    换句话说，Java程序能够载入一个执行时才得知名称    
    的class，获悉其完整构造（但不包含methods定义），并生成其    
    对象实体、或对其fields设值、或唤起其methods1。   
      
      
      
      
    29. web应用程序体系结构是如何的?

      [难]   
    一般分为表示层、业务层、数据存取层   
    30. .GET和POST有什么差别？   [难]   
    GET是明码传递，POST是暗码传递   
      
      
    31. HTTP协议的特点？  [中]   
    使用port发送和接受消息 。port是协议发送和接收数据的信道或机制 ，80是默认port   
    通过这样的协议传递数据server不会保存连接信息。因此又称为连接信息。

      
      
    32. 怎样通过RandomAccessFile操作文件  [难]    
    RandomAccessFile rf =    
    new RandomAccessFile("F:\nepalon\ rtest.dat", "rw");    
    for(int i=0; i<10; i++)    
    rf.writeDouble(i*1.414);    
    rf.close();    
      
    rf = new RandomAccessFile("F:\nepalon\ rtest.dat", "r");    
    for(int i=0; i<10; i++)    
    System.out.println("Value " + i + "：" + rf.readDouble());    
    rf.close();    
      
    rf = new RandomAccessFile("F:\nepalon\ rtest.dat", "rw");    
    rf.seek(5*8);    
    rf.writeDouble(47.0001);    
    rf.close();    
      
    rf = new RandomAccessFile("F:\nepalon\ rtest.dat", "r");    
    for(int i=0; i<10; i++)    
    System.out.println("Value " + i + "：" + rf.readDouble());    
    rf.close();    
    }    
    }    
      
      
    32. 静态方法有什么优点?  [难]   
      
    （1）在Java里。能够定义一个不须要创建对象的方法。这个方案就是静态方法。要实现这种效果，仅仅须要在类中定义的方法前加上statickeyword。比如：public static int maximum(int n1,int n2)   
    使用类的静态方法时，注意：   
    a）           在静态方法里仅仅能直接调用同类中其它的静态成员（包含变量和方法），而不能直接訪问类中的非静态成员。

    这是由于，对于非静态的方法和变量。须要先创建类的实例对象后才可使用。而静态方法在使用前不用创建不论什么对象。   
    b）          静态方法不能以不论什么方式引用this和superkeyword。由于静态方法在使用前不用创建不论什么实例对象。当静态方法调用时，this所引用的对象根本没有产生。   
    （2）静态变量是属于整个类的变量而不是属于某个对象的。

    注意不能把不论什么方法体内的变量声明为静态。比如：   
    fun()   
    {   
       static int i=0;//非法。   
    }   
    （3）一个类能够使用不包括在不论什么方法体中的静态代码块，当类被加载时，静态代码块被运行，且之被运行一次，静态块经常使用来运行类属性的初始化。

    比如：   
    static  
    {   
    }   
      
      
    33. Set里的元素是不能反复的。那么用什么方法来区分反复与否呢?

    是用==还是equals()?

    它们有何差别?

      [中]   
    Set里的元素是不能反复的，那么用iterator()方法来区分反复与否。

    equals()是推断两个对象是否相等。   
      
      
      
    34. JAVA中的静态方法有什么理解?   [难]   
      
    在Java里，能够定义一个不须要创建对象的方法。这个方案就是静态方法。要实现这种效果。仅仅须要在类中定义的方法前加上statickeyword。比如：public static int maximum(int n1,int n2)   
    使用类的静态方法时，注意：   
    a）           在静态方法里仅仅能直接调用同类中其它的静态成员（包含变量和方法），而不能直接訪问类中的非静态成员。这是由于，对于非静态的方法和变量，须要先创建类的实例对象后才可使用，而静态方法在使用前不用创建不论什么对象。   
    b）          静态方法不能以不论什么方式引用this和superkeyword，由于静态方法在使用前不用创建不论什么实例对象。当静态方法调用时，this所引用的对象根本没有产生。   
    （2）静态变量是属于整个类的变量而不是属于某个对象的。注意不能把不论什么方法体内的变量声明为静态。比如：   
    fun()   
    {   
       static int i=0;//非法。

      
    }   
    （3）一个类能够使用不包括在不论什么方法体中的静态代码块，当类被加载时。静态代码块被运行，且之被运行一次，静态块经常使用来运行类属性的初始化。比如：   
    static  
    {   
    }   
      
    35. JSP中动态INCLUDE与静态INCLUDE的差别？　［难］   
    动态INCLUDE用jsp:include动作实现 <jsp:include page="included.jsp" flush="true" />它总是会检查所含文件里的变化，   
    适合用于包括动态页面。而且能够带參数。

      
    静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包括静态页面<%@ include file="included.htm" %>   
      
      
    36. Java有没有goto?   
    java中的保留字，如今没有在java中使用。

      
      
    37. 启动一个线程是用run()还是start()?   [难]   
    启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可执行状态，这意味着它能够由JVM调度并执行。这并不意味着线程就会马上执行。run()方法能够产生必须退出的标志来停止一个线程。   
      
      
    38. swtich能否作用在byte上。能否作用在long上，能否作用在String上? [易]   
    switch（expr1）中，expr1是一个整数表达式。应该是 int、 short、 char byte。   
    long,string 都不能作用于swtich。

      
      
    39. try {}里有一个return语句。那么紧跟在这个try后的finally {}里的code会不会被运行。什么时候被运行，在return前还是后?  [难]   
    会运行，在return前运行。

      
      
    40. 两个对象值同样(x.equals(y) == true)，但却可有不同的hash code，这句话对不正确?   
    不正确，有同样的hash code。  [易]   
      
    41. char型变量中能不能存贮一个中文汉字?为什么?

      [难]   
    能够。由于java中以unicode编码。一个char占16个字节，所以放一个中文是没问题的   
      
    42. Java中的线程有四种状态各自是是什么？ [难]   
    执行、就绪、挂起、结束。

      
      
    43. java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们各自是哪些类？  [难]   
    字节流，字符流。   
    字节流继承于InputStream OutputStream。   
    字符流继承于InputStreamReader OutputStreamWriter。   
      
    44. 静态变量和实例变量的差别？ [中]   
    static i = 10; //常量   
    class A a;  a.i =10;//可变   
      
    45. 什么是java序列化，怎样实现java序列化？  [难]   
    序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。

    能够对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。

    序列化是为了解决在对对象流进行读写操作时所引发的问题。

      
    序列化的实现：   
    将须要被序列化的类实现Serializable接口。该接口没有须要实现的方法，implements Serializable仅仅是为了标注该对象是可被序列化   
      
    46. 能否够从一个static方法内部发出对非static方法的调用？ [难]   
    不能够,假设当中包括对象的method()；不能保证对象初始化.   
      
    47. 在JAVA中，怎样跳出当前的多重嵌套循环？ [难]   
    用break; return 方法。

      
      
    48. 面向对象的特征有哪些方面    [中]   
    1.抽象：   
    抽象就是忽略一个主题中与当前目标无关的那些方面。以便更充分地注意与当前目标有关的方面。抽象并不打算了解所有问题，而仅仅是选择当中的一部分，临时不用部分细节。抽象包含两个方面，一是过程抽象。二是数据抽象。

      
    2.继承：   
    继承是一种联结类的层次模型。而且同意和鼓舞类的重用，它提供了一种明白表述共性的方法。对象的一个新类能够从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类能够从它的基类那里继承方法和实例变量，而且类能够改动或添加新的方法使之更适合特殊的须要。   
    3.封装：   
    封装是把过程和数据包围起来。对数据的訪问仅仅能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界能够被描绘成一系列全然自治、封装的对象，这些对象通过一个受保护的接口訪问其它对象。   
    4. 多态性：   
    多态性是指同意不同类的对象对同一消息作出响应。多态性包括參数化多态性和包括多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，非常好的攻克了应用程序函数同名问题。

      
      
    49. String是最主要的数据类型吗?  [中]   
    基本数据类型包含byte、int、char、long、float、double、boolean和short。   
    java.lang.String类是final类型的。因此不能够继承这个类、不能改动这个类。

    为了提高效率节省空间，我们应该用StringBuffer类   
    50. int 和 Integer 有什么差别  [中]   
    Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每一个原始类型提供了封装类。

      
      
    51. 执行时异常与一般异常有何异同？   [ 难]   
    异常表示程序执行过程中可能出现的非正常状态。执行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见执行错误。java编译器要求方法必须声明抛出可能发生的非执行时异常，可是并不要求必须声明抛出未被捕获的执行时异常。   
      
    52. &和&&的差别。 [ 中]    
    &是位运算符，表示按位与运算，&&是逻辑运算符。表示逻辑与（and）。   
      
    53. final, finally, finalize的差别。  [中]   
    final 用于声明属性，方法和类。分别表示属性不可变，方法不可覆盖。类不可继承。   
    finally是异常处理语句结构的一部分。表示总是运行。

      
    finalize是Object类的一个方法，在垃圾收集器运行的时候会调用被回收对象的此方法，能够覆盖此方法提供垃圾收集时的其它资源回收，比如关闭文件等。   
      
      
    Jsp/servlet面试题   
    1. 四种会话跟踪技术是什么？(jsp) (中)   
    答：cookie,url重写,session,隐藏表单域。

      
    2.不同client可不能够共享Session?不能够 (易)   
    Jps和Servlet之间可不能够用session传值?

    能够   
    3.简单介绍cookie的有关知识 (中)   
    浏览器与WEBserver之间是使用HTTP协议进行通信的。当某个用户发出页面请求时，WEBserver仅仅是简单的进行响应，然后就关闭与该用户的连接。因此当一个请求发送到WEBserver时，不管其是否是第一次来訪，server都会把它当作第一次来对待。这种不好之处可想而知。为了弥补这个缺陷，Netscape 开发出了cookie这个有效的工具来保存某个用户的识别信息，因此人们昵称为“小甜饼”。cookies是一种WEBserver通过浏览器在訪问者的硬盘上存储信息的手段：Netscape Navigator使用一个名为cookies.txt本地文件保存从全部网站接收的Cookie信息；而IE浏览器把Cookie信息保存在类似于C: windowscookies的文件夹下。当用户再次訪问某个网站时，服务端将要求浏览器查找并返回先前发送的Cookie信息，来识别这个用户。   
    　　cookies给站点和用户带来的优点许多：   
    1、Cookie能使网站跟踪特定訪问者的訪问次数、最后訪问时间和訪问者进入网站的路径   
    2、Cookie能告诉在线广告商广告被点击的次数 ，从而能够更精确的投放广告   
    3、Cookie有效期限未到时，Cookie能使用户在不键入password和username的情况下进入以前浏览过的一些网站   
    4、Cookie能帮助网站统计用户个人资料以实现各种各样的个性化服务    
    JSP是使用例如以下的语法格式来创建cookie的：   
    　　Cookie cookie_name =new Cookie(""Parameter"",""Value"");   
    　　比如：Cookie newCookie =new Cookie(""username"",""zheng""); response.addCookie(newCookie);   
      
    4.在浏览器的打开时再新打开一个浏览器还是同一个session吗? (中)   
    对IE而言不是同一个SESSION   
    5.描写叙述Cookie和Session的作用。差别和各自的应用范围 (中)   
    Cookie和Session都能够用来在多个页面之间共享数据,差别是Cookie保存在client,能够设置比較长的保存时间.而Session保存在server端,通常生存时间较短。

    假设client禁用了Cookie,Cookie将无法工作。而session不受这一影响。一般来说保密性高、保存时间短的信息适合用session来存放，而Cookie适合存放须要长期保存的非敏感数据。   
      
    6.怎样实现购物车加入新项,又不使购物车中原有项目被取消?

    (易)   
    能够将购物车存放在session其中   
      
    7.Cookie的过期时间怎样设置? (易)   
    使用setMaxAge(int exp)方法   
      
    8.假设BROWSER已关闭了cookies,在JSP中我怎样打开session? (中)   
    假设Cookie被禁用。session将通过url重写的方式来传送。所以不会影响session的使用   
      
    9.include指令和include动作的差别  (中)   
        
    10. Jsp有哪些经常使用动作?

    作用各自是什么?

    (jsp)  (中)   
    答：JSP有6种经常使用基本动作 jsp:include：在页面被请求的时候引入一个文件。

       
    jsp:useBean：寻找或者实例化一个JavaBean。    
    jsp:setProperty：设置JavaBean的属性。

       
    jsp:getProperty：输出某个JavaBean的属性。    
    jsp:forward：把请求转到一个新的页面。    
    jsp:plugin：依据浏览器类型为Java插件生成OBJECT或EMBED标记。   
      
    11. "forward与redirect差别? (中)   
    Forward是在server端进行分发,分发后地址栏无变化,用户看不到分发后的地址.而redirect是在client进行的页面重定向,地址栏上会显示重定向后的网页.forward的页面仅仅能是在同一个web应用程序之内,而重定向能够定位到外部资源.forward后还是同一个request请求,而重定向后曾经的request请求就不存在了.   
      
    12.Jsp和Servlet中的请求转发分别怎样实现?

    (易)   
    Jsp中使用<jsp:forward>动作,servlet中使用RequestDistpatcher对象的forward方法"   
      
    13.什么是web容器？(易)   
    答：给处于当中的应用程序组件（JSP。SERVLET）提供一个环境，使JSP,SERVLET直接更容器中的环境变量接口交互，不必关注其他系统问题。主要有WEBserver来实现。比如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEBserver就叫做J2EE中的WEB容器。   
      
    14.应用server有那些？ (中)   
    答：BEA WebLogic Server。IBM WebSphere Application Server。Oracle9i Application Server，JBoss，Tomcat。"   
      
    15.请说出JSP的内置对象及方法 (中)   
    答：request表示HttpServletRequest对象。它包括了有关浏览器请求的信息。而且提供了几个用于获取cookie,    
    header, 和session数据的实用的方法。

      
        response表示HttpServletResponse对象，并提供了几个用于设置送回    
    浏览器的响应的方法（如cookies,头信息等）   
        out对象是javax.jsp.JspWriter的一个实例。并提供了几个方法使你能用于向浏览器回送输出结果。   
        pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，而且包装了通用的servlet相关功能的方法。   
        session表示一个请求的javax.servlet.http.HttpSession对象。

    Session能够存贮用户的状态信息   
        applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息   
        config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化參数。   
    page表示从该页面产生的一个servlet实例。   
      
    16.使用JSP怎样获得客户浏览器的信息?  (易)   
    request对象的getXXXX方法"   
      
    17.B/S与C/S的联系与差别。  (中)   
    答：C/S是Client/Server的缩写。

    server通常採用高性能的PC、工作站或小型机，并採用大型数据库系统。如Oracle、Sybase、Informix或    
    SQL Server。client须要安装专用的client软件。   
    B/Ｓ是Brower/Server的缩写，客户机上仅仅要安装一个浏览器（Browser），如Netscape    
    Navigator或Internet Explorer，server安装Oracle、Sybase、Informix或 SQL    
    Server等数据库。在这样的结构下。用户界面全然通过WWW浏览器实现，一部分事务逻辑在前端实现。可是主要事务逻辑在server端实现。浏览器通过Ｗeb    
    Server 同数据库进行数据交互。

      
    C/S 与 B/S 差别：   
    １）．硬件环境不同:   
    　　C/S 一般建立在专用的网络上, 小范围里的网络环境,    
    局域网之间再通过专门server提供连接和数据交换服务.   
    　　B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备.    
    信息自己管理. 有比C/S更强的适应范围, 一般仅仅要有操作系统和浏览器即可   
    ２）．对安全要求不同   
    　　C/S 一般面向相对固定的用户群, 对信息安全的控制能力非常强.    
    一般高度机密的信息系统採用C/S 结构适宜. 能够通过B/S公布部分可公开信息.   
    　　B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。   
    ３）．对程序架构不同   
    　　C/S 程序能够更加注重流程, 能够对权限多层次校验,    
    对系统执行速度能够较少考虑.   
    　　B/S 对安全以及訪问速度的多重的考虑, 建立在须要更加优化的基础之上.    
    比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk    
    2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean    
    构件技术等,使 B/S更加成熟.   
    ４）．软件重用不同   
    　　C/S 程序能够不可避免的总体性考虑,    
    构件的</ div <>   
      
         
      <DIV class=attachments>   
           
             
            <UL>   
              <LI><A href="http://dl.iteye.com/topics/download/4bb5d3ac-5b81-3821-8979-95a9e6af97e8">打印.rar</A> (98.7 KB)   
              <LI>描写叙述: SSH面试题   
              <LI>下载次数: 4  
            </LI></UL>   
             
           
           
      </DIV>   
      
      
      
      <SCRIPT type=text/javascript><!--   
    google_ad_client = "pub-1076724771190722";   
    /* JE个人博客468x60 */  
    google_ad_slot = "5506163105";   
    google_ad_width = 468;   
    google_ad_height = 60;   
    //-->   
    </SCRIPT>   
    <SCRIPT type=text/javascript src="http://pagead2.googlesyndication.com/pagead/show_ads.js">   
    </SCRIPT><SCRIPT src="http://pagead2.googlesyndication.com/pagead/js/r20110713/r20110719/show_ads_impl.js"></SCRIPT><SCRIPT src="http://googleads.g.doubleclick.net/pagead/test_domain.js"></SCRIPT><SCRIPT src="http://pagead2.googlesyndication.com/pagead/render_ads.js"></SCRIPT><SCRIPT>google_protectAndRun("render_ads.js::google_render_ad", google_handleError, google_render_ad);</SCRIPT><IFRAME id=google_ads_frame1 height=60 marginHeight=0 src="http://googleads.g.doubleclick.net/pagead/ads?client=ca-pub-1076724771190722&output=html&h=60&slotname=5506163105&w=468&lmt=1311752896&ea=0&flash=10.3.181.34&url=http%3A%2F%2Fzhengyunfei.iteye.com%2Fblog%2F1078170&dt=1311752896437&shv=r20110713&jsv=r20110719&saldr=1&correlator=1311752896562&frm=4&adk=2365030428&ga_vid=861167297.1311752897&ga_sid=1311752897&ga_hid=1115300874&ga_fc=0&u_tz=480&u_his=0&u_java=1&u_h=900&u_w=1600&u_ah=876&u_aw=1600&u_cd=32&u_nplug=0&u_nmime=0&biw=1584&bih=726&ref=http%3A%2F%2Fwww.iteye.com%2Fblogs%2Ftag%2F%25E9%259D%25A2%25E8%25AF%2595%3Fpage%3D7&fu=0&ifi=1&dtd=156" frameBorder=0 width=468 allowTransparency name=google_ads_frame1 marginWidth=0 scrolling=no></IFRAME>   
         
      <DIV id=bottoms class=clearfix> <DIV id=digg_bottom class=clearfix><A onclick='digg("blogs", 1078170, false);return false;' href="#"><DIV><STRONG>1</STRONG> <BR>顶</DIV></A><A onclick='digg("blogs", 1078170, true);return false;' href="#"><DIV><STRONG>2</STRONG> <BR>踩</DIV></A></DIV> <DIV id=share_weibo>分享到：<A title=分享到新浪微博 href="javascript:;" data-type="sina"><IMG src="/images/t_sina.gif"></A>   
          <A title=分享到腾讯微博 href="javascript:;" data-type="qq"><IMG src="/images/t_qq.gif"></A>   
        </DIV>   
      </DIV>   
      
      <DIV class=blog_nav>   
        <DIV class=pre_next> <A class=next title=oracle批量更新 href="/blog/1106941">oracle批量更新</A> | <A class=pre title="java 面试题整理2" href="/blog/1072284">java 面试题整理2</A> </DIV>   
      </DIV>   
      <DIV class=blog_bottom>   
        <UL>   
          <LI>23:19  
          </LI><LI><A href="#comments">评论</A> / 浏览 (0 / 166)</LI><LI><A class=favorite onclick="$$('.favorite_form_spinner')[0].show();new Ajax.Request('http://zhengyunfei.iteye.com/links/new_xhr?user_favorite%5Btitle%5D=SSH%E9%9D%A2%E8%AF%95%E9%A2%98%E6%95%B4%E7%90%86&user_favorite%5Burl%5D=http%3A%2F%2Fzhengyunfei.iteye.com%2Fblog%2F1078170', {method: 'get', onSuccess: function(response){$(document.getElementsByTagName('body')[0]).insert({bottom:response.responseText});$$('.favorite_form_spinner')[0].hide();}});return false;" href="http://app.iteye.com/links?

    user_favorite%5Btitle%5D=SSH%E9%9D%A2%E8%AF%95%E9%A2%98%E6%95%B4%E7%90%86&user_favorite%5Burl%5D=http%3A%2F%2Fzhengyunfei.iteye.com%2Fblog%2F1078170" target=_blank>收藏</A><IMG style="DISPLAY: none; MARGIN-LEFT: 7px; VERTICAL-ALIGN: bottom" class=favorite_form_spinner alt=Spinner src="http://www.iteye.com/images/spinner.gif?

    1308833136"> </LI><LI>分类:<A href="http://www.iteye.com/blogs/category/language">编程语言</A> </LI><LI class=last><A class=more href="http://www.iteye.com/wiki/blog/1078170" target=_blank>相关推荐</A> </LI></UL>   
      </DIV>   
      
      <DIV class=blog_comment> <H5>评论</H5> <A id=comments name=comments></A> </DIV>   
      
      <DIV class=blog_comment> <H5>发表评论</H5> <FORM id=comment_form onsubmit="return false;" method=post action=/blog/1078170> <INPUT id=editor_bbcode_flag value=true type=hidden> <DIV id=editor_main><DIV id=editor_wrapper class=clearfix><DIV id=bbcode_emotions><H5>表情图标</H5><IMG src="http://www.iteye.com/images/smiles/icon_biggrin.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_smile.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_sad.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_surprised.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_eek.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_confused.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_cool.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_lol.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_mad.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_razz.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_redface.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_cry.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_evil.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_twisted.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_rolleyes.gif" width=19 height=19><IMG src="http://www.iteye.com/images/smiles/icon_wink.gif" width=19

  • 相关阅读:
    源代码的下载与编译
    Git使用入门
    搭建Android开发环境
    Android系统移植与驱动开发
    Android探索与驱动开发学与思（10）
    Android探索与驱动开发学与思（9）
    Android探索与驱动开发学与思（8）
    第七章
    第六章
    第五章
  • 原文地址：https://www.cnblogs.com/tlnshuju/p/6815830.html
Copyright © 2011-2022 走看看