java面试
来源：互联网 发布：sublime 知乎 编辑：程序博客网 时间：2024/04/30 18:12
答：面向对象的特征主要有以下几个方面：
1）抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象包括两个方面，一是过程抽象，二是数据抽象。
2）继承：继承是一种连接类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3）封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4）多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了界面的简陋问题。
5）对网络的依赖较大
web的常用开发技术jsp，asp.net,PHP
2)JSP:java在网络中的应用 开源 跨平台（服务器的那一端可以跨平台），功能强大（在手机，超市，医院） 框架支持好（有利于块速开发）， 灵活（环境自己配）应用程序函数同名。
ASP.NET：非开源 跨平台不如JSP功能强大，框架支持较好 不灵活 速成开发
2.作用域public，private，protected，以及不写时的区别？
答：区别如下：
作用域 当前类 同包 子孙类 其他
public √ √ √ √
protected√ √ × ×
private √ × × ×
不写时默认为：default。
3.short s1=1;s1=s1+1;有什么错？
short s1=1;s1=s1+1;s1+1运算结果是int型，需要强制转换类型；
PHP：免费 开源 框架支持较少 灵活 MySQL数据库结合使用
short s1=1;s1+=1;可以正确编译，自动类型提升。
4.Java没有goto
5.web开发的特点（B/s）
a）B/S对客户端要求低有利于项目的升级的维护
b）最多是浏览升级，服务端更新，对于客户端根本不需要升级，web项目可以跨平台
依赖于网络的速度
c）界面不友好。html+js+css辅服务端技术，但是exUS Flex解决了界面简陋
goto是java中的保留字，现在没有在java中使用。
5.int和Integer有什么区别？
java提供两种不同的类型：引用类型和原始类型（或内置类型）；
int是java的原始数据类型，Integer是java为int提供的封装类。
java为每个原始类型提供了封装类：
原始类型：Boolean，char，byte，short，int，long，float，double
封装类型：Boolean，character，byte，short，Integer，long，float，double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。这种类型以哪种类型的数据结构存储，当引用类型和原始类型型用作某个类的实例数据时所指定的
3.创建一个web项目，获取用户登录的信息
a）访问地址//先启动Tomcat
b）Http 404路径错误
c）Internet explorer无法显示，没启动
4.int和Integer有什么区别？
java提供两种不同的类型：引用类型和原始类型（内置类型）；
int是java的原始数据类型，Integer是java为Integer提供的封装类。
java为每个原始类型提供了封装类：
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为null，而原始类型实例变量的缺省值与他们的类型有关。
5.&和&&的区别？
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与
区别主要有两点：a.条件操作只能操作布尔型的，而逻辑操作不仅可以操作布尔型，而且可以操作数值型b.逻辑操作不会产生短路。
6.heap和stack有什么区别？
栈是一种线性集合，其添加和删除的操作应在同一段完成，栈按照后进先出的方式进行处理；堆是栈的一个组成元素。
7.swith是否能作用在byte上，是否能作用在long上，是否能作用在String上？
swith（expr1）中，expr1是一个整数表达式。因此传递给swith和case语句的参数应该是int、short、char或者byte。long，String都不能作用于swith。
8.有没有length（）这个方法？String有没有length（）这个方法？
数组中没有length（）这个方法，有length的属性。String有length（）这个方法。
9.在java中，如何跳出当前的多重嵌套循环？
在最外层循环前加label标示，然后用break：label方法即可跳出多重循环。
10.构造器Constructor是否可被override？
构造器Constructor不能别继承，因此不能重写Overriding，但是可以被重载Overloading.
11.两个对象值相同（x.equals(y)==true），但却可有不同的hash code，这句话对不对？
不对，有相同的hash code。
12.是否可以继承String类？
String类是final类，故不可以继承。
13.以下二条语句返回值为true的有：
A：“beijing”==“beijing”；
B：“beijing”.equalsIgnoreCase(new String("beijing"));
14.当一个对象被当做参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？
是值传递。java编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
15.Overload和Override的区别。overLoaded的方法是否可以改变返回值的类型？
方法的重写override和重载overloading是java多态性的不同表现。重写overriding是父类与子类之间多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写（Overriding）。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载（Overloading）。OverLoaded的方法是可以改变返回值的类型。
16.描述一个JVM加载class文件的原理机制？
JVM中类的装载是由ClassLoader和它的子类来实现的，Java ClassLoader是一个重要的java运行时系统组件。他负责在运行时查找和装入类文件的类。
17.char型变量中能不能存贮一个中文汉字？为什么？
能定义成为一个中文的，因为java中以Unicode编码，一个char占16个字节，所以放一个中文是没问题的。
18.声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract类的实例。不能有抽象构造函数或抽象静态方法。abstract类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。新型多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，所有成员变量都是public static final的。一个类可以实现多个接口，当类实现特殊接口时，它定义所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。
通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof运算符可以用来决定某对象的类是否实现了接口。
19.static nested class和inner class的不同？
static nested class是被声明为静态（static）的内部类，它可以不依赖外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。
20.是否可以从一个static方法内部发出对非static方法的调用？
不可以，如果包含对象的method（），不能保证对象初始化。
21.java中会存在内存泄露吗，请简单描述。
会，存在无用但可达的对象，这些对象不被GC回收，导致耗费内存资源。system.gc()或runtime.gc()
22.abstract的method是否可同时是static，是否同时是native，是否可同时是synchronized？
都不能。
23.静态变量和实例变量的区别？
静态变量也称为类变量，归全类共有，它不依赖于某个对象，可通过类名直接访问；而实例变量依存于某一实例，只能通过对象才能访问到它。
24.是否可以从一个static方法内部发出对非static方法的调用？
不可以，如果其中包含对象的method（），不能保证对象初始化。
25.写clone（）方法时，通常都有一行代码，是什么？
clone有缺省行为：super.clone(),他负责产生正确大小的空间，并逐位复制。
26.垃圾回收的优点和原理。并考虑2种回收机制。
java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，java中的对象不再有“作用域”的概念，只用对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收期对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
27.String s=new String("xyz");创建了几个String Object？
两个对象，一个是“xyz”，一个是指向“xyz”的引用对象s
28.接口是否可以继承接口？抽象类是否可以实现接口？抽象类是否可继承实体类
接口可以继承接口。抽象类可以实现接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。
29.java的接口和C++的虚类的相同和不同处。
由于java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static，所有方法默认情况下是public，一个类可以实现多个接口。
30.一个“.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？
可以，必须只有一个类名与文件名相同。
31.Anonymous inner class（匿名内部类）是否可以extends其他类？是否可以implements interface？
可以继承其他类或实现其他接口，在swing编程中常用此方式。
32.内部类可以引用它包含类的成员吗？有没有什么限制？
一个内部类对象可以访问创建它的外部类对象的内容。
33.java中实现多态的机制是什么？
方法的覆盖overriding和overloading是java多态性的不同表现；覆盖overriding是父类与子类之间多态性的一种表现，重载overloading是一个类中多态性的一种表现。
34.在java中一个类被声明为final类型，表示了什么意思？
表示该类不能被继承，是顶级类。
35.下面哪些类可以被继承？
java.lang.Thread(T)
java.lang.Number(T)
java.lang.Double(F)
java.lang.Math(F)
java.lang.void(F)
java.lang.Class(F)
java.lang.ClassLoader(T)
36.类的static代码段，可以看作是类首次加载执行的代码，而对于类加载，首先要执行其基类的构造，再执行其本身的构造。
37.数值型字符转换为数字：调用数值类型相应包装类中的方法parse***（String）或valueOf（String）即可返回相应基本类型或包装类型数值；
数字转换为字符：①数字与空字符串相加即可或得其所对应的字符串②基本类型数字调用String类中的valueOf（...）方法返回相应字符串③对于包装类类型数字则可调用其toString（）方法获得相应字符串。
如何取小数点前两位并四舍五入？
可用该数字构造一java.math.BigDecimal对象，再利用其round()方法进行四舍五入到保留小数点后两位，再将其转换为字符串截取后两位。
38.日期和时间：
如何取得年月日，小时分秒？
创建java.util.Calendar实例（Calendar.getInstance()），调用其get（）方法传入不同的参数即可获得参数所对应的值，如：
calendar.get(Calendar.YEAR);//获得年
2）如何取得从1970年到现在的毫秒数，以下方法均可获得该毫秒数：
Calendar.getInstance().getTimeInMillis();
System.currentTimeMillis();
3）如何取得某个日期是当月的最后一天？
Calendar time=Calendar.getInstance();
time.set(Calendar.DAY_OF_MONTH,time.getActualMaximum(Calendar.DAY_OF_MONTH));
4)如何格式化日期？
利用java.text.DataFormat类中的format()方法可将日期格式化。
39.java和JavaScript的区别。
javaScript和java是两个公司开发的不同的两个产品。java是SUN公司推出的新一代面向对象的程序设计语言，特别适合于Internet应用程序开发；而JavaScript是Netscape公司的产品，其目的是为了扩展Netscape Navigator功能，而开发的一种可以嵌入web页面的机遇对象和事件驱动的解释性语言，它的前身是Live Script；而java的前身是oak语言。
①java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；
JavaScript是种脚本语言，他可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（Object Based）和事件驱动（Event driver）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用
②java的源代码在执行之前，必须经过编译；
javaScript是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行；
③强类型变量和类型弱变量：
java采用强类型变量检查，即所有变量在编译之前必须作声明；
javaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检查其数据类型
④代码格式不一样。
40.当java程序违反了java的语义规则时，java虚拟机就会将发生的错误表示为一个异常。违反语义包括2种情况。一种是java类库内置的语义检查。例如数组下标越界，会引发IndexOutOfBoundsException；访问null的对象时会引发NullPointerException。另一种就是java允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。
41.error和exception有什么区别？
error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；
exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。
42.try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return钱还是后？
会执行，在return前执行。
43.java语言如何进行异常处理，关键字：throws，throw，try，catch，finally分别代表什么意义？在try块中可以抛出异常吗？
java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在java中，每个异常都是一个对象，它是throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。如果出现异常，系统会抛出（thows）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理；try用来指定一块预防所有“异常”的程序；catch子句紧跟在try块后面，用来指定你想要捕获的“异常”的类型；throws语句用来表明一个成员函数可能抛出的各种异常；throw语句用来明确地抛出一个“异常”；finally为确保一段代码不管发生什么“异常”都被执行一段代码。
可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try语句。
44.运行时异常与一般异常有何异同？
异常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
45.UML是标准建模语言；常用图包括：用例图，静态图（类图，对象图和包图），行为图、交互图（顺序图，合作图），实现图。
46.软件开发中迭代的含义的理解：
软件开发中，各个开发阶段不是顺序执行的，应该是并行执行，也就是迭代的意思。这样对于开发中的需求变化，及人员变动都能得到更好的适应。
47.XML文档定义有几种形式？他们之间有何本质区别？解析XML文档有哪几种？
1）两种形式：dtd以及schema；
2)本质区别：schema本身是XML的，可以被XML解析器解析
DOM：处理大型文件时性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存，适合对XML的随机访问；
SAX：不同于DOM，SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问；
STAX：Streaming API for XML
48.你在项目中用到了xml技术的哪些方面？如何实现的？
用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩包加密后通过网络传送给接受者，接受解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存储在XML文件中。
49.数据库，比如100用户同时来访，要采取什么技术解决？
可采用连接池。
50.什么是ORM(object relation mapping)对象关系映射是一种为了解决面向对象与面向关系数据库存在的互不匹配的现象的技术；简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中；本质上就是将数据从一种形式转换到另外一种形式。
51.什么是Hibernate框架
Hibernate是一款ORM框架.用于将数据映射成java对象.Hibernate是对JDBC的一个轻量级封装,用于简化数据库访问.为应用程序构建一个持久层.
52.五个核心接口
configuration接口:配置Hibernate,负责加载hibernate.cfg.xml配置文件,根据其启动hibernate,创建SessionFactory对象;
SessionFactory接口:会话工厂对象,初始化Hibernate,充当数据存储源的代理,负责创建Session对象,SessionFactory是线程安全的,意味着它的同一个实例可以被应用的多个线程共享,是重量级、二级缓存；
Session接口：数据库操作对象，负责对数据库一些增删改查方法。是线程不安全的，避免多个线程共享同一个session。是轻量级、一级缓存；
Transaction：事务管理对象，负责管理事物操作。与JDBC不同，在使用Hibernate进行增删改时，需要显式使用对象commit
Query：查询对象：负责执行HQL面向对象查询语言。
一对多的标签为<one-to-many>;多对多的标签为<many-t0-many>;
sessionFactory的缓存为hibernate的二级缓存；默认关闭。不同session对象可以共享缓存空间的数据对象
Hibernate的事务实际上是底层的JDBC Transaction的封装或者是JTA Transaction的封装：默认情况下使用JDBCTransaction.
53.Hibernate的应用的结构？
①获得SessionFactory的对象
SessionFactory sessionFactory=new Configuration().configure().buildSessionFactory();
②获得session的对象
Session session=sessionFactory.openSession();
③其次获得Transaction的对象
Transaction tx=session.beginTransaction();
④执行相关的数据库操作：增删改查
session.save(user);//增加
session.delete(user);//删除
session.update(user);//更新
Query query=session.createQuery("from User");//查询
List list=query.list();
//提交事务
tx.commit();
//如果有异常，我们还要坐事物的回滚，恢复到操作之前
tx.rollback();
//最后还要关闭session，释放资源
session.close();
54.什么是重量级？什么是轻量级？
轻量级是指它的创建和销毁不需要消耗太多的资源，意味着可以在程序中经常创建和销毁session对象；
重量级意味不能随意的创建和销毁它的实例，会占用很多的资源。
55.数据库的连接字符串？
MS SQL Server
jdbc.sqlserver.SQLServerDriver”). newInstance(); conn = DriverManager.getConnection(“jdbc:Microsoft:sqlserver ://localhost:1433;DatabaseName=pubs”,”sa”,””);
//Oracle Class.forName(“oracle.jdbc.driver.OracleDriver”).newInstance(); conn = DriverManager.getConnection(“jdbc:oracle:thin: @localhost:1521:sid”, uid, pwd);
//Mysql Class.forName(“org.git.mm.mysql.Driver”).newInstance(); conn = DriverManager.getConnection(“jdbc:mysql ://localhost:3306/pubs”,”root”,””); 处理中文的问题: jdbc:mysql://localhost:3306/pubs?useUnicode=true &characterEncoding=GB2312
56.事务处理？
Connection类中提供了3个事务处理方法：setAutoCommit(Boolean autoCommit):设置是否自动提交事务，默认为自动提交事务，即为true，通过设置false禁止自动提交事务；
commit();提交事务rollback():回滚事务。
57.Java中访问数据库的步骤？Statement和PreparedStatement之间的区别？
Java中访问数据库的步骤如下：
①注册驱动；②建立连接；③创建Statement；④执行sql语句；⑤处理结果集（若sql语句查询语句）；⑥关闭连接。PreparedStatement被创建时即指定了SQL语句，通常用于执行多次结构相同的SQL语句。
58.Hibernate的分页：
Query query=session.createQuery("from Student");
query.setFirstResult(firstResult);//设置每页开始的记录号
query.setMaxResults(resultNumber);//设置每页显示的记录数
Collection students=query.list();
59.JDBC的分页：根据不同的数据库采用不同的sql分页语句
例如：oracle中的sql语句为：select * from (select a.*,rownum r from tb_student) where r between 2 and 10 查询从记录号2到记录号10之间的所有记录
60.jsp中动态include与静态include的区别？
动态include用jsp:include动作实现<jsp:include page="included.jsp" flush="true"/>它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数；静态include用include伪码实现，它不会检查所含文件的变化，适用于包含静态页面<%@include file="included.htm"%>
61.说出数据连接池的工作机制是什么？
J2ee服务器启动时会建立一定数量的池连接，并一直维护不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其标记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池连接将此连接标记为空闲，其他调用就可以使用这个连接。
62.JSP的内置对象及方法？
request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，包含来自GET、POST请求的参数；并且提供了几个用于获取cookie，header和session数据的有用的方法。
response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies，头信息等）。
out对象是javax.jsp.JspWriter的实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关对象的API，并且包装了通用的servlet相关功能的方法。网页的属性是在这里管理
session表示一个请求的javax.servlet.htto.HttpSession对象。Session可以存贮用户的状态信息。与请求有关的会话期；
application表示一个javax.servlet.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息。
config表示javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page表示从该页面产生的一个servlet实例。JSP网页本身
exception：针对错误网页，未捕捉的例外
63.get和post的区别？
form中的get和post方法，在数据传输过程中分别对应了HTTP协议中的GET和POST方法，二者主要区别如下：
1）Get是用来从服务器上获得数据，而Post是用来向服务器上传递数据；
2）Get将表单中数据按照variable=value的形式，添加到action所指向的URL后面，并且两者使用？连接，而各个变量之间使用“&”连接；Post是将表单中的数据放在form的数据体中，按照变量和值对应的方式，传递到action所指向URL；
3）Get是不安全的，因为在传输过程，数据被放在请求的URL中；post的所有操作对用户来说都是不可见的；
4）Get传输的数据量小，这主要是因为受URL长度限制；而Post可以传输大量的数据，所以在上传文件只能使用Post。
5）Get限制Form表单的数据集必须为ASCII字符，而Post支持整个ISO10646字符集；
6）Get是Form的默认方法。
64.页面中有一个命名为bank No的下拉列表，写脚本获取当前选项的索引值。
java request.getRarameter("bank No")
javaScript: var selectItems=document.getElementByName("bank No");
selectItems[0].value;
65javascript常用的方面：
常用于数据输入校验和页面特殊效果等。
66常用的web容器开发工具；
最常用的容器包括：tomcat，weblogic；
开发工具：Eclipse jbuilder
67.web application的基本目录结构
webapps
|
application
|
---------------------------
| |
jsp页面 web-INF
|
--------------------
| | |
classes lib web.xml
68.JSP和servlet有哪些相同点和不同点，他们之间的联系是什么？
JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强烈应用的外表表达。JSP编译后是：类servlet。最重要的不同点在于，
servlet的应用逻辑是在java文件中，并且完全从表示层的HTML里分离开来。而JSP的情况是java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。
69.jsp的四种范围？
a.page是代表与一个页面相关的对象和属性。一个页面由一个编译好java servlet类（可以带有任何的include指令，但是没有include动作）表示。这既包括servlet又包括被编译成servlet的jsp页面
b.request是代表与web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个web组件（由于forward指令和include动作的关系）
c.session是代表与用于某个web客户机的一个用户体验相关的对象和属性。一个web会话可以也经常会跨越多个客户机请求
d.appliacation是代表与整个web应用程序相关的对象和属性。这实质上是跨越整个web应用程序，包括多个页面、请求和会话的一个全局作用域。
70.如何实现servlet的单线程模式？
<%page isThreadSafe="false"%>
71.页面间对象传递的方法。
request，session，application，cookies等。
72.详细描述MVC。
基于java的web应用系统采用mvc架构模式，即model、view、control分离设计；这是目前web应用服务系统的主流设计方向。
model：即处理业务逻辑的模块，每一种处理一个模块；
view：负责页面显示，显示model处理结果给用户，主要实现数据到页面转换过程；
control：负责每个请求的分发，把form数据传递给model处理，把处理结果的数据传递给view显示。
73.MVC的各个部分都有哪些技术来实现？如何实现？
MVC是Model-view-controller的简写。“model”代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），“view”是应用的表示面（由JSP页面产生），“controller”
是提供应用的处理过程控制（一般是一个servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
74.serlet执行时一般实现哪几个方法？
public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request,ServletResponse response)
public void destroy()
75.hashMap和Hashtable的区别？
二者都实现了Map接口，是将唯一键映射到特定的值上；主要区别在于:
1)HashMap 没有排序，允许一个NULL键和多个Null值，而hashtable不允许；
2）HashMap把Hashtable的contains方法去掉了，改为containsvalue和containsKey，因为contains方法容易让人引起误解；
3）Hashtable继承自Dictionary类，HashMap是java1.2引进的Map接口的实现；
4）Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供同步。
Hashtable和HashMap采用hash/rehash算法大致一样，所以性能不会有很大的差异
76.String和StringBuffer的区别？
它们可以存储和操作字符串，即包含多个字符的字符数据。这个String类提供了树枝不可改变的字符串。而这个stringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候，就建议使用StringBuffer。典型地，你可以使用StringBuffer来动态构造字符数据。
77.一般常用格式化类DateFormat和SimpleDateFormat的format(Date time)方法进行格式化日期.
78.jsp常用的指令：<%@page %>
page指令：language extends import session autoFlush buffer isTreadSafe isErrorPage errorPage contentType(text/thml) info trimDirective Whitespaces
include指令：<%@include file="relativeURL"%>
jsp指令：<jsp:include page="head.jsp" flush="true">
<jsp:useBean id="java Bean 对象名" class=“类的全名” scope="[page|session]">
<jsp:plugin>
<jsp:forward page="/" >
<jsp:param name="" value="">
<jsp:direcctive>
jsp 隐藏对象：out、out.println(strb);
request：request.setCharacterEncoding("GBK"); 设置编码格式
request.getParameter("c_sname")返回提交参数
request.getMethod() == "GET"返回提交方式
request.getRealPath("/freecomp/"+mod)
response：response.sendRedirect("/do/login.html");从本页面跳到另一个页面
config
seesion：session.getAttribute("name")返回session中属性名为name的对象
session.removeAttribute("errpass")删除属性
session.setAttribute("uid",uid+"");设置属性
application、page、pageContext、exception
jstl标签：core 1、<c:out>
2、 <c:if test="">
<3、c:choose>
<c:when>
</c:when>
<c:otherwise>
</c:othserwise>
</c:choose>
4、<c:foreach var="num" begin="2" end="100" step="2">
${num}
</c:foreach>
5、<c:forTokens>
6、可以写的标签：<c:set/>
7 <c:url>
8 <c:redirect>
9<c:param>
79、Struts标签OGNL：object-Graph Navigation Language #声明是OGNL
<s:iterator value="dp" var="b">
<s:property value="#b1.pro.product_name"/>
</s:iterator>
80、
<s:iterator>
<s:if test="cid==#c1.id">
</s:if>
<s:else>
</s:else>
</s:iterator>
81、关于oracle的：
常用的函数有：substr(),Instr();
NVL(to_char(manager_id),'BOSS')
大小写转换：lower('SQL Course')
最大值： max(commission_pct)
平均工资：avg(salary)
最小值：min(salary)
统计：count(*)
本月最后一天：last_day(sysdate)
四舍五人：月初的基础上加1：trunc(sysdate,'MONTH')+1 round(c1)
add_months(trunc(sysdate,'MONTH'),1) 已月为基础加1
日期操作：
round、trunc、last_day
1、获得上月的最后一天：
select to_char(add_months(last_day(sysdate),-1),'yyyy-MM-dd') LastDay fromdual;
2、上个月的今天(同日期)
select to_char(add_months(sysdate,-1),'yyyy-MM-dd') PreToday from dual;
3、上个月的第一天
select to_char(add_months(last_day(sysdate)+1,-2),'yyyy-MM-dd') First_Day_Last_Month from dual;
SELECT Trunc(Trunc(SYSDATE, 'MONTH') - 1, 'MONTH')First_Day_Last_Month FROM dual;
4、获得日期对应的星期几
select to_char(to_date('2013-04-07','yyyy-mm-dd'),'day') from dual;
5、从当前日期到某一个日期的天数
select floor(sysdate -to_date('20130405','yyyymmdd')) from dual;
6、找出今年的天数
selectadd_months(trunc(sysdate,'year'), 12) - trunc(sysdate,'year') from dual
看今年是366天，还是365天。
7、简单的找出闰年
如果2月份的天数是28天，那么就不是闰年
select decode(to_char(last_day(to_date('200902','yyyymm') ),'dd'),'28','不是闰年','闰年' )from dual
8、当前日期是本年的第几天
selectto_char(sysdate,'ddd'),sysdate from dual;
9、查找上月的第一天和最后一刻，本月的第一天和最后一刻
SELECT Trunc(Trunc(SYSDATE,'MONTH') - 1, 'MONTH') First_Day_Last_Month,
Trunc(SYSDATE, 'MONTH') - 1 /86400 Last_Day_Last_Month,
Trunc(SYSDATE, 'MONTH')First_Day_Cur_Month,
LAST_DAY(Trunc(SYSDATE,'MONTH')) + 1 - 1 / 86400 Last_Day_Cur_Month
FROM dual;
82、spring框架的作用
主要用于整合，可以整合struts,hibenate等框架，
可以降低组件之间的关联提高程序灵活性，可扩展性，
主要是依靠spring框架提供的一个容器，可以管理程序中的具有IOC AOP特性
为什么struts中加入spring：
工程主要是用spring管理beans，还会使用spring的AOP，事务。struts试试web的应用框架，而spring是一个粘合平台，它能把struts和hibernate/ibatis很好的组织在一起
83、
1、 延迟加载延迟加载（load）是Hibernate为提高程序执行效率而提供的一种机制，即只有真正使用该对象的数据时才会创建。
2、抓取策略
3、缓冲机制
84、oracle 的索引存放在：user_indexes,user_ind_columns，user_constrains,user_cons_columns
查询出用户所有表的索引
select * from user_indexes
83.jdbc中PreparedStatement相比statement的好处
一个sql命令发给服务器去执行的步骤为：语法检查、语义分析、编译成内部命令，缓冲命令、执行命令等
select * from student where id=3--缓冲xxx二进制命令
select * from student where id=3--直接取xxx二进制命令
select * from student where id-4--会怎么干？
可以防止sql注入
84. 大数据量的插入：
String sql = "insert into table *****";con.setAutoCommit(false);ps = con.prepareStatement(sql);for(int i=1; i<65536; i++){ ps.addBatch(); // 1w条记录插入一次 if (i % 10000 == 0){ ps.executeBatch(); con.commit(); }}// 最后插入不足1w条的数据ps.executeBatch();con.commit();1. 返回值的区别,函数有1个返回值,而存储过程是通过参数返回的,可以有多个或者没有2.调用的区别,函数可以在查询语句中直接调用,而存储过程必须单独调用.函数一般情况下是用来计算并返回一个计算结果而存储过程一般是用来完成特定的数据操作（比如修改、插入数据库表或执行某些DDL语句等等）
86、spring事务管理
Spring+Hibernate的实质：
就是把Hibernate用到的数据源Datasource，Hibernate的SessionFactory实例，事务管理器HibernateTransactionManager，都交给Spring管理。
那么再没整合之前Hibernate是如何实现事务管理的呢？
通过ServletFilter实现数据库事务的管理，这样就避免了在数据库操作中每次都要进行数据库事务处理。
一.事务的4个特性：
原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。
一致性：数据不会因为事务的执行而遭到破坏。
隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。
持久性：一个事务一旦提交，它对数据库的改变将是永久的。
二.事务的实现方式：
实现方式共有两种：编码方式；声明式事务管理方式。
基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。
声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。
三.创建事务的时机：
是否需要创建事务，是由事务传播行为控制的。读数据不需要或只为其指定只读事务，而数据的插入，修改，删除就需要事务管理了。
一种常见的事务管理配置：事务拦截器TransactionInterceptor和事务自动代理BeanNameAutoProxyCreator相结合的方式
<!--定义Hibernate的事务管理器HibernateTransactionManager -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 依赖注入上面定义的sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!--定义Spring的事务拦截器TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 依赖注入上面定义的事务管理器transactionManager -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->
<property name="transactionAttributes">
<props>
<!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->
<prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
<!-- 所有方法均进行事务控制，如果当前没有事务，则新建一个事务 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 针对指定的bean自动生成业务代理 -->
<property name="beanNames">
<list>
<value>adminService</value>
<value>columnsService</value>
<value>newsService</value>
<value>crawlService</value>
<value>memberLevelService</value>
<value>memberService</value>
<value>categoryService</value>
<value>merService</value>
<value>cartService</value>
<value>ordersService</value>
<value>trafficService</value>
</list>
</property>
<!-- 这个属性为true时，表示被代理的是目标类本身而不是目标类的接口 -->
<property name="proxyTargetClass">
<value>true</value>
</property>
<!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>
尤其注意：如下
***********************************************************************************************************
【以上的事务拦截器和事务自动代理方式实现原理：像Struts2一样，都是凭借强大的拦截器功能对业务逻辑方法的调用进行拦截，然后又BeanNameAutoProxyCreator自动生成事务代理，最后送事务管理器，统一管理】
***********************************************************************************************************
87 hibernate二级缓存使用
第一，在hibernate.cfg.xml中配置使用二级缓存和二级缓存的提供类；
hibernate.cfg.xml
- <?xml version='1.0' encoding='UTF-8'?>
- <!DOCTYPE hibernate-configuration PUBLIC
- "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
- "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
- <hibernate-configuration>
- <session-factory>
- <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
- <property name="connection.url">jdbc:mysql://localhost:3306/navigater</property>
- <property name="connection.username">root</property>
- <property name="connection.password">123456</property>
- <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
- <property name="show_sql">true</property>
- <property name="hibernate.cache.use_second_level_cache" >true</property> <!-- 使用二级缓存 -->
- <property name="hibernate.cache.provider_class"><!-- 二级缓存的提供类 -->
- org.hibernate.cache.EhCacheProvider
- </property>
- <mapping resource="Category.hbm.xml" />
- <mapping resource="Friendurl.hbm.xml" />
- </session-factory>
- </hibernate-configuration>
第二，一的那方使用cache标签
category.hbm.xml
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE hibernate-mapping PUBLIC
- "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
- "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
- <hibernate-mapping>
- <class name="com.wansha.pojo.Category" table="category">
- <id name="id" column="id">
- <generator class="identity" />
- </id>
- <property name="categoryName" column="categoryName" type="string" />
- <list name="list" inverse="false" cascade="all" fetch="join">
- <cache usage="read-write"/><!-- 缓存可读可写，仅配置此句即可 -->
- <key column="category_id"/>
- <index column="index_"/>
- <one-to-many class="com.wansha.pojo.Friendurl"/>
- </list>
- </class>
- </hibernate-mapping>
第三，多的那方配置cache标签
friendurl.hbm.xml
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE hibernate-mapping PUBLIC
- "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
- "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
- <hibernate-mapping>
- <class name="com.wansha.pojo.Friendurl" table="friendurl">
- <cache usage="read-write"/><!-- 仅配置此句即可 -->
- <id name="id" column="id">
- <generator class="identity" />
- </id>
- <property name="siteName" column="siteName" type="string" />
- <property name="siteUrl" column="siteUrl" type="string" />
- <property name="companyAddress" column="companyAddress" type="string" />
- <property name="description" column="description" type="string" />
- <property name="status" column="status" type="boolean" />
- <property name="contactNumber" column="contactNumber" type="string" />
- <property name="startTime" column="startTime" type="timestamp" />
- <property name="endTime" column="endTime" type="timestamp" />
- <many-to-one name="category" class="com.wansha.pojo.Category" column="category_id" lazy="false"/>
- </class>
- </hibernate-mapping>
如果使用annotation可以在public class User 上面配置 @Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
第四，在src目录下，新建ehcache.xml文件，Ehcache 中ehcache.xml 配置详解和示例
- <?xml version="1.0" encoding="UTF-8"?>
- <ehcache>
- <!--timeToIdleSeconds 当缓存闲置n秒后销毁 -->
- <!--timeToLiveSeconds 当缓存存活n秒后销毁 -->
- <!--
- 缓存配置
- name:缓存名称。
- maxElementsInMemory：缓存最大个数。
- eternal:对象是否永久有效，一但设置了，timeout将不起作用。
- timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
- timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
- overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
- diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
- maxElementsOnDisk：硬盘最大缓存个数。
- diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
- diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
- memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
- clearOnFlush：内存数量最大时是否清除。
- -->
- <diskStore path="c:/cache" /> <!-- 二级缓存存放地址 -->
- <defaultCache
- maxElementsInMemory="500"
- eternal="false"
- timeToIdleSeconds="300"
- timeToLiveSeconds="1200"
- overflowToDisk="true" />
- <cache name="com.wansha.pojo.Student" maxElementsInMemory="150" eternal="false" timeToLiveSeconds="36000" timeToIdleSeconds="3600" overflowToDisk="true"/>
- </ehcache>
使用缓存，是需要对应用系统进行性能优化而常采用的一种重要手段。合理地运用缓存，可以极大的提高应用系统的运行效率。
Hibernate中应用缓存：因为应用程序访问数据库，读写数据的代价非常高，而利用持久层的缓存可以减少应用程序与数据库之间的交互，即把访问过的数据保存到缓存中，应用程序再次访问已经访问过的数据，这些数据就可以从缓存中获取，而不必再从数据库中获取。同时如果数据库中的数据被修改或者删除，那么是、该数据所对应的缓存数据，也会被同步修改或删除，进而保持缓存数据的一致性。
Hibernate的二级缓存由SessionFactory对象管理，是应用级别的缓存。它可以缓存整个应用的持久化对象，所以又称为“SessionFactory缓存”。
hibernate二级缓存中的缓存对象可以被整个应用的Session对象共享，即使关闭当前Session对象，新建的Session对象仍可使用。使用Hibernate的二级缓存之后查询数据，Session对象会首先在以及缓存中查找有无缓存数据被命中。如果没有，则查找二级缓存。如果有，则直接返回所命中的数据；否则查询数据库。
三. Hibernate二级缓存的管理：
1. Hibernate二级缓存策略的一般过程如下：
1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。
2) 把获得的所有数据对象根据ID放入到第二级缓存中。
3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。
4) 删除、更新、增加数据的时候，同时更新缓存。
Hibernate二级缓存策略，是针对于ID查询的缓存策略，对于条件查询则毫无作用。为此，Hibernate提供了针对条件查询的Query Cache。
2. 什么样的数据适合存放到第二级缓存中？
1) 很少被修改的数据
2) 不是很重要的数据，允许出现偶尔并发的数据
3) 不会被并发访问的数据
4) 参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。
3. 不适合存放到第二级缓存的数据？
1) 经常被修改的数据
2) 财务数据，绝对不允许出现并发
3) 与其他应用共享的数据。
- [JAVA面试] java面试
- java 面试
- java 面试
- java 面试
- Java 面试
- Java 面试
- java面试
- java面试
- java 面试
- java面试
- java面试
- java面试
- java面试
- JAVA面试
- Java面试
- Java面试
- java面试
- java面试
- CR, LF, CR/LF 回车 换行总结(转载)
- .TK免费顶级域名绑定“点点网”详细图文教程
- B.原根
- java基础语法学习
- ps 图层 缩小
- java面试
- HDU 1372 Knight Moves
- C# 学习笔记 数据库 Entity Framework （书：C#与.NET4 第23章）
- TestLink（1.8.4版本）安装及使用说明
- table函数
- Android不生成R文件的一个原因
- Asp.Net底层解析（四）——应用程序生命周期与HttpModule
- 《代码整洁之道》--注释
- java-rpc介绍
