JSP方面

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

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

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

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

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

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

答:JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：
　request 用户端请求，此请求会包含来自GET/POST请求的参数
 response 网页传回用户端的回应
 pageContext 网页的属性是在这里管理
 session 与请求有关的会话期
 application servlet 正在执行的内容
 out 用来传送回应的输出
 config servlet的构架部件
 page JSP网页本身
 exception 针对错误网页，未捕捉的例外

3、  JSP有哪些动作？作用分别是什么？

答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

4、  getAttribute()和setAttribute()的作用是什么？

 

5、  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的默认方法。

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

 

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

 

8、  什么是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就这么出来了。并不难,是不是?

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

 

10、              JavaBuan的范围？

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

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

11、              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、  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);

五、将字符型直接做为数值转换为其它数据类型
将字符型变量转换为数值型变量实际上有两种对应关系，在我们在第一部分所说的那种转换中，实际上是将其转换成对应的ASCII码，但是我们有时还需要另一种转换关系，例如，'1'就是指的数值1，而不是其ASCII码，对于这种转换，我们可以使用Character的getNumericValue(char ch)方法。
六、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中数据数型的转换.供大家学习

 

2、  连一个数据库。给一个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;

}

 

}

3、  线程。

 

JavaScript方面

1、  用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中对应的类创建实现。