面试（三）

• method：发送数据的方式； action：发给谁

• 单选框和复选框，name值必须相同，value值能够不一样 单选：type=radio 复选：type=checkbox

常见浏览器的内核：

1. Trident内核：IE浏览器，360，搜狗浏览器等

2. Gecko内核：Firefox浏览器

3. Presto内核：Opera（原为Presto内核，如今为Blink）

4. Webkit内核：Google Chrome

http常见的状态码有那些？

• 200 - 请求成功

• 301 - 资源（网页等）被永久转移到其它URL

• 404 - 请求的资源（网页等）不存在

• 500 - 内部服务器错误

Integer与int的区别

①int是java提供的8种原始数据类型之一。Java为每一个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer能够区分出未赋值和值为0的区别，int则没法表达出未赋值的状况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，因此用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，因此用el表达式在文本框中显示时，结果为0，因此，int不适合做为web层的表单数据的类型。

②在Hibernate中，若是将OID定义为Integer类型，那么Hibernate就能够根据其值是否为null而判断一个对象是不是临时的，若是将OID定义为了int类型，还须要在hbm映射文件中设置其unsaved-value属性为0。

③另外，Integer提供了多个与整数相关的操做方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

Iterator和ListIterator的区别是什么？

• Iterator可用来遍历Set和List集合，可是ListIterator只能用来遍历List。

• Iterator对集合只能是前向遍历，ListIterator既能够前向也能够后向。

• ListIterator实现了Iterator接口，并包含其余的功能，好比：增长元素，替换元素，获取前一个和后一个元素的索引，等等。

Jar包的做用是什么

一、用于发布和使用类库 二、做为应用程序和扩展的构建单元 三、做为组件、applet 或者插件程序的部署单位 四、用于打包与组件相关联的辅助资源

Java 的信号灯

• Semaphore：

Semaphore也叫信号量，在JDK1.5被引入，用来控制同时访问某个特定资源的操做数量，或者同时执行某个指定操做的数量。还能够用来实现某种资源池，或者对容器施加边界。

Semaphore能够维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore能够控制同时访问资源的线程个数，例如，实现一个文件容许的并发访问数。

Semaphore实现的功能就相似厕全部5个坑，假若有十我的要上厕所，那么同时能有多少我的去上厕所呢？同时只能有5我的可以占用，当5我的中的任何一我的让开后，其中在等待的另外5我的中又有一个能够占用了。另外等待的5我的中能够是随机得到优先机会，也能够是按照先来后到的顺序得到机会，这取决于构造Semaphore对象时传入的参数选项。

单个信号量的Semaphore对象能够实现互斥锁的功能，而且能够是由一个线程得到了“锁”，再由另外一个线程释放“锁”，这可应用于死锁恢复的一些场合。

 

JAVA 语言如何进行异常处理，关键字throws,throw,try,catch,finally 分别表明什么意义？在try 块中能够抛出异常吗？

Java 经过面向对象的方法进行异常处理，把各类不一样的异常进行分类，并提供了良好的接口。在Java 中，每一个异常都是一个对象，它是Throwable 类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法能够捕获到这个异常并进行处理。Java 的异常处理是经过5 个关键词来实现的：try、catch、throw、throws和finally。通常状况下是用try来执行一段程序，若是出现异常，系统会抛出（throws）一个异常，这时候你能够经过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。

• try：用 try来指定一块预防全部"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。

• throw：明确地抛出一个"异常"。

• throws ：标明一个成员函数可能抛出的各类"异常"。

• Finally：一段无论发生什么"异常"都被执行一段代码。

类java.lang.ThreadLocal的做用和原理。

• ThreadLocal隶属java.lang包，表示线程私有变量，也可叫作线程本地变量。它为单个线程单首创立了一个副本，每一个线程只可访问属于本身的变量，不可访问和修改别的线程所属的变量。

• ThreadLocal属于一个泛型类，泛型参数为变量的类型，能够经过重写initialValue方法来实现对该变量初始值的设置。

ThreadLocal的原理

ThreadLocal是如何作到为每个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每个线程的变量的副本。

Java.util.Map的实现类

一、HashMap

二、Hashtable

三、LinkedHashMap

四、TreeMap

JavaScript的数据类型都有什么？

基本数据类型：String,boolean,Number,Undefined, Null

引用数据类型：Object(Array,Date,RegExp,Function)

Java三大版本

Java2平台包括标准版（J2SE）、企业版（J2EE）和微缩版（J2ME）三个版本：

• Standard Edition(标准版) J2SE 包含那些构成Java语言核心的类。

好比：数据库链接、接口定义、输入/输出、网络编程

• Enterprise Edition(企业版) J2EE 包含J2SE 中的类，而且还包含用于开发企业级应用的类。

好比servlet、JSP、XML、事务控制

• Micro Edition(微缩版) J2ME 包含J2SE中一部分类，用于消费类电子产品的软件开发。

好比：呼机、智能卡、手机、PDA、机顶盒

他们的范围是：J2SE包含于J2EE中，J2ME包含了J2SE的核心类，但新添加了一些专有类

应用场合，API的覆盖范围各不相同。

Java三种注释类型说明

共有单行注释、多行注释、文档注释3种注释类型。

• 单行注释，采用“//”方式.只能注释一行代码。如：//类成员变量

• 多行注释，采用“/.../”方式，可注释多行代码，其中不容许出现嵌套。

• 文档注释，采用“/*.../”方式。如：

/**

* 子类 Dog

* @author www.wuliaokankan.cn

**/

java中final和abstract关键字的做用

• abstract能够用来修饰类和方法，不能用来修饰属性和构造方法；使用abstract修饰的类是抽象类，须要被继承，使用abstract修饰的方法是抽象方法，须要子类被重写。

• final能够用来修饰类、方法和属性，不能修饰构造方法。使用final修饰的类不能被继承，使用final修饰的方法不能被重写，使用final修饰的变量的值不能被修改，因此就成了常量。

特别注意：final修饰基本类型变量，其值不能改变，由原来的变量变为常量；可是final修饰引用类型变量，栈内存中的引用不能改变，可是所指向的堆内存中的对象的属性值仍旧能够改变

java中i++和++i的异同之处

共同点： 一、i++和++i都是变量自增1，都等价于i=i+1

               二、若是i++,++i是一条单独的语句，二者没有任何区别

               三、i++和++i的使用仅仅针对变量。 5++和++5会报错，由于5不是变量。

不一样点： 若是i++,++i不是一条单独的语句，他们就有区别：

            i++ ：先运算后增1。

如： int x=5; int y=x++; System.out.println("x="+x+", y="+y); //以上代码运行后输出结果为：x=6, y=5

            ++i ： 先增1后运算。

如： int x=5; int y=++x; System.out.println("x="+x+", y="+y); //以上代码运行后输出结果为：x=6, y=6

下面程序的运行结果是（）（选择一项） String str1="hello";

                                                                  String str2=new String("hello");

                                                                  System.out.println(str1==str2);

                                                                 A. true B. false C. hello D. he

答案：B 分析：str1没有使用new关键字，在堆中没有开辟空间，其值”hello”在常量池中，str2使用new关键字建立了一个对象，在堆中开辟了空间，”==”比较的是对象的引用，即内存地址，因此str1与str2两个对象的内存地址是不相同的

Java语言中，String类中的indexOf()方法返回值的类型是int

给定如下代码，程序的运行结果是 （）（选择一项）

public class Example { String str=new String("good");

     char [] ch={'a','b','c'};

public static void main(String[] args) {

    Example ex=new Example();

    ex.change(ex.str, ex.ch);

    System.out.print(ex.str+"and");

    System.out.print(ex.ch); }

public void change(String str,char ch[]){

    str="test ok";

    ch[0]='g';

    }

}

 

 A. goodandabc B. goodandgbc C. test okandabc D. test okandgbc

答案：B 分析：在方法调用时，在change方法中对str的值进行修改，是将str指向了常量江池中的”test ok”，而主方法中的ex.str仍然指向的是常量池中的”good”。字符型数组在方法调用时，将主方法中ex.ch的引用传递给change方法中的ch，指向是堆中的同一堆空间，因此修改ch[0]的时候,ex.ch能够看到相同的修改后的结果。

是否能够继承String类?

答:不能够，由于String类有final修饰符，而final修饰的类是不能被继承的，实现细节不容许改变。                         

                                   String str1=“hello”；

                                   Sring str2=“he”+new String(“llo”)；

                                   Sysem.out.println(str1==str2)); //false

                                   Sysem.out.println(str.equal(str2)); //true

下面哪一个是正确的（）

A. String temp[ ] = new String{“a”,”b”,”c”};

B. String temp[ ] = {“a”,”b”,”c”};

C. String temp= {“a”,”b”,”c”};

D. String[ ] temp = {“a”,”b”,”c”}; 答案：BD

 

已知以下代码：执行结果是什么（）

public class Test {

   public static void main(String[] args) {

         String s1 = new String("Hello");

         String s2 = new String("Hello");

         System.out.print(s1 == s2);

         String s3 = "Hello";

         String s4 = "Hello";

   System.out.print(s3 == s4); s1 = s3; s2 = s4;

   System.out.print(s1 == s2);

    }

}

 

A. false true true B. true false true C. true true false D. true true false

答案：A

java中this和super关键字的做用

• this是对象内部指代自身的引用,同时也是解决成员变量和局部变量同名问题；this能够调用成员变量，不能调用局部变量；this也能够调用成员方法，可是在普通方法中能够省略this，在构造方法中不容许省略，必须是构造方法的第一条语句，并且在静态方法当中不容许出现this关键字。

• super表明对当前对象的直接父类对象的引用，super能够调用直接父类的成员变量（注意权限修饰符的影响，好比不能访问private成员）,super能够调用直接父类的成员方法（注意权限修饰符的影响，好比不能访问private成员）；super能够调用直接父类的构造方法，只限构造方法中使用，且必须是第一条语句。

java中while和do-while循环的区别

• while先判断后执行，第一次判断为false,循环体一次都不执行

• do while先执行 后判断，最少执行1次。

若是while循环第一次判断为true, 则两种循环没有区别。

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

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

Java中垃圾回收（GC）有什么目的？有哪些GC?何时进行垃圾回收？

• 垃圾回收（GC）的目的是识别而且丢弃应用再也不使用的对象来释放和重用资源。

• System.gc()和Runtime.gc()这两个方法用来提示JVM要进行垃圾回收。可是，当即开始仍是延迟进行垃圾回收是取决于JVM的。

• 在释放对象占用的内存以前，垃圾收集器会调用对象的finalize()方法。通常建议在该方法中释放对象持有的资源。

• 若是对象的引用被置为null，垃圾收集器是不会当即释放对象占用的内存，在下一个垃圾回收周期中，这个对象将是可被回收的。

Java中如何实现序列化，有什么意义？

• 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。能够对流化后的对象进行读写操做，也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操做时可能引起的问题（若是不进行序列化可能会存在数据乱序的问题）。

• 要实现序列化，须要让一个类实现Serializable接口，该接口是一个标识性接口，标注该类对象是可被序列化的，而后使用一个输出流来构造一个对象输出流并经过writeObject(Object)方法就能够将实现对象写出（即保存其状态）；若是须要反序列化则能够用一个输入流创建对象输入流，而后经过readObject方法从流中读取对象。

• 例如，在web开发中，若是对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。若是对象要通过分布式系统进行网络传输或经过rmi等远程调用，这就须要在网络上传输对象，被传输的对象就必须实现Serializable接口。

Java中如何获取到线程dump文件

死循环、死锁、阻塞、页面打开慢等问题，打线程dump是最好的解决问题的途径。所谓线程dump也就是线程堆栈，获取到线程堆栈有两步：

（1）获取到线程的pid，能够经过使用jps命令，在Linux环境下还可使用ps -ef | grep java

（2）打印线程堆栈，能够经过使用jstack pid命令，在Linux环境下还可使用kill -3 pid

java中实现多态的机制是什么？

靠的是父类或接口定义的引用变量能够指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

java中接口有什么用

一、经过接口能够实现不相关类的相同行为，而不须要了解对象所对应的类。

二、经过接口能够指明多个类须要实现的方法。

三、经过接口能够了解对象的交互界面，而不需了解对象所对应的类。

另：Java是单继承，接口可使其实现多继承的功能。

java中有几种方法能够实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为什么不推荐使用？

• 有两种实现方法，分别是继承Thread类与实现Runnable接口

• 用synchronized关键字修饰同步方法

• 反对使用stop()，是由于它不安全。它会解除由线程获取的全部锁定，并且若是对象处于一种不连贯状态，那么其余线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这以前得到的锁定。此时，其余任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来讲，若是它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会形成死锁。因此不该该使用suspend()，而应在本身的Thread类中置入一个标志，指出线程应该活动仍是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()从新启动线程。

  Java中有几种类型的流？

（1）字节流 InputStream/OutputStream

①FileInputStream/FileOutputStream：文件字节流，用于文件的读写操做

②BufferedInputStream/BufferedFileOutputStream：加缓冲区的字节流，用于提升效率

（2）字符流 Reader/Writer

①FileReader/FileWriter：文件字符流，用于文本文件的读写操做

②BufferedReader/BufferedWriter：加缓冲区的字符流，用于提升效率

（3）转换流 InputStreamReader/OutputStreamWriter

Java中用到的线程调度算法是什么？

抢占式。一个线程用完CPU以后，操做系统会根据线程优先级、线程饥饿状况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。

Exception和Error都是Throwable的子类。Exception用于用户程序能够捕获的异常状况。Error定义了不指望被用户程序捕获的异常。

java中线程的状态转换

java中继承条件下构造方法的执行过程

• 状况1：若是子类的构造方法中没有经过super显式调用父类的有参构造方法，也没有经过this显式调用自身的其余构造方法，则系统会默认先调用父类的无参构造方法。在这种状况下，写不写“super();”语句，效果是同样的。

• 状况2：若是子类的构造方法中经过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。

• 状况3：若是子类的构造方法中经过this显式调用自身的其余构造方法，在相应构造方法中应用以上两条规则。

Java代码优化

(1)尽可能指定类、方法的final修饰符

(2)尽可能重用对象

(3)尽量使用局部变量

(4)及时关闭流

(5)慎用异常

(6)当复制大量数据时,使用System.arraycopy()命令

(7)循环内不要不断建立对象引用

(8)基于效率和类型检查的考虑,应该尽量使用array,没法肯定数组大小时才使用ArrayList

(9)尽可能使用HashMap、ArrayList、StringBuilder,除非线程安全须要,不然不推荐使用Hashtable、Vector、StringBuffer,后三者因为使用同步机制而致使了性能开销

(10)不要将数组声明为public static final

(11)及时清除再也不须要的会话

(12)使用同步代码块替代同步方法

(13)将常量声明为static final,并以大写命名

(14)程序运行过程当中避免使用反射

(15)使用数据库链接池和线程池

(16)顺序插入和随机访问比较多的场景使用ArrayList,元素删除和中间插入比较多的场景使用LinkedList

(17)字符串变量和字符串常量equals的时候将字符串常量写在前面

(18)公用的集合类中不使用的数据必定要及时remove掉

(19)使用最有效率的方式去遍历Map

Java建立线程后，调用start()方法和run()的区别

两种方法的区别

1） start方法：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。经过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并无运行，一旦获得cpu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run（）：

run()方法只是类的一个普通方法而已，若是直接调用run方法，程序中依然只有主线程这一个线程，其程序执行路径仍是只有一条，仍是要顺序执行，仍是要等待，run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，仍是在主线程里执行。这两个方法应该都比较熟悉，把须要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。而且run()方法必须是public访问权限，返回值类型为void。

两种方式的比较 ：

实际中每每采用实现Runable接口，一方面由于java只支持单继承，继承了Thread类就没法再继续继承其它类，并且Runable接口只有一个run方法；另外一方面经过结果能够看出实现Runable接口才是真正的多线程。

Java反射技术主要实现类有哪些，做用分别是什么？

在JDK中，主要由如下类来实现Java反射机制，这些类都位于java.lang.reflect包中

1）Class类：表明一个类

2）Field 类：表明类的成员变量(属性)

3）Method类：表明类的成员方法

4）Constructor 类：表明类的构造方法

5）Array类：提供了动态建立数组，以及访问数组的元素的静态方法

java反射的使用场合和做用、及其优缺点

1）使用场合

在编译时根本没法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息。

2）主要做用

经过反射可使程序代码访问装载到JVM 中的类的内部信息，获取已装载类的属性信息，获取已装载类的方法，获取已装载类的构造方法信息

3）反射的优势

反射提升了Java程序的灵活性和扩展性，下降耦合性，提升自适应能力。它容许程序建立和控制任何类的对象，无需提早硬编码目标类；反射是其它一些经常使用语言，如C、C++、Fortran 或者Pascal等都不具有的

4） Java反射技术应用领域很广，如软件测试等；许多流行的开源框架例如Struts、Hibernate、Spring在实现过程当中都采用了该技术

5）反射的缺点

性能问题：使用反射基本上是一种解释操做，用于字段和方法接入时要远慢于直接代码。所以Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。

使用反射会模糊程序内部逻辑：程序人员但愿在源代码中看到程序的逻辑，反射等绕过了源代码的技术，于是会带来维护问题。反射代码比相应的直接代码更复杂。