面试题（3）

JSP方面

一、 JSP四种范围是什么？区别是什么？

Page:指单单一页jsp page的范围；

Request:的范围只在一jsp页发出请求到另外一页之间，随后这个属性失效；

Session:范围是用户和服务器链接的那段时间，用户与服务器断开属性就失效； 

Application:做用范围最大，在服务器一开始执行服务到服务器关闭为止。可能形成服务器负载太重。

二、 JSP有哪些内置对象?做用和分别是什么？

答:JSP共有如下9种基本内置组件（可与ASP的6种内部组件相对应）：

  　request 用户端请求，此请求会包含来自GET/POST请求的参数 

 response 网页传回用户端的回应

   pageContext 网页的属性是在这里管理 

 session 与请求有关的会话期 

 application servlet 正在执行的内容   

out 用来传送回应的输出 

 config servlet的构架部件   

page JSP网页自己   

exception 针对错误网页，未捕捉的例外 

三、 JSP有哪些动做？做用分别是什么？

答:JSP共有如下6种基本动做 

jsp:include：在页面被请求的时候引入一个文件。

  jsp:useBean：寻找或者实例化一个JavaBean。 

jsp:setProperty：设置JavaBean的属性。 

jsp:getProperty：输出某个JavaBean的属性。

  jsp:forward：把请求转到一个新的页面。

  jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记 

四、 getAttribute()和setAttribute()的做用是什么？

 

五、 get和post的区别？

Form中的get和post方法，在数据传输过程当中分别对应了HTTP协议中的GET和POST方法。两者主要区别以下：

  1、Get是用来从服务器上得到数据，而Post是用来向服务器上传递数据。

  2、Get将表单中数据的按照variable=value的形式，添加到action所指向的URL后面，而且二者使用“?”链接，而各个变量之间使用“&”链接；Post是将表单中的数据放在form的数据体中，按照变量和值相对应的方式，传递到action所指向URL。

  3、Get是不安全的，由于在传输过程，数据被放在请求的URL中，而现在现有的不少服务器、代理服务器或者用户代理都会将请求URL记录到日志文件中，而后放在某个地方，这样就可能会有一些隐私的信息被第三方看到。另外，用户也能够在浏览器上直接看到提交的数据，一些系统内部消息将会一同显示在用户面前。Post的全部操做对用户来讲都是不可见的。

  4、Get传输的数据量小，这主要是由于受URL长度限制；而Post能够传输大量的数据，因此在上传文件只能使用Post（固然还有一个缘由，将在后面的提到）。

  5、Get限制Form表单的数据集的值必须为ASCII字符；而Post支持整个ISO10646字符集。

  6、Get是Form的默认方法。

六、 写一个JSP页面，里面要包含一个表单、表单包含文本框、列表框、单选按扭、复选框。

 

七、 当前页面是a.jsp，用forward显示b.jsp的内容。

 

八、 什么是taglib?如何使用？有哪些方式？

 

1、问题：Tag到底是什么？如何实现一个Tag？ 　　一个tag就是一个普通的java类，它惟一特别之处是它必须继承TagSupport或者BodyTagSupport类。这两个类提供了一些方法，负责jsp页面和你编写的类之间的交互，例如输入，输出。而这两个类是由jsp容器提供的，无须开发人员本身实现。换句话说，你只需把实现了业务逻辑的类继承TagSupport或者BodyTagSupport，再作一些特别的工做，你的类就是一个Tag。而且它本身负责和jsp页面的交互，不用你多操心。

“特别的工做”一般有如下几个步骤： 　　

1）提供属性的set方法，此后这个属性就能够在jsp页面设置。以jstl标签为例 ＜c:out value=""/＞，这个value就是jsp数据到tag之间的入口。因此tag里面必须有一个setValue方法，具体的属性能够不叫value。

例如： setValue(String data){this.data = data;} 　　这个“value”的名称是在tld里定义的。取什么名字均可以，只需tag里提供相应的set方法便可。

　　2）处理 doStartTag 或 doEndTag 。这两个方法是 TagSupport提供的。 仍是以＜c:out value=""/＞为例，当jsp解析这个标签的时候，在“＜”处触发 doStartTag 事件，在“＞”时触发 doEndTag 事件。一般在 doStartTag 里进行逻辑操做，在 doEndTag 里控制输出。 　　

3）编写tld文件。 　　4）在jsp页面导入tld 　

　这样，你的jsp页面就可使用本身的tag了。 　　一般你会发现本身绝大多数活动都集中在 doStartTag 或 doEndTag 方法里。确实如此，熟悉一些接口和类以后，写taglib很容易。正如《jsp设计》的做者所言：里面的逻辑稍微有点复杂，但毕竟没有火箭上天那么难。

  2、一个简单的例子：OutputTag package diegoyun; import javax.servlet.jsp.JspException; import javax.servlet.jsp.JspWriter; import javax.servlet.jsp.tagext.TagSupport; /** * @author chenys */ public class OutputTag extends TagSupport { private String name=null; public void setName(String name) { this.name = name; } public int doStartTag() throws JspException{ try { JspWriter out = pageContext.getOut(); out.print("Hello! " + name); } catch (Exception e) { throw new JspException(e); } return EVAL_PAGE; } } 　　

简要说明： 　　1、如何输出到jsp页面： 　　调用JspWriter JspWriter out = pageContext.getOut();out.print...... 　　记住这个方法就能够了。 　

　2、输出后如何做处理 　　函数会返回几个值之一。EVAL_PAGE 表示tag已处理完毕，返回jsp页面。还有几个值，例如 EVAL_BODY_AGAIN 和EVAL_BODY_INCLUDE等，后面咱们会做讨论 　　编写tld ＜?xml version="1.0" encoding="ISO-8859-1" ?＞ ＜!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd"＞ ＜taglib＞ ＜tlib-version＞1.0＜/tlib-version＞ ＜jsp-version＞1.2＜/jsp-version＞ ＜short-name＞diego＜/short-name＞ ＜!--OutputTag--＞ ＜tag＞ ＜name＞out＜/name＞ ＜tag-class＞diegoyun.OutputTag＜/tag-class＞ ＜body-content＞empty＜/body-content＞ ＜attribute＞ ＜name＞name＜/name＞ ＜required＞false＜/required＞ ＜rtexprvalue＞false＜/rtexprvalue＞ ＜/attribute＞ ＜/tag＞ ＜/taglib＞ 　　在WEB-INF下新建tlds文件夹，把这个文件取名为diego.tld，放到tlds文件夹下。路径应该这样：WEB-INF\tlds\diego.tld 关于tld的简单说明： 　　short-name：taglib的名称，也称为前缀。好比＜c:out value=""/＞ 里的“c” 　　name：tag的名字。例如＜c:out value=""/＞ 里的"out”，咱们的类也取名为out，因为有前缀做区分，不会混淆 　　tag-class：具体的tag类。带包名 　　body-content：指tag之间的内容。例如＜c:out value=""＞ ...... ＜/c＞ 起始和关闭标签之间就是body-content。因为没有处理body-content，因此上面设为empty 　　＜attribute＞里的name：属性名字。例如＜c:out value=""/＞里的value。名字可任意取，只要类里提供相应的set方法便可。 　　required：是否必填属性。 　　rtexprvalue：是否支持运行时表达式取值。这是tag的强大功能。之后咱们会讨论。暂时设为false 　　编写jsp页面 ＜%@ page language="java"%＞ ＜%@ taglib uri="/WEB-INF/tlds/diego.tld" prefix="diego"%＞ ＜html＞ ＜body＞ Test Tag: ＜diego:out name="diegoyun"/＞ ＜/body＞ ＜/html＞ 　　个人编程环境是eclipse+tomcat.启动服务器，若是一切按照上面步骤的话，就能看到 Test Tag: Hello! diegoyun 字样 　　最简单的tag就这么出来了。并不难,是否是?

九、 Jsp跳转有几种方式？分别是什么？

 

十、 JavaBuan的范围？

<jsp:useBean>标签里有一属性scope，它用来设定JavaBean的范围，它的值只能为Page,request,session,application,不可为其它值。

使用不一样的scope属性值，能在不用的范围共享JavaBean.

十一、 JSP中动态INCLUDE与静态INCLUDE的区别？  答：动态INCLUDE用jsp:include动做实现  <jsp:include page="included.jsp" flush="true" />它老是会检查所含文件中的变化，适合用于包含动态页面，而且能够带参数  静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面  <%@ include file="included.htm" %> 12、两种跳转方式分别是什么?有什么区别? 答：有两种，分别为：  <jsp:include page="included.jsp" flush="true"> <jsp:forward page= "nextpage.jsp"/> 前者页面不会转向include所指的页面，只是显示该页的结果，主页面仍是原来的页面。执行完后还会回来，至关于函数调用。而且能够带参数.后者彻底转向新页面，不会再回来。至关于go to 语句。 

 

 

[对象的建立与使用]

java中对象是由类建立出来的

建立对象包括：1.定义对象 

    2.创建对象 

3.初始化对象 

如:Rectangle myRectangle=new Rectangle(0,0,10,20);

使用： 1.经过对象变量的引用来使用对象

如：myRectangle.width=20;

2.经过调用对象的方法来使用对象

如：myRectangle.move(5,10);

[类，类的属性，类的成员变量]

类分类的说明和类体

如：class Point{

int x,y; //变量说明

x() //类class中的一个方法x()

{

return x

}

}

 

类的属性包括：

1.指出此类的父类 (extends 部分)

2.指出类提供的接口 (implements 部分)

如：class ImNumber extends Number implements Collection(){

...

}

3.指出类的特性 (修饰部分)

如：final class ImNumber extends Number implements Collection() {...} //final 指出类ImNumber是个最终类

又如：abstract class ImNumber extends Number implements Collection()

{...} //abstract 指出类ImNumber是个抽象类

final和abstract不可能同时出现

由类建立出对象，而多个类组成包，同一个包中的类能够相互访问。

但有种类是公共类，能够被包之外的其余类或对象访问。

用public表示是公共类，用private表示只能被同一个包中的其余类访问。用public和private代表类的一种访问权限。

所以，类的说明是以下形式：

[modifiers]class ClassName [extends SuperClassName][implements Interfacelist(接口列表)] {

...} //带方括号的部分为可选的

类的成员变量定义包含：

1.变量的访问权限 (用关键字public,private,protected或private protected表示)

2.是否为静态变量 (用关键字static表示)

3.是否为常量 (若是一个变量是一个常量，用关键字final)

如：final int CON=20;

类的成员变量的访问权限：

1.公用(public)变量 (容许全部的类访问)

2.专用(private)变量 (只能被其所属的类访问)

3.保护型(protected)变量 (容许被其归属的类，由此类派生的子类以及同一包中的其余类访问)

4.专用保护型(private protected)变量 (容许被其归属的类，由此类派生的子类访问)

5.默认型变量(不用任何词来修饰，没有设置访问权限。容许所归属的类访问和被同一包中的其余类访问)

[方法]

方法和类的结构类似，有方法说明和方法体。

方法的结构表示以下所示：

[modifiers(访问权限)]type(返回参数类型，没有返回参数就写成void) methodName(para1,para2,... (入口参数)){

methodBody

}

例： public int selMax(int x,int y){

if (x>y) return x;

else return y;

}

}

[构造方法]

不能有独立的方法名字，并且只能有入口参数，没有返回值。（名字与class同样，入口参数可不同。）不能有abstract.

调用时，第一条用super()语句调用，（若是没用super(),系统默认为super()）有入口参数的必需要写出。

若是第一条用this()语句调用，java系统就不会再默认这个构造方法调用父类。

[main方法]

Applet中必定没有main方法，Application中必定包含main方法。main方法是static 类型的，也没有返回参数。

[变量隐藏和方法置换]

在子类继承父类时，若是子类的成员变量和父类的成员变量同名，子类就隐藏了(override)父类的成员变量。此时，子类使用的是他本身的变量。

如子类的方法与父类同名，同返回值，同入口参数，此时，子类的方法便置换了父类的方法。如想使用父类，需用super来实现。

[抽象类与抽象方法]

抽象类不能建立对象，只能由其派生子类，是专门用来做为其余类的父类的。(abstract class xx{})

抽象方法是只给出定义，但没有实现语句的方法。它的实现必须由子类来完成。

注意：1.构造方法不能冠以abstract

2.凡是定义为static或private型的方法不能再加abstract

3.若是父类中已有同名的abstract方法，那么，子类中就不能再有同名的抽象方法

4.抽象类中不必定有抽象方法，但包含抽象方法的类必须为抽象类。

[最终类，最终方法和最终变量]

最终类不能再派生出子类，也就提升了安全性，程序可读性。

用关键字final。如final class ...{}

[接口]

特色: 1.接口用关键字interface,不用class

2.接口中定义的变量是最终的静态变量

3.接口中没有自身的构造方法，并且定义的其余方法全是抽象方法，即只提供反方法的定义，没有提供实现方法的语句。

4.接口采用多重继承机制，而不是采用单一的继承体制。

由于java的类中是采用的单一的继承体制，即一个类只有一个父类。在程序设计中，存在须要多重继承的时候，所以，java引入接口的概念。这样既保留了类的单一继承带来的程序简洁和层次清晰等优势，又可使用多重继承来实现java的更方便，更强大的功能。

接口支持多重继承，因此一个接口能够有好几个父接口，用逗号将几个父接口名分开，如：

public interface Cookable extends Foodable,Printable{

.....

}

接口名一般第一个字母用大写，并用able或ible做结尾，表示接口能完成必定的功能。

接口中定义的常量要用大写表示，所有默认为final和static型。

接口中都用抽象方法，因此，接口中的方法定义中没有方法体，都默认为abstract属性。

如： interface Bigable{

int SUM=100;

void increment();

int setData();

}

[一个类调用有多个父接口的子接口所遵循的规则]

如：有First,Second,Three和Fourth的四个接口，并且，Three和Fourth是从First和Second继承来的。

interface First{...}

interface Second{...}

interface Three extends First{...}

interface Fourth extends First,Second{...}

此时，若有一个类Fifth用以下语句调用和继承Fourth接口：

class Fifth implements Fourth {...}

那么，在Fifth中，不但要实现接口Fourth中所定义的全部方法，并且还要实现Fourth的父接口First和Second中所定义的全部方法。且要实现时，要使方法的名字，返回值，入口参数一一对应。

[线程的状态、线程的方法、线程的建立]

线程由java.lang软件包提供,一个进程中可建立多个线程，且建立时不须要再分配数据段。

线程的生命周期：

分4个状态：

1． 建立（new）状态

2． 可运行（runnable）状态

3． 不可运行（not runnable）状态

4． 消亡（dead）状态

线程4个状态的转换：

1． 建立（new）状态

两种操做：

一. 启动（start），使其进入可运行状态。

二. 终止（stop），使其进入消亡状态。

如：Thread myThread=new MyThreadClass();

2． 可运行（runnable）状态

有以下操做：1.挂起（suspend） 2.睡眠(sleep) 3.等待(wait) 4.退让(yield) 5.终止(stop)

1~3使可运行状态的线程进入不可运行状态。

3． 不可运行状态（not runnable）

有三种方式恢复到运行状态：

自动恢复

恢复（resume）操做

通知(notify或notify All)方法

4． 消亡状态（dead）

线程的方法：

四大组：

1． 构造方法（7个）

如：public Thread(); public Thread(Runnable target);…

2． 实现线程行为的方法

就是run()方法，如：public void run();

3． 改变线程状态的方法

就是如：启动、睡眠、终止、挂起、恢复、退让以及等待

如：public void start(); public static void sleep(long millis);

public final void stop() 等

4． 其余方法

有获取线程的名字getName、设置线程的名字setName等等

线程的建立：

有两种方法：

1． 经过对Thread的继承来派生一个子类，再由此子类生成一个对象来实现线程的建立，这是比较简单直接的方法。

如:

import java.lang.* //引用lang包

class Mango extends Thread {

public void run(){ //run方法置换父类Thread的run方法

…

}

}

还要由子类生成一个对象，而且进行启动操做，这样才能获得一个处于可运行状态的线程。生成对象其实就是完成线程的建立，启动则对已建立的线程进行操做。

语句以下：

Mango t=new Mango();

t.start();

线程其实也是一个对象。

2． 经过一个类去继承接口Runnable来实现线程的建立，而这个类必须提供Runnable接口中定义的方法run()的实现。

如：下面的程序实现和接口的链接

public class xyz implements Runnable {

int i;

public void run(){

while (true){

System.out.println(“Hello”+i++);

}

}

}

而后再建立一个线程：

Runnable r=new xyz();

Thread t=new Thread(r);

这种比第一种灵活，因为java不支持多重继承，就须要用接口实现，能够按须要继承一个父类又可由此建立一个线程。

用第一种方法线程建立时，线程会自动执行子类的run()方法，不会执行Thread类的run()方法。由于Thread类中的run()方法是这样的：

public void run() {

if (target !=null){

target.run();

…

}

}

因此，Thread执行时，老是先检查线程的目标对象是否存在，如不为空，就执行目标对象的run()方法。子类中必须提供run()方法的实现。

用从Thread类派生子类的方法建立和启动线程时，会有以下两种方法：

1． 派生子类，生成对象，再使用start方法

例： class First extends Thread{

public void run(){

…

}

}

First t=new First();

t.start();

2． 用一个语句完成生成对象和启动线程操做

例：class First extends Thread{

public void run(){

…

}

}

new First.start();

这里子类的名字和线程名字合二为一，都是First。

具体的例子：

class FruitTes {

public static void main(String arg[ ]) {

new Fruit(“Apple”).start();

new Fruit(“Orange”).start)();

}

}

class Fruit extends Thread {

public Fruit(String ) {

super(str);

}

public void run(){

for (int i=0;2;i++){

System.out.println(i+“”+getName());

try{

sleep((int)(Math.random()*500));

}

catch (InterruptedException e){}

}

}

}

程序先执行main方法，main方法里有两个语句，分别生成Fruit的两个对象即线程，并启动Apple和Orange两个线程。

用继承接口Runnable来建立线程：

public interface java.lang.Runnable{

public abstract void run();

}

Runnable 只提供一个“接口”，实现线程具体行为的run()方法则必须由链接这个类提供。

用Runnable接口建立线程的方式：

1． 采用构造方法

即在子类中先定义线程，而后在构造方法中完成线程的建立和启动。

如：

class Tigers extends Animal implements Runnable{

Thread mythread;

Tigers (String name){

mythread=new Thread(this);

mythread.start();

}

public void run(){

…}

… }

2． 采用启动方法

即在程序中先定义线程，而后设计一个start()方法，在start()方法中再完成线程的建立和启动。

如：

public class Clock extends Applet implements Runnable{

Thread clockThread;

public void start(){

if (clockThread==null){

clockThread=new Thread(this,”Clock”);

clockThread.start();

}

}

public void run(){

while (clockThread!=null){

…

}

}

}

[容器、组件与类]

容器中包含组件，也可包含其余容器。

容器和组件都要由java中对应的类建立实现。