JSP面試知識

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方面

一、 Java 的類型轉換，日期與字符串間的轉換。

 若是低級類型爲char型，向高級類型（整型）轉換時，會轉換爲對應ASCII碼值，例如\r

   char c='c';     int i=c;     System.out.println("output:"+i);

輸出：output:99;
對於byte,short,char三種類型而言，他們是平級的，所以不能相互自動轉換，可使用下述的強制類型轉換。

short i=99;char c=(char)i;System.out.println("output:"+c);

輸出：output:c;
但根據筆者的經驗，byte,short,int三種類型都是整型，所以若是操做整型數據時，最好統一使用int型。
2.2強制類型轉換 
  將高級變量轉換爲低級變量時，狀況會複雜一些，你可使用強制類型轉換。即你必須採用下面這種語句格式：

int i=99;byte b=(byte)i;char c=(char)i;float f=(float)i;

    能夠想象，這種轉換確定可能會致使溢出或精度的降低，所以筆者並不推薦使用這種轉換。
  2.3包裝類過渡類型轉換
   在咱們討論其它變量類型之間的相互轉換時，咱們須要瞭解一下Java的包裝類，所謂包裝類，就是能夠直接將簡單類型的變量表示爲一個類，在執行變量類型的相互轉換時，咱們會大量使用這些包裝類。Java共有六個包裝類，分別是Boolean、Character、Integer、Long、Float和Double，從字面上咱們就能夠看出它們分別對應於 boolean、char、int、long、float和double。而String和Date自己就是類。因此也就不存在什麼包裝類的概念了。
   在進行簡單數據類型之間的轉換（自動轉換或強制轉換）時，咱們老是能夠利用包裝類進行中間過渡。
   通常狀況下，咱們首先聲明一個變量，而後生成一個對應的包裝類，就能夠利用包裝類的各類方法進行類型轉換了。例如：
  例1，當但願把float型轉換爲double型時：

  float f1=100.00f;   Float F1=new float(f1);   Double d1=F1.doubleValue();//F1.doubleValue()爲Float類的返回double值型的方法

   當但願把double型轉換爲int型時：

   double d1=100.00;     Double D1=new Double(d1);     int i1=D1.intValue();

   當但願把int型轉換爲double型時，自動轉換：

    int i1=200;     double d1=i1;

    簡單類型的變量轉換爲相應的包裝類，能夠利用包裝類的構造函數。即：
Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
而在各個包裝類中，總有形爲××Value()的方法，來獲得其對應的簡單類型數據。利用這種方法，也能夠實現不一樣數值型變量間的轉換，例如，對於一個雙精度實型類，intValue()能夠獲得其對應的整型變量，而doubleValue()能夠獲得其對應的雙精度實型變量。
  3 字符串型與其它數據類型的轉換 
    經過查閱類庫中各個類提供的成員方法能夠看到，幾乎從java.lang.Object類派生的全部類提供了toString()方法，即將該類轉換爲字符串。例如：Characrer,Integer,Float,Double,Boolean,Short等類的toString()方法toString()方法用於將字符、整數、浮點數、雙精度數、邏輯數、短整型等類轉換爲字符串。以下所示：

int i1=10;float f1=3.14f;double d1=3.1415926;Integer I1=new Integer(i1);//生成Integer類\rFloat F1=new Float(f1); //生成Float類\rDouble D1=new Double(d1); //生成Double類\r//分別調用包裝類的toString()方法轉換爲字符串String si1=I1.toString();String sf1=F1.toString();String sd1=D1.toString();Sysytem.out.println("si1"+si1);Sysytem.out.println("sf1"+sf1);Sysytem.out.println("sd1"+sd1);

5、將字符型直接作爲數值轉換爲其它數據類型
將字符型變量轉換爲數值型變量實際上有兩種對應關係，在咱們在第一部分所說的那種轉換中，其實是將其轉換成對應的ASCII碼，可是咱們有時還須要另外一種轉換關係，例如，'1'就是指的數值1，而不是其ASCII碼，對於這種轉換，咱們可使用Character的getNumericValue(char ch)方法。
6、Date類與其它數據類型的相互轉換
  整型和Date類之間並不存在直接的對應關係，只是你可使用int型爲分別表示年、月、日、時、分、秒，這樣就在二者之間創建了一個對應關係，在做這種轉換時，你可使用Date類構造函數的三種形式：
Date(int year, int month, int date)：以int型表示年、月、日
Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、時、分
Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、時、分、秒\r
在長整型和Date類之間有一個頗有趣的對應關係，就是將一個時間表示爲距離格林尼治標準時間1970年1月1日0時0分0秒的毫秒數。對於這種對應關係，Date類也有其相應的構造函數：Date(long date)
獲取Date類中的年、月、日、時、分、秒以及星期你可使用Date類的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也能夠將其理解爲將Date類轉換成int。
而Date類的getTime()方法能夠獲得咱們前面所說的一個時間對應的長整型數，與包裝類同樣，Date類也有一個toString()方法能夠將其轉換爲String類。
有時咱們但願獲得Date的特定格式，例如20020324，咱們可使用如下方法，首先在文件開始引入，

import java.text.SimpleDateFormat;import java.util.*;java.util.Date date = new java.util.Date();//若是但願獲得YYYYMMDD的格式SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");String dateFormat=sy1.format(date);//若是但願分開獲得年，月，日SimpleDateFormat sy=new SimpleDateFormat("yyyy");SimpleDateFormat sm=new SimpleDateFormat("MM");SimpleDateFormat sd=new SimpleDateFormat("dd");String syear=sy.format(date);String smon=sm.format(date);String sday=sd.format(date);

結束語：
固然，筆者的論述只是一人之見，若是但願更多瞭解有關JAVA數據類型轉換的知識，筆者建議參考JAVA類庫java.util.*下面的
Integer類\r
Boolean類\r
Character類\r
Float類\r
Double類\r
String類\r
Date類 
根據本身的須要，參考不一樣類的各類成員方法進行數據類型之間的轉換。
你們能夠參考JAVA的網上類庫或下載一份，來更靈活的利用其中的成員方法進行數據類型之間的轉換，IP地址：
http://java.sun.com/j2se/1.3/docs/api/index.html

補充：

  如何將字串 String 轉換成整數 int? A. 有兩個方法: 1). int i = Integer.parseInt([String]); 或 i = Integer.parseInt([String],[int radix]); 2). int i = Integer.valueOf(my_str).intValue(); 注: 字串轉成 Double, Float, Long 的方法大同小異. 2 如何將整數 int 轉換成字串 String ? A. 有叄種方法: 1.) String s = String.valueOf(i); 2.) String s = Integer.toString(i); 3.) String s = "" + i; 注: Double, Float, Long 轉成字串的方法大同小異. 這是一個例子,說的是JAVA中數據數型的轉換.供你們學習

 

二、 連一個數據庫。給一個SQL語句，對返回的結果集進行操做。

package com.bluedot.util;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

 

public class ConnDB

{

public static String jdbcDriver="org.gjt.mm.mysql.Driver";

    public static String url="jdbc:mysql://localhost:3306/test_user";

    public static String name="root";

    public static String password="root";

 

public ConnDB()

{

super();

}

public static  Connection getConnection()

{

Connection conn=null;

try

{

Class.forName(jdbcDriver).newInstance();

conn=DriverManager.getConnection(url,name,password);

}

catch (InstantiationException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

catch (IllegalAccessException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

catch (ClassNotFoundException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

catch (SQLException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return conn;

}

 

}

三、 線程。

 

JavaScript方面

一、 用JavaScript作一個樹狀菜單。

 

 

 

 

 

 

 

 

java概念簡析

[對象的建立與使用]

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