面試題（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中對應的類建立實現。