2006年6月8日随笔档案 - BloveSaga

2006年6月8日 #

大家可以浏览我新的博客 dyin.cn

posted @ 2007-05-11 16:57 蓝色Saga 阅读(149) | 评论 (0) | 编辑收藏

今天与大家分享的资源如下:
==================================================================================
JSP动态网页制作
PHP动态网页制作
ASP动态网页制作
Perl动态网页制作
winxp优化大全
JSP程序设计
以上皆是视频教程
如果你需要请你留下email我将会在晚上统一把种子发送到你的邮箱里,如果需要请抓紧,3天后将不再提供!

posted @ 2006-06-21 12:23 蓝色Saga 阅读(310) | 评论 (5) | 编辑收藏

国际化问题

要考虑一个真正意义的全球资源,Web浏览器的内容对每个接收到的用户来说都是易读的,现在大多数的全球资源的网站都是英文的.当然,现在也在发生变化,有的网站为一些特定的国家定制一些非英文版本,比如,说英文的通过http://www.ibm.com/en/index.html来访问,说中文的通过http://www.imb.com/cn/index.html来访问,这些很多都是静态的文本.怎么构件一个动态生成的国际化内容的网站就不是一个简单的问题了.

国际化又称Il8N,因为英文国家的国家化是Internationalization,它以I开始,以N结束,共18个字母.本地化又称L18N,即是Localization.国际化的问题主要包含以下的一些内容:
.日期,时间
.数字
.货币
.其它的一些特殊字符
也就是说不同的Locale,显示日期,时间格式是不一样的.当然,不同的语言有自己不同的字符集.

HTML中的字符实体
HTML中的字符实体和XML的语言保持一致.它定义了用特定的字符序列显示单字符的功能,这种字符序列称为字符实体,它以" &"开头,以";"结束.例如: © 表示字符"©";
看一例子显示西班牙语的" Hello World":
<%@page contentType="text/html;charset=ISO-8859-1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<%
   response.setHeader("Content-Language","es");
   out.println("<html><head><title>En Español</title></head>");
   out.println("<body>");
   out.println("<h3>En espa%ntilde;ol</h3>");
   out.println("¡Hola Mundo!");
   out.println("</body></html>");
%>

运行结果:

En espa%ntilde;ol

¡Hola Mundo!

在HTML字符实体表示中，&ntilde代表了" ñ "字符，使用response.setHeader("Content-Language","es");来设置HTML显示时要使用的语言.

Unicode
Unicode字符标准是一个字符编码系统,它支持互相转换,处理和显示现在世界上不同语言的文本.在Java语言中,字符,字符串和标始符在内部使用16位的Unicode 2.0字符集表示.Unicode使用 " \uxxxx" 来表示一个字符,前256个Unicode字符和ISO-8859-1标准(Latin-1)的前256个字符一致.在Unicode世界中, " ñ " 用 " \u00f1 " 表示.看怎么用Unicode来编写西班牙语的Hello World:
<%@page contentType="text/html;charset=ISO-8859-1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<%
   response.setHeader("Content-Language","es");
   out.println("<html><head><title>En Espa\u00f1ol</title></head>");
   out.println("<body>");
   out.println("<h3>En espa\u00f1ol</h3>");
   out.println("\u00f1Hola Mundo!");
   out.println("</body></html>");
%>

支持多国语言的Hello World

用语选择语言的页面:

语言处理页面代码:
<%@page contentType="text/plain;charset=UTF-8"
import="java.io.*,java.text.*,java.util.*,javax.servlet.jsp.*" %>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
<%!
   Locale locale;
   DateFormat format;
   JspWriter writer;
%>
<%!
   //英语
void processEnglish()throws Exception
{
    locale=new Locale("en","US");
    format=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG,locale);
    writer.println("in english");
    writer.println("<br>");
    writer.println("HelloWorld");
    writer.println(format.format(new Date()));
    writer.flush();
}

   //中文
void processChinese()throws Exception
{
    locale=new Locale("zh","");
    format=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG,locale);
    writer.println("in Chinese");
    writer.println("<br>");
    writer.println("\u4f60\u597d\u4e16\u754c");
    writer.println(format.format(new Date()));
    writer.flush();
}

   //韩国语
void processKorean()throws Exception
{
    locale=new Locale("ko","");
    format=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG,locale);
    writer.println("in Korean");
    writer.println("<br>");
    writer.println("\uc548\ud558\uc138\uacc4");
    writer.println(format.format(new Date()));
    writer.flush();
}
//.........................其他的语言省略
%>
<%
    //获得请求的语种
     String language=(String)request.getParameter("language");
     int lan=Integer.parseInt(language);
%>
<%
   writer=out;
   switch(lan)
   {
       case 1:processEnglish();break;
       case 2:processChinese();break;
       case 3:processKorean();break;
       //case 4:processRussian();break;
       //case 5:processSpanish();break;
      // case 6:processJapanese();break;
   }
%>
    </body>
</html>
处理的思路很简单,首先获得请求的语种,然后根据不同的语言来做不同的处理.

posted @ 2006-06-20 14:00 蓝色Saga 阅读(210) | 评论 (0) | 编辑收藏

JSP开发中常用的技巧

在JSP开发中我们常常会碰到以下的一些问题，其实都很有代表性.

在不同的页面或者用户之间共享数据

在JSP中共享数据,大体上可以分为两种情况,第一种是在同一个用户的不同也面之间共享数据,另一种是在不同用户之间共享数据.
对于同一个用户的会话,要想在不同的页面之间共享数据,可以有以下几种选择:
.把数据保存在Session中(最常见的方法)
.通过Cookie
.通过隐含表单提交到下一个页面
.通过ServletContext对象
.通过Application对象
.通过文件系统或者数据库
要在不同的用户之间共享数据,通常的方法是:
.通过ServletContext对象
.通过Application对象
.通过文件系统或者数据库
可见,对于不同用户之间共享数据的实现方法在同一个用户的不同也面之间也能实现数据共享.
a.在同一个用户的不同也面之间共享数据
1.使用session共享数据
用户在浏览网页时,由于HTTP协议是一种无状态协议,往往在不同的页面之间存在数据交换的问题,这就需要在这些不同的页面之间共享数据.在编程实现中我们常看到的方法是把共享数据保存在session中.这些共享数据可以是字符串或者与Java的原始数据类型相关的对象,也可以是一个Java对象.
exampl: 用户登录时,如果验证成功,就把信息保存到一个userSession的类中,在其他的页面可以读取这个值.
userSession.java
package dory;
import java.util.Date;
/**
*
* @author Dory Doo
*/
public class userSession {
    private boolean isLogin=false;
    private String userId;
    private Date lastLoginTime;
    private int logCount;
    /** Creates a new instance of userSession */
    public userSession() {
    }
    public void setIsLogin(boolean l)
    {
        this.isLogin=l;
    }
    public void setUserId(String userId)
    {
        this.userId=userId;
    }
    public void setLastLoginTime(Date l)
    {
        this.lastLoginTime=l;
    }
    public void setLogCount(int logCount)
    {
        this.logCount=logCount;
    }
    public boolean isLogin()
    {
        return this.isLogin;
    }
    public String getUserId()
    {
        return this.userId;
    }
    public Date getLastLoginTime()
    {
        return this.lastLoginTime;
    }
    public int getLogCount()
    {
        return this.logCount;
    }
}
当然这个就比较简单的了，要的是整个思路.我们怎么来使用这个类，我们需要一个验证登陆的页login.jsp
<%@page contentType="text/html;charset=gb2312" language="java"
import="java.sql.*,dory.*" errorPage=""%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

    <h1>Login Checking Page</h1>
<%
   String name=request.getParameter("name");
   String password=request.getParameter("password");
   //Connection the Database,loading
   //int logCount=resultSet.getInt("count");
   //java.util.Date lastLoginTime=resultSet.getDate("LastLoginTime");
   //这里简单设置logCount和lastLoginTime的值
   UserSession user=new UserSeesion();
   user.setUserId(name);
   user.setIsLogin(true);
   user.setLastLoginTime(new java.util.Date());
   user.setLogCount(10);
   session.setAttribute("userSession",user)
   response.sendRedirect("welcome.jsp");
%>
    </body>
</html>
整个登陆页面的过程是这样的:
(1)获得用户的登陆信息
(2)连接数据库进行权限验证
(3)如果通过验证,那么读取用户的注册信息
(4)把用户的注册信息保存到一个userSession对象中
(5)把userSession对象保存到Session内建对象中
(6)把视图派发到下一个显示页面
注意:session.setAttribute("userSession",user)把userSession的一个对象设置到Session中,Session只能保存对象,不能保存原始的数据类型,比如:
session.setAttribute("count",10)
是非法的语句,如果要把值为10的整数保存到Session中,需要使用以下的方法:
session.setAttribute("count",new Integer(10));
然后在另一个页面使用
(Integer)session.getAttribute("count");
把这个整数读出来.
我们用如下方法在另一个页面中把userSesseion对象读取出来:
<%@page contentType="text/html;charset=gb2312" language="java"
import="java.sql.*,dory.*" errorPage=""%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
<%
   UserSession user=(UserSession)session.getAttribute("userSession");
   try
   {
       if(user.isLogin())
       {
           out.print("welcome,your login id is:"+user.getUserId());
           out.print("your last login time is:"+user.getLastLoginTime());
           out.print("now you are the:"+user.getLogCount()+"times logging this website");
       }
       else
       {
           response.sendRedirect("login.html");
       }
   }
   catch(Exception e)
   {
       response.sendRedirect("login.html");
   }
%>
    </body>
</html>
可以看出,通过UserSession user=(UserSession)session.getAttribute("userSession");代码来读取在前一个页面中设置的对象,然后再从这个对象读取一些相关值.当然我们也可以用JavaBean的形式来读取.

2.使用隐含菜单
这种方式通过隐含菜单的形式把数据传递到下一个页面,它有两个局限性:
.只能在相邻的两个页面之间传递数据
.客户端可以使用查看网页源代码的方式获得表单中的数据,安全性不好
它的实现很简单:
<form action="target.jsp">
<input type="hidden" name="test" value="abc">
<input type="hidden" name="test2" value="def">
</form>
在另外一个页面中,通过这样来获得数据:
String test=request.getParameter("test");
String test2=request.getParameter("test2");

3.使用Cookie
和Session不同,Cookie是放在客户端的,由于客户考虑到安全应素可能会禁用cookie,这样在使用cookie就会遇到麻烦了.

b.在不同的用户之间共享数据
在不同的在不同的用户之间共享数据最常见的方法是使用ServletContext和application对象,通过在一个用户那里设置属性在另一个用户那里获得这个属性.

1.使用ServletContext
在JSP页面中可以通过getServletContext()方法获得ServletContext对象.在这种情况下不同的用户通过它来工享数据,看下面的实现代码:
<%@page contentType="text/html;charset=gb2312" language="java"
import="java.sql.*,javax.servlet.*,javax.servlet.http.*,dory.*" errorPage="" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<%
   request.setCharacterEncoding("gb2312");
%>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
        <title>JSP Page</title>
    </head>
    <body>
    a simple chatting room
    <br><hr><font color="red">
<%
   String content=(String)getServletContext().getAttribute(new String("chatTopic_1"));
   out.print(content);
   getServletContext().setAttribute("chatTopic_1",content+(String)request.getParameter("content")
   +"<br>");
%>
    </font>
    <hr>
    <form accept="Servelt Context_chat.jsp">
        <input type="text" name="content">
        <input type="submit" value="speak">
    </form>
    </body>
</html>

2.application对象
application对象对应于每个web应用来说只有一个,它使用和ServletContext差不多.如下:
<%@page contentType="text/html;charset=gb2312" language="java"
import="java.sql.*,javax.servlet.*,javax.servlet.http.*,dory.*" errorPage="" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<%
   request.setCharacterEncoding("gb2312");
%>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
        <title>JSP Page</title>
    </head>
    <body>
    a simple chatting room
    <br><hr><font color="red">
<%
   String content=(String)application.getAttribute(new String("chatTopic_1"));
   out.print(content);
   application.setAttribute("chatTopic_1",content+(String)request.getParameter("content")
   +"<br>");
%>
    </font>
    <hr>
    <form accept="Servelt Context_chat.jsp">
        <input type="text" name="content">
        <input type="submit" value="speak">
    </form>
    </body>
</html>
可以得到ServletContext和application的实现机制基本上一致.

posted @ 2006-06-20 13:05 蓝色Saga 阅读(274) | 评论 (0) | 编辑收藏

分享网上资源

多学习别人才能进步，多交流才能收获，这里分享给大家一些网络资源.

=====================================================================================
国内外JSP/Java/Servlet技术著名网站

http://www-900.ibm.com/developerWorks/cn
http://java.sun.com
http://www.jchq.net
http://jquest.webjump.com/
http://www.chinaasp.com/ (国内)
http://www.cnjsp.com/ (国内)
http://www.javaunion.org/ (国内)
http://www.jspchina.com/ (国内)

国内外介绍JSP/Servlet应用程序服务器的网站

http://www.allaire.com/
http://jakarta.apache.org/
http://java.apache.org/
http://www.atg.com/
http://www.bea.com/
http://www.beasys.com/
http://www.bluestone.com/
http://caucho.com/
http://easythings.iwarp.com/
http://www.fefionsoftware.com
http://www.gemstone.com/
http://www.software.ibm.com/
http://www.inprise.com/
http://sun.com/software/
http://www.tagtraum.com/
http://www.enhydra.com/
http://www.mortbay.com/
http://www.novocode.com/
http://www.oracle.com/
http://www.orionserver.com/
http://www.paralogic.com/
http://www.pramati.com/
http://www.secant.com/
http://www.servertec.com/
http://www.silverstream.com/
http://www.siteforum.com/
http://www.unify.com/
http://www.vqsoft.com/
http://www.w3.org/

国内外介绍 JSP/Java/Servlet开发工具的网站

http://www.adobe.com/
http://www.bea.com/
http://www.software.ibm.com/
http://www.inprise.com/
http://www.macromedia.com/
http://www.netbeans.org/
http://www.netobjects.com/
http://www.oracle.com/
http://www.sun.com/
http://www.eclipse.com/

FAQ网站

http://www.jguru.com/
http://java.sun.com/products/jsp/faq.html
http://www.esperanto.org.nz/
http://www.jchq.net/

繁体资源

http://www.javaworld.com.tw/jute或http://www.jsptw.com/jute
http://www.jsp.mlc.edu.tw

posted @ 2006-06-19 14:49 蓝色Saga 阅读(285) | 评论 (0) | 编辑收藏

正则表达式之---基础学习

正则表达式

.正则表达式及其作用
.RegExp对象
.String对象中与正则表达式有关的方法
.正则表达式的语法参考
.实用程序举例

什么是正则表达式?
.文件路径通配符
"?"通配符匹配文件名中的单个字符，而"'"通配符匹配零个或多个字符。data?.dat就是一中文
本模式，它能匹配data1.dat,data2.dat,datax.dat,dataN.dat等文件名。data*.dat是另一种文
本模式，它匹配data.dat,data1.dat,data2.dat,data12.dat,datax.dat等文件名。

.正则表达式
是由英文词语regular expression翻译过来的，英文比中文更能实现其含义，就是符合某种规则
的表达式。可以将正则表达式理解为一种对文件进行模糊匹配的语言，它用一些特殊的符号（称
为元字符）来代表某种特征（例如，全都是数字）的一组字符以及指定匹配的次数，含有元字符
的文本不再表示某一具体的文本内容，而是形成了一种文本模式，它可以匹配符合这种模式的所
有文本串。

元字符与子匹配
.元字符
如果一个图书的编号格式是:要么是5个数字字符，例如,10101;要么是5个数字后加上一个连字号
(-)，再加上4个数字组成的10个字符，例如，11111-1234。那么，要在一个大的文本串中查找这
两种格式的图书编号时，就可以用\d{5}(-\d{4})?做为匹配模式。
如果要让abc?中的bc同时受到?的作用，必须使用圆括号将他们括起来，使它们成为一个紧密结合
的组合项，这样后面的?就表示圆括号中的内容可有可无，例如,a(bc)?能匹配a和abc。

.字匹配
圆口号所括起来的部分为一个子匹配（也叫子表达式），除了可以得到整个正则表达式的匹配
结果外，还可以单独得到每个子表达式部分所匹配的结果。
多个子表达式所匹配的原始内容按照它们正则表达式模式中从左到右出现的顺序存储在缓冲区中
，这种过程称为捕获。圆括号中的子匹配所捕获的内容可在整个表达式中位于这个括号之后的
地方被反引用，第一括号（即第一个子匹配）捕获的内容用\1表示，第二个圆括号（即第二个子
匹配）捕获的内容\2表示，依次类推。例如，要匹配2个相同的连续字符的正则表达式为(\d)\1.
要匹配连续5个相同的数字字符的正则表达式为(\d)\1{4}.要匹配1221.3553.6776等数字。可以
使用正则表达式为(\d)(\d)\2\1。

正则表达式的作用
.测试字符串是否匹配某个模式，从而实现数据格式的有效性验证。
.将一段文本中满足某一正则表达式模式的文本内容替换为别的内容或删除（即替换为空字符串）
例如，将一大段文本中的所有的19xx年的内容替换为20xx年，其中xx部分是两个任意的数字，
不会被替换，但不能简单地用20替换19，否则1919就被替换为2020。
.在一段文本中搜索具有某一类型特征的文本内容。精确搜索和正则表达式的模式搜索最大的区
别就是：精确搜索是搜索一个具体的文本，而模式搜索是模式搜索具有某一类型特征的文本。

RegExp对象
JavaScript中提供了一个名为RegExp的对象来完成有关正则表达式的操作和功能，每一条正则
表达式模式对应一个RegExp对象实例。

创建RegExp对象实例
(1)使用RegExp对象的显示构造函数，语法为:new RegExp("pattern"[,"flags"]);
(2)使用RegExp对象的隐式构造函数，采用纯粹的文本格式:/pattern/[flags]

flags标志字符：
     -g 用做全局标志
     -i 用做忽略大小写标志
     -m 用做多行标志
     如果没有设置这个标志，那么元字符"^"只与整个被搜索字符串的开始位置相匹配，而元字符
     "$"只与整个被搜索字符串的结束位置相匹配。如果设置了这个标志，那么"^"还可以与被
     搜索字符串中的"\n"或"\r"之后的位置相匹配。
注意:
当使用构造函数的方式创建RegExp实例对象的时候，应将原始的正则表达式模式文本中的每个
"\"都使用"\\"来替换，例如，下面的语句等价:
   var re=new RegExp("\\d{5}");
   var re=^d{5}/

RegExp对象-属性
.所有RegExp对象实例共享静态属性
.单个对象实例的属性
静态属性:
.index
.input
.lastIndex
.lastMatch
.lastParen
.lastContext
.leftContext
.rightContext
.$1...$9

对象实例属性:
.global
.ignoreCase
.multiline
.source

RegExp对象-方法
.test方法
语法格式为:test(str)。检查一个字符串中是否存在创建RegExp对象实例所指定的正则表达式模式
.exec方法
语法格式为:exec(str)。使用创建RegExp对象实例时所指定的正则表达式模式对一个字符串执行
搜索，并返回一个包含搜索结果的数组。
.compile方法
语法格式为:compile("pattern"[,"flags"])。更换RegExp对象实例所使用的正则表达式模式，并
将新的正则表达式模式编译为内部格式，从而使以后的匹配过程执行更快。

RegExp对象-综合举例
code:
<script language="javascript">
    var strSrc="xxa1b01c001yya2b02c002zz";
    var re="/a(\d)b(\d{2})c(\d{3})/gi";
    var arr,count=0;
    while((arr = re.exec(strSrc))!=null)
    {
       displayResult();
    }
    function displayResult()
    {
      document.write(<p>这是用正则表达式/"+re.source+"/gi对字符串<br>\""
                 +RegExp.input+ "\"进行第" +(++count)+ "次搜索的结果:<br>");
      document.write("RegExp.index为"+RegExp.index+"<br>");
      document.write("RegExp.lastindex为"+RegExp.lastindex+"<br>");
      document.write("RegExp.lastMatch为"+RegExp.lastMatch+"<br>");
      document.write("RegExp.lastParen为"+RegExp.lastParen+"<br>");
      document.write("RegExp.lastContext为"+RegExp.lastContext+"<br>");
      document.write("RegExp.$1为"+RegExp.$1+"<br>");
      document.write("RegExp.$1为"+RegExp.$2+"<br>");
      document.write("RegExp.$1为"+RegExp.$3+"<br>");
      document.write("RegExp.$1为"+RegExp.$4+"<br>");
      document.write("arr.index为"+arr.index+"<br>");
      document.write("arr.input为"+arr.input+"<br>");
      document.write("arr.lastindex为"+arr.lastindex+"<br>");
      document.write("返回的元素个数为"+arr.length+"<br>");
      document.write("返回数组的类容为[");
      for(var i=0;i<arr.length;i++)
      {
         if(arr.length-1)
            document.write("\""+arr[i]+"\",");
         else
            document.write("\""+arr[i]+"\"]</p>");
      }

    }
</script>

String对象中与正则表达式有关的方法
.match方法
语法格式为:match(Exp)。与RegExp对象的exec方法类似，它使用正则表达式模式对字符串执行
搜索，并返回一个包含搜索结果的数组。
<script language="javascript">
   var strSrc="xxa1b01c001yya2b02c002zz";
   var re=/a(\d)b(\d(2))c(\d{3})/gi;
   var arr;
   arr=strSrc.match(re);
   for(var i=0;i<arr.length;i++)
   {
      if(i<arr.length-1)
         document.write("[\""+arr[i]+"\",");
      else
         document.write("\""+arr[i]+"\"]");
   }
</script>

.search方法
语法格式为:serach(rgExp)。返回使用正则表达式搜索时，第一个匹配的字符串在整个被搜索
的字符串中的位置。
.replace方法
语法格式为: replace(rgExp,replaceText)。使用正则表达式模式对字符串执行搜索，并对搜索
到的内容用指定的字符串替换，返回值包含替换后的内容的字符串对象。

posted @ 2006-06-15 18:06 蓝色Saga 阅读(201) | 评论 (0) | 编辑收藏

视频教程分享之-软件工程

给大家分享一个视频教程-软件工程,CSF格式的,或许大家有和我一样用得着的，如果你需要就抓紧时间下载吧,白天相对来说速度快点，晚上就比较慢了，也不一定.希望可以给你提供点帮助.现把目录列举如下:
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
课程名称：软件工程
总学时：32讲
主讲老师：刘亚军
要下载抓紧时间，下载地址经常变动
授课目录：
第1讲软件过程背景、目的
第2讲软件质量评价、软件开发方法和开发工具可行性研究与计划
第3讲成本效益分析
第4讲需求分析基本理论、结构化分析概述、数据流图
第5讲数据流图基本充分、由外向里画数据流图
第6讲分层数据流图、由顶向下画数据流图、实例
第7讲数据流图的改进、数据词典
第8讲小说明、分析的步骤，SA方法小结、快速原型法
第9讲基本概念、概要设计

第10讲块间联系、块内联系
第11讲影响范围、控制范围、变换分析
第12讲变换分析、事务分析
第13讲详细设计、JACSON方法
第14讲编程方法、软件测试基本概念
第15讲白盒测试法
第16讲白盒测试法举例
第17讲黑盒测试法
第18讲黑盒测试法举例
第19讲维护方法
第20讲面向对象开发方法(1)
第21讲面向对象开发方法(2)
第22讲面向对象开发方法(3)
第23讲面向对象开发方法(4)
第24讲软件工具和环境，案例分析(1)
第25讲案例分析(2)
第26讲案例分析(3)
第27讲案例分析(4)
第28讲课堂练习模拟试卷一美
第29讲模拟试卷一
第30讲模拟试卷二
第31讲模拟试卷二
第32讲模拟试卷二开发方法比较

下载地址:
http://202.119.2.197/netcourses/评比课件/软件工程/软件工程01.csf
....................
http://202.119.2.197/netcourses/评比课件/软件工程/软件工程32.csf

If you need them! Be quick!

posted @ 2006-06-14 16:46 蓝色Saga 阅读(1197) | 评论 (3) | 编辑收藏

XML文档的结构

XML文档结构包含下面三个部分:
* 声明部分,声明该文档是一个XML文档.
* 定义部分,定义XML数据的类型以及所使用的DTD(可选).
* 内容部分,用XML标签和注释标注过的文档类容.

声明

XML文档以XML声明开头,声明本文档是一个XML文档.一般这样书写:
<? xml version encoding standalone?>
定义符<?和?>表示这是一条给XML解析器的处理指令.虽然声明这条语句是可有可无的,但考虑到以后的兼容,建议读者还是写上为好.随着语言的进一步发展,以后的浏览器如果知道文档所用的XML版本的话,将是有好处的.这天语句必须全部用小写.
在上面的声明中version表示的XML的标准版本号.encoding表示的是文档所用的编码.standalone用来指定在XML文档被解析之前,是否使用外部或内部DTD,它的值只能是yes或no.如果为no,表示使用外部DTD;如果为yes表示使用内部DTD;如果不使用DTD,则不使用这个属性.
看下面的实际例子:
<?xml version="1.0" encoding="UTF-8" standalone="yes">
在XML声明之后,紧接着是类型定义部分,定义XML文档中数据的类型.

文档定义类型(DTD)

DTD是用来定义XML文档内容的结构的,以便按统一的格式存储信息.DTD规定了XML文档中可以出现哪些元素;这些元素是必须的还是可选的;这些元素有什么属性;以及它们之间的相互位置关系,等等.XML允许用户为自己的应用程序定义专用的DTD,这样用户就可以完全检查文档结构和内容的过程了.这一检验过程称为有效化,严格依从一个DTD的XML文档被称作有效文档.
创建DTD的过程与在数据库里创建数据表是类似的.在DTD中,用户定义用来表示数据的元素,然后规定数据的结构,并规定这个元素是可选的还是必须的,这就好比创建数据表的列；然后你把数据存入XML文档,就好比添加数据表的记录.
XML文档使用的元素可以在内部DTD中定义,也可以在外部DTD中定义.

内部DTD
DTD可以作为文档的一部分直接放到文档里面,这样的DTD只能用于包含它的这个文档,别的文档就不能使用了.创建内部DTD的语法如下:
<!DOCTYPE rootelement
[element and attribute declarations]
>
<!DOCTYPE标识文档类型定义的开始,属性rootelement指明跟元素名字.

为部DTD
外部DTD是一个单独的文件,存放XML文档中可以使用的全部元素及属性的定义.你可以在多个文档中同时使用同一个DTD,以便保持多个文档之间数据结构的一致性。
在XML文档中引用外部DTD的语法如下:
<!DOCTYPE rootelement [PUBLIC|SYSTEM] "name-of-file">
其中,DOCTYPE标识这是文档类型定义部分;rootelement代表根元素;PUBLIC表示这个DTD是存放在公用服务器上的;SYSTEM表示这个DTD是存放在本地计算机系统上的;Name-of-file是被引用的DTD文件的名称.

DTD字符
下表是DTD中使用的部分专用字符及其含义.

DTD字符

含义

举例

描述

指定顺序中的"与"

Firstname ,Lastname

Firstname与Lastname,以此顺序

"或"

Firstname | Lastname

Firstname或Lastname

"可选项',只能出现一次

Lastname?

可以不出现Lastname,但如果使用,则只能出现一次

()

用于组成元素

(Firstname | Lastname),Address

一个Firstname或Lastname元素必须出现在Address元素之前

该元素可以不出现也可以出现多次

(Firstname | Lastname)*

可以以任何顺序出现任意个数Firstname或Lastname元素

＋

该元素至少出现一次也可以出现多次

(Firstname +)

可以出现多个Firstname元素

在DTD中定义元素

元素是XML文件的基本组成部分.每个元素都是用标签标识的一小段数据.标签包括了元素的名字和属性.
XML允许用于创建自己的元素集.因此,元素名应该取得容易记忆,并且最好有一定的含义,让人一看到它,便对里面的数据有个大概的了解.XML是大小写敏感的,所以要么你全用大写,要么就一律用小写.
定义元素的语法如下:
<!ELEMENT elementname content>
在DTD中,你通过创建一个元素内容模型(element content model)来精确的规定一个元素中是否喊有其它元素,可以出现多少次以及按什么顺序出现.如果元素中只包含别的元素,而不包含字符数据,我们就说它只含有元素内容.

XML中命名元素的规则
* 元素名至少要含有一个字母(a-z或A-Z中的一个)
* 元素名可以用下划线(_)或冒号( : )开头.
* 第一个字符后面可以是一个或多个字母,数字,连字符,下划线或句号,但不能是空格和定位符(tab),至于标点符号只能使用连字符(-)和句号(.).

对于完整的命名规则,请参看http://www.w3.org/XML/上的在线XML介绍

元素类型
元素有空元素,自由元素和容器元素三种(如下表:)

元素类型	语法
空元素(Empty)	<!ELEMENT empty.element EMPTY>	<!ELEMENT empty.element EMPTY>
自由元素(Unrestricted)	<!ELEMENT any.element ANY>	<!ELEMENT any.element ANY>
容器元素(Container)	<!ELEMENT TITLE(#PCDATA)>	<!ELEMENT TITLE(#PCDATA)>

PCDATA 表示 parsable character data,既可解析的字符数据.为了避免将这一关键字与普通的元素名混淆起来，在此关键字前加前缀字符#.

分析下面的标签结构:
<student>
<firstname> Blove </firstname>
<lastname> Saga </lastname>
<rollno> 49 </rollno>
<score> 70 </score>
</student>
要使上面的文档生效,必须创建一个DTD,里面包含student,firstname,lastname,rollno,score等五个元素的定义.另外,还要规定这五个元素是必须的或可选的;以规定顺序或任意排序;以及它们出现的次数.用户为这些规定编写元素定义,每个元素的定义可能不同.
譬如,如果firstname和lastname都是必需的元素,并且firstname要在lastname后面,那么DTD可以这样编写:
<!ELEMENT student (firstname,lastname)>
<!ELEMENT firstname (#PCDATA)>
<!ELEMENT lastname (#CDATA)>
注意:
数据类型#CDATA表示元素包含字符型数据,解析器不解析这些数据,其中的标签是不作为标记的.
数据类型#PCDATA表示元素包含字的数据将由解析器解析,其中的标签是被作为标记处理.

posted @ 2006-06-13 16:42 蓝色Saga 阅读(487) | 评论 (0) | 编辑收藏

XML 文档的组件

XML 文档是一个含XML标记的ASCII文本文件,它的扩展名是.xml, 如: employee.xml在开始编写XML文档之前,你应该了解组成XML文档的各个部分.一个XML文档的主要成分包括:

* 元素
* 内容
* 属性
* 注释

元素
元素是XML文件的基本构造块,作为主要的标注组件,用来描述文件的内容.每一个元素用一个标签来表示一段文本信息.大部分标签是成对出现的,开始标签在数据的开始处,结束标签放在数据的末尾.开始标签和结束标签之间嵌有信心的元素称为容器元素.例如:
<Title> My Title </Title>
我们知道,上面语句中的Title是HTML里的元素,用来显示浏览器窗口的标题.在XML里，你可以创建自己的元素,如:
<empname> John Rambo </empname>
在上面的语句中,empname是由开始标记(<>)和结素标记(</>)定义的元素,嵌在这两个标签中的信息就是这个元素的内容.利用元素嵌套,你可以构建一个分层的结构.
也有一些标签不是成对出现的,被称作空元素.空元素不能包含的元素或数据,因为它没有开始和结束标签.最简单的空元素例子是用<BR>标签表示的断行元素.
在一个XML文件中,可以有一个或多个元素,但只能有一个根元素,根元素下面允许有多个子元素.

内容
在XML中,由元素表示的信息,称为内容.请看下面的例子:
<TITLE> LION KING </TITLE>
上面这行语句中,LION KING就是TITLE元素所表示的内容.

属性
属性提供元素的补充信息.每个属性有一个属性名和属性值,属性值可以是数字,单词,或URL.

在HTML中,我们经常使用字体元素的颜色属性,如:
<Font color="red">Displayed in red</Font>
其中,color是属性名,其属性值是red.
在XML中，属性值一律要加上引号.例如:
<empname doj="2006">John Rambo</empname>
这里,"2006"是doj属性(data of joining)的属性值,用来描述元素empname.

注释
注释是用来给XML文档加上注释的,浏览器和XML处理器都忽略注释,不加处理.使用注释的好处是能使所有使用XML文档的人都对文档中各种元素的用法一目了然.

要在XML文件中输入注释,可以依次输入一个小于号,一个感叹号和两个横杠,再输入注释的文本内容,并确保文本中没有两个横杠.这一点W3C规定的,以保持XML与SGML的兼容.最后输入两个横杠和一个大于号来结束注释.例如:

这就是注释.

结构良好的XML文档
一个结构良好的XML文档应该遵守以下五个基本规则:

* 标签不能隐含,必须显式出现.每一个起始标签必须有对应的结束标签;每一个结束标签也必须有对应的起始标签,对比一下HTML和XML的不同:

在HTML中,可以用下面的这段代码创建一个编号列表:
<OL>
<LI> Number list item one
<LI> Number list item two
<LI> Number list item three
</OL>
在上诉代码中,用<OL>和</OL>来表示这是一个顺序列表,用<LI>表示当前列表项的开始,而列表项的结束,则是靠后一列表项的开始来暗示的.如果这段代码出现在XML文档中,浏览器是不会正确解析这个页面的,
因为它并不是一个结构良好的文档.
XML文档中的标签必须显式出现，不能隐含.如果用XML实现上面的例子,必须这样书写:
<OL>
<LI> Number list item one</LI>
<LI> Number list item two</LI>
<LI> Number list item three</LI>
</OL>
从上面这个例子中,你能看到,第一个列表必须包含在开始标签和结束标签之间,以满足结构良好的XML文档的第一个规则.

* 空标签的结束字符'>'前必须使用'/'字符.
所谓空标签,是指标签的所有信息都放在它的分界符里,没有任何属于它的文本信息.比如象HTML中的<BR>和<IMG>,都不需要结束标签,因为标签里已经包含了所有的信息.

HTML中的标签全部是预定义的,浏览器能够直接识别.但是必须记住,XML中没有任何预定义的标签,用户为自己的页面定义自己的语言.正因为这样,XML并不能知道<BR>,<IMG>是空标签,你必须在标签的结束处加上斜杠(/),来指明他们是空标签.就像这样:
<BR/>
<IMG SRC="image.gif"/>

* 所有的属性值必须用双引号括起来.
在HTML当中,下面的语法是正确的:
<TD WIDTH="25%">
<TD WIDTH=25%>
然而在XML当中,由于属性值必须用引号括起来,所以只有前面一句和</TD>配合起来才是合法的.

* 标签不能交叠使用
比如说,下面这行语句就交叠起来了:
<CITY>Chicago<STATE>Michigan</CITY></STATE>
在XML中，必须从里到外地关闭标签,正确的顺序是:
<CITY>Chicago<STATE>Michigan</STATE></CITY>

* 标签大小写敏感,每次都必须严格匹配
在XML文档中,必须区分大小写,如果你写了如下的语句,将导致一个致命的错误(fatal error):
<P> Able was I, ere I saw Elba</p>
标签<P>不能用来关闭标签</p>,因为两者的大小写是不同的.所有的标签必须大小写严格匹配.

一个结构良好的XML文档,就是一个严格遵循XML标签规则,但没有文档类型定义(DTD, Document Type Definition)的文档.

posted @ 2006-06-13 13:08 蓝色Saga 阅读(380) | 评论 (0) | 编辑收藏

XML基础理解

理解XML

    XML表示可扩展标记语言(eXtensible Markup Language).其中,"可扩展"这个词意味着开发者能够自由扩展在描述文件方面的能力,可以为自己的应用程序定义有实际意义的标签.XML是基于文本的,允许开发者在各种应用程序之间传递和交换结构化数据,同时大大便利了不同服务器之间的数据传输.用XML表注的数据能够被所有的设备识别,从带主机的大型机和微型机,到掌上电脑和蜂窝电话.
    与诸如HTML,DHTML,CSS等其他网页技术相比,XML更注重数据的结构,而不是数据的表现形式.让我们看看下面的这段代码:
<B>XML Bible</B>
<P>
Elliotte Rusty Harold <BR>
IDG Books Worldwide <BR>
$39.99
    稍微看一下,你可能已经知道了,它将的是一本关于书的基本信息:作者,出版社,价格.但是,这里用作标记的元素,比如<B>,<P>等,并没有揭示出这是一本有关书的信息,它只是描述了这几行信息是如何显示的.比如，在第一行中用了<B>,就表示浏览器处理的时候,要以粗体字显示这行文本.
    同样对这些信息,我们用XML标注如下:
<BOOK>
<NAME>XML Bible</NAME>
<AUTHOR>Elliotte Rusty Harold</AUTHOR>
<PUBLISHER>IDG Books Worldwide</PUBLISHER>
<PRICE>$39.99</PRICE>
</BOOK>
    上面的小例子揭示出,通过定义一些有含义的标签,XML扩展了用户描述文件的能力.你可以根据应用程序的需要,定义任意多个标签.在上面的代码段中,没有任何关于如何显示信息的描述.XML将数据的结果与显示分离开来,这似乎不太合理,其实很有益处的.

使用XML的优越性

    XML不仅对数据从服务器到客户端的传输大有好处,对于应用程序之间的数据传输,也是十分理想的.我们将它的优越性列举如下:
* 可使用特定领域的词汇
* 数据交换
* 智能化查询
* 让用户选择显示的数据
* 局部更新

可使用特定领域的词汇
    XML是没有预定义标签的,你必须自己定义标签,用来标注你的数据.也就是说,你可以用XML创建自己的表注语言(称为XML词汇表).XML允许每个特定的行业根据需要定义自己的标签集合,这样浏览器就不必处理成千上万的标签集了.利用XML,已经创建了若干新的标记语言,比如W3C特别推荐的MathML,一种用于显示数学公式和科学数据的专用标记语言,就是基于XML的.

数据交换
    数据交换在进行电子商务的交易时是极为重要.数据交换的关键在于企业之间或企业内部部门之间的标准数据接口,使用存储格式不同的数据能够进行交换.XML为以文本格式式存储的数据提供了对于结构的定义和管理,可以作为数据交换的标准格式或协议,是数据交换双方的系统差异变得无关紧要,并且产生清晰易读的文件.XML避免了同类产品的一些常见弊病,如扩展性差,缺乏国际化和本地化的支持,平台相关等.作为一种非常健壮的数据交换格式,XML将继续发展,不断完善.

智能化查询
    由于XML的出现,只能搜索引擎将成为现实,可将XML文档中的数据进行智能化搜索,得到更精确的查询结果.为了更好的理解XML实现内容定义的意义,我们来比较一下下面的两个例子:
例1: The best pricture award in 1998 went to the film <I>Titanic</I>.
例2: The best pricture award in 1998 went to the film <FILM>Titanic<FILM>.
在第一例子中,搜索引擎并不能确定所涉及的一艘轮船,一场表演,一部电影,抑或是一个形容词.这样的搜索精度比较低.而在第二个例子中,你能知道"Titanic"是一部电影的名字.如果现在搜索引擎要搜索的是电影 "Titanic",那么在这个文档中就能找到一个精确的匹配项.

让用户选择显示的数据
      XML支持用户端的数据处理.用户可以选择一个,若干或全部数据记录,也可以按照不同的属性进行排序,或者切换到图形化查看方式,而且不需要服务器针对每一次操作发送数据.相同的数据可以用不同的方式来显示,也可以仅仅显示数据的一个子集,这些都取决于用户与这些数据的相对关系.比如,会计部门是可以访问财务信息的,而购买东西的顾客却不能反问这部分信息.

局部更新
      当需要更新XML文档中的数据时,并不需要更新整个页面,而只要重新下载那些变化了的数据,这显然加快了更新的速度.例如:股票交易中的数据是动态的,如果每次都更新整个页面的话,都需要很多时间.而使用XML,将只改变变化了的数据.

XML的设计目标
      XML是针对大规模的电子出版物的挑战来设计的,同时在Web数据的交换中也充当着越来越重要的角色.
根据W3C的有关文件,XML将在如下几个方面发挥重要作用:
* 实现国际化,独立于媒体的电子出版.
* 允许个产业部门制订与平台无关的数据交换协议,尤其针对电子商务数据交换的协议.
* 使用允许自动处理的格式,将信息传递给用户代理商
* 让人们用低价软件就可以实现数据处理
* 允许人们按照自己的方式显示信息
* 提供一种有关信息的数据(写作 metadata),以帮助人们寻找和发现信息,实现信息的生产者和消费者之间的双向寻找.

任何形式电子商务的成功,都有赖于一个公共词汇表的广泛使用.部分XML词汇表列举如下:

频道定义格式(CDF, Channel Definition Format)-一种基于XML的,用于创建web频道的数据格式.所谓web频道,是一种实现web服务器到客户端的数据自动发送的技术.

开放软件描述(OSD, Open Software Description)-用于网上自动安装软件,而不需要任何人工干预.

开放式金融交易(OFX, Open financial Exchange)-被个人金融应用程序用来作为个人和金融组织之间进行网上交流的工具.

Meta内容框架(MCF, Meta Content Framework)-用来定义关于信息的数据,以实现对信息的编目和搜索.

资源描述框架(RDF, Resource Description Framework)-用于描述各种类型的资源,以实现对资源的编目,搜索和引用.

无线标记语言(WML, Wireless Markup Language)-用于在无线网络上的数据奋发,采用无线访问协议.

化学标记语言(CML, Chemical Markup Language)-用来定义化学公式.

   数学标记语言(MathML, Mathematical Markup Language)-用来定义复杂的数学公式.

posted @ 2006-06-13 12:02 蓝色Saga 阅读(205) | 评论 (0) | 编辑收藏

Java Basic-Java I/O(二)

编码：将一个Unicode码转换为本地字符表示的过程为编码。
解码：将一个字节转换为一个字符（用Unicode表示），这个过程叫解码。
[简单的说去获取一个Unicode码就是解码]
code:

import java.util.*;
import java.nio.charset.*;
class CharsetTest
{
public static void main(String[] args)throws Exception
{
  /*
  Map m=Charset.availableCharsets();
  Set names=m.keySet();
  Iterator it =names.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  Properties pps=System.getProperties();
  //pps.list(System.out);
  pps.put("file.encoding","ISO-8859-1");
  int data;
  byte[] buf=new byte[100];
  int i=0;
  while((data=System.in.read())!='q')
  {
   buf[i]=(byte)data;
   i++;
  }
  String str=new String(buf,0,i);
  //String strGBK=new String(str.getBytes("ISO-8859-1"),"GBK");
  //System.out.println(strGBK);
  System.out.println(str);
}
}

RandomAccessFile

RandomAccessFile类同时实现了DataInput和DataOutput接口，提供了对文件随机存取的功能，
利用这个类可以在文件的任何位置读取或写入数据。
RandomAccessFile类提供了一个文件指针，用来标志要进行读写操作的下一位数据的位置。

code:
import java.io.*;
class RandomFileTest
{
public static void main(String[] args)throws Exception
{
  Student s1 = new Student(1,"zhangsan",98.5);
  Student s2 = new Student(2,"lisi",90.5);
  Student s3 = new Student(3,"wangwu",78.5);

  RandomAccessFile rsf=new RandomAccessFile("student.txt","rw"); //存取模式rw
  s1.WriteStudent(rsf);
  s2.WriteStudent(rsf);
  s3.WriteStudent(rsf);

  Student s =new Student();
  rsf.seek(0); //把文件指针移到文件首
  for(long i=0;i<rsf.length();i=rsf.getFilePointer())
  {
   s.ReadStudent(rsf);
   System.out.println(s.num+":"+s.name+":"+s.score);
  }
  rsf.close();
}
}

class Student
{
int num;
String name;
double score;
Student()
{

}
Student(int num,String name,double score)
{
  this.num=num;
  this.name=name;
  this.score=score;
}
public void WriteStudent(RandomAccessFile raf)throws Exception
{
  raf.writeInt(num);
  raf.writeUTF(name);
  raf.writeDouble(score);
}
public void ReadStudent(RandomAccessFile raf)throws Exception
{
  raf.readInt();
  raf.readUTF();
  raf.readDouble();
}
}

对象序列化

.将对象转换为字节流保存起来，并在日后还原这个对象，这种机制叫做对象序列化。
.将一个对象保存到永久存储设备上称为持续性。
.一个对象要想能够实现序列化，必须实现Serializable接口或Externalizable接口。
.当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员变量和静态的
成员变量。
.如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
.如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，
并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient,那么对象
仍然可以序列化。

code:
import java.io.*;
class ObjectSerialTest
{
public static void main(String[] args)throws Exception
{
  Employee e1 = new Employee("zhangsan",20,2800.50);
  Employee e2 = new Employee("lisi",22,25000.50);
  Employee e3 = new Employee("wangwu",23,12800.50);
  Employee e4 = new Employee("blovesaga",22,3800.50);

  FileOutputStream fos=new FileOutputStream("employee.txt");
  ObjectOutputStream oos=new ObjectOutputStream(fos);
  oos.writeObject(e1);
  oos.writeObject(e2);
  oos.writeObject(e3);
  oos.writeObject(e4);
  oos.close();

  FileInputStream fis = new FileInputStream("employee.txt");
  ObjectInputStream ois =new ObjectInputStream(fis);
  Employee e;
  for(int i=0;i<4;i++)
  {
   e=(Employee)ois.readObject();
   System.out.println(e.name+":"+e.age+":"+e.salary);
  }
  ois.close();
}
}

class Employee implements Serializable
{
String name;
int age;
double salary;
transient Thread t1 =new Thread();
Employee(String name,int age,double salary)
{
  this.name=name;
  this.age=age;
  this.salary=salary;
}
//可以写private void readObject()方法来控制我们自己想要实现的
private void writeObject(java.io.ObjectOutputStream oos)throws Exception
{
  //例如我们自己写想要显示的顺序和那些需要显示
  oos.writeInt(age);
  oos.writeUTF(name);
  System.out.println("Write Object");
}
private void readObject(java.io.ObjectInputStream ois)throws Exception
{
  //按照写入的顺序来读取
  age=ois.readInt();
  name=ois.readUTF();
  System.out.println("Read Object");
}
}

posted @ 2006-06-11 21:27 蓝色Saga 阅读(134) | 评论 (0) | 编辑收藏

基础学习之---Java I/O学习(一)

File类

一个File类的对象，表示了磁盘上的文件或目录。
File类提供了与平台无关的方法来对磁盘上的文件或目录进行操作。

import java.io.*;
class FileTest
{
public static void main(String[] args) throws Exception
{
  //File f = new File("1.txt");
  //f.createNewFile();   创建文件
  //f.mkdir(); 创建文件夹
  //File f = new File("F:\\Java Develop\\1.txt");//使用绝对路径
  //f.createNewFile();
  /*
  *WINDOWS平台下有盘符，LINUX下是没有的
  *考虑到JAVA语言的平台性，所有用分隔符seperator/seperatorChar
  */
  /*
  File fDir = new File(File.separator);//创建了当前的根目录
  String strFile = "Java Develop"+File.separator+"1.txt";
  File f = new File(fDir,strFile);
  f.createNewFile();
  //f.delete();
  f.deleteOnExit();
  Thread.sleep(3000);
  */
  /*
  for(int i=0;i<5;i++)
  {
   File.createTempFile("linshi",".tmp");
   f.deleteOnExit();
  }
  Thread.sleep(3000);
  */

  File fDir = new File(File.separator);
  String strFile ="Java Develop"+File.separator;
  File f = new File(fDir,strFile);
  //文件过滤器
  String[] names = f.list(new FilenameFilter()
  {
   public boolean accept(File dir,String name)
   {
    return name.indexOf(".java")!=-1;
   }
  });
  for(int i=0;i<names.length;i++)
  {
   System.out.println(names[i]);
  }
}
}

流式I/0

流(Stream)是字节的源或目的。
两种基本的流是: 输入流(Input Stream)和输出流(Output Stream)。从从中读出一系列字节的
对象称为输入流。而能向其中写入一系列字节的对象称为输出流。

流的分类

节点流: 从特定的地方读写的流类，例如：磁盘或一块内存区域。
过滤流: 使用节点作为输入或输出。过滤流使用的是一个已经存在的输入流或输出流连接创建的。
(如下图)

         InputStream(一个抽象的基类)
.三个基本的读写方法
abstract int read(): 读取一个字节数据，并返回到数据，如果返回-1，表示读到了输入流的
                       末尾。
int read(byte[] b): 将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，
                       表示读到了输入流的末尾。
int read(byte[] b,int off,int len): 将数据读入一个字节数组，同时返回是实际读取的字
                       节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放
                       数据的起始偏移位置；len指定读取的最大字节数。
其他的方法
long-skip(long n): 在输入流中跳过n个字节，并返回实际跳过的字节数。
int available():   返回在不发生阻塞的情况下，可读取的字节数。
void close():      关闭输入流，释放和这个流相关的系统资源。
void mark(int reqdlimit): 在输入流的当前位置放置一个标记，如果读取的字节数多余
                     readlimit设置的值，则流忽略这个标记。
void reset():      返回到上一个标记。
boolean markSupported(): 测试当前是否支持mark和reset方法。如果支持返回true，反之false。

java.io包中的InputStream的类层次 (下图)

OutputStream

三个基本的写方法
abstract void write(int b): 往输出流中写入一个字节
void write(byte[] b): 往输出流中写入数组b中的所有字节
void writte(byte[] b,int off,int len): 往输出流中写入数组b中从偏移量off开始的len个
字节的数据
其它方法
void flush(): 刷新输出流，强制缓冲区中的输出字节被写出
void close(): 关闭输出流，释放和这个流相关的系统资源

java.io包中OutputStream的类层次(如下图)

基本的流类

FileInputStream和FileOutputStream
节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经
存在，则覆盖这个文件。

BufferedInputStream和BufferedOutputStream
过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。

DataInputStream和DataOutputStream
过滤流，需要使用已经存在的节点流来构造,提供了读写Java中的基本数据类型的功能。

PipedInputStream和PipedOutputStream
管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream
对象读取输入。要使管道流有用，必须同时构造管道输入流和管道输出流。

code:
import java.io.*;
class StreamTest
{
public static void main(String[] args)throws Exception
{
  /*
  int data;
  while((data=System.in.read())!=-1) //从标准设备读取数据
  {
   System.out.write(data);//从标准设备输出数据
  }
  */
  //输出流写数据,只需要关闭尾端的流就可以了，因为fos连接到了bos
  FileOutputStream fos = new FileOutputStream("1.txt");
  //fos.write("http://www.google.cn".getBytes());
  //fos.close();
  BufferedOutputStream bos = new BufferedOutputStream(fos);
  //bos.write("http//www.baidu.com".getBytes());
  //bos.flush();
  //bos.close();
  DataOutputStream dos=new DataOutputStream(bos); //连接到了bos和fis
  byte b=3;
  int i=78;
  char ch='a';
  float f=4.5f;
  dos.writeByte(b);
  dos.writeInt(i);
  dos.writeChar(ch);
  dos.writeFloat(f);
  dos.close(); //必须调用flush()或者close()不然不会写入硬盘

  //输入流读数据
  FileInputStream fis=new FileInputStream("1.txt");
  BufferedInputStream bis = new BufferedInputStream(fis);
  //byte[] buf=new byte[100];
  //int len=fis.read(buf);
  //int len=bis.read(buf);
  //System.out.println(new String(buf,0,len));
  //fis.close();
  //bis.close();
  //注意读取的顺序要和写的顺序一样
  DataInputStream dis = new DataInputStream(bis);
  System.out.println(dis.readByte());
  System.out.println(dis.readInt());
  System.out.println(dis.readChar());
  System.out.println(dis.readFloat());
  dis.close();

}
}

管道输入/输出流 code:
import java.io.*;
class PipedStreamTest
{
public static void main(String[] args)
{
  PipedOutputStream pos=new PipedOutputStream();
  PipedInputStream pis=new PipedInputStream();
  //连接
  try
  {
   pos.connect(pis);
   new Producer(pos).start();
   new Consumer(pis).start();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

class Producer extends Thread
{
private PipedOutputStream pos;
public Producer(PipedOutputStream pos)
{
  this.pos=pos;
}
public void run()
{
  try
  {
   pos.write("hello,welcome!".getBytes());
   pos.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

class Consumer extends Thread
{
private PipedInputStream pis;
Consumer(PipedInputStream pis)
{
  this.pis=pis;
}
public void run()
{
  try
  {
   byte[] buf=new byte[100];
   int len=pis.read(buf);
   System.out.println(new String(buf,0,len));
   pis.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

=================================================================================
Java I/O库的设计原则

Java的I/O库提供了一个称做链接的机制，可以将一个流与另一个流首尾相接，形成一个流管道的链接。
这种机制实际上是一种被称做为Decorator(装饰)的设计模式的应用。

通过流的链接，可以动态的增加流的功能，而这些功能的增加是通过组合一些流的基本功能而动
态获取的。

我们要获取一个I/O对象，往往需要产生多个I/O对象，这也是Java I/O库不大容易掌握的原因，
但在I/O库中的Decorator模式的运用，给我们提供了实现上的灵活性。

I/O流的链接图(如下)

Reader和Writer

Java程序语言使用Unicode来表示字符串和字符。
Reader和Writer这两个抽象类主要用来读写字符流。

java.io包中Reader的类层次(如下图)

java.io包中Writer的类层次(如下图)

code:
import java.io.*;
class StreamTest
{
public static void main(String[] args)throws Exception
{
  /*
  FileOutputStream fos = new FileOutputStream("1.txt");
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  BufferedWriter bw = new BufferedWriter(osw);

  bw.write("http://www.yahoo.com.cn");
  bw.close();

  FileInputStream fis = new FileInputStream("1.txt");
  InputStreamReader isr = new InputStreamReader(fis);
  BufferedReader br = new BufferedReader(isr);
  System.out.println(br.readLine());
  br.close();
  */
  //InputStreamReader/OutputStreamWriter是一个中间过度类,连接字符和字符串
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  String strLine;
  while((strLine=br.readLine())!=null)
  {
   System.out.println(strLine);
  }
  br.close();
}
}

字符集的编码

ASCII(American Standard Code for Information Interchange,美国信息互换标准代码),是基
于常用的英文字符的一套电脑编码系统。我们知道英文中经常使用的字符，数字符号被计算机
处理时都是以二进制编码的形式出现(bit)二进制数对应。其最高位是0，相应的十进制数是0-127
如，数字1，有一些制表符和其他符号组成。ASCII是现金最通用的单字节编码系统。

GB2312： GB2312码是中华人民共和国国家汉字信息交换用编码，全称《信息交换用汉字编码字
符集-基本集》。主要用于给每一个中文字符指定相应的数字，也就是进行编码。一个中文字符
用两个字节的数字来表示，为了和ASCII码有所区别，将中文字符每一个字节的最高位置都用1
来表示。

GBK：为了对更多的字符进行编码，国家又发布了新的编码系统GBK（GBK的K是“扩展”的汉语
拼音的第一个字母）。在新的编码系统里，除了完全兼容GB2312外，还对繁体中文，一些不常用
的汉字和许多符号进行了编码。

ISO-8859-1：是西方国家所使用的字符编码集，是一种单字节的字符集，而英文实际上只用了其
中数字小于128的部分。

Unicode: 这是一种通用的字符集，对所有语言的文字进行统一编码，对每一个字符都采用2个字节
来表示，对于英文字符采取前面加“0”字节的策略实现等长兼容。如"a"的ASCII码为0x61,
UNICODE就为0x00,0x61。

UTF-8: Elight-bit UCS Transformation Format,(UCS,Universal Character Set,通用字符集,
UCS是所有其他字符集标准的一个超集)。一个7位的ASCII码值，对应的UTF码是一个字节，如果
字符是0x0000，或在0x0080与0x007f之间，对应的UTF码是两个字节，如果字符在0x0800与0xffff
之间，对应的UTF码是三个字节。

posted @ 2006-06-11 14:18 蓝色Saga 阅读(694) | 评论 (1) | 编辑收藏

集合框架中的接口

     Collection                   Map(和Collection接口没任何关系)
       / \                         |
      /   \                        |
    Set   List                  SortedMap
    /
   /
SortedSet
(接口图)

所谓框架就是一个类库的集合。集合框架就是一个用来表示和操作集合的统一框架，包含了实现
集合的接口和类。

集合框架中的接口

.Collection: 集合层次中的根接口，JDK没有提供这个接口直接的实现类。
.Set: 不能包含重复的元素。SortedSet是一个按照升序排列元素的Set。
.List: 是一个有序的集合，可以包含重复的元素。提供了按照索引访问的方式。
.Map: 包含了key-value对。Map不能包含重复的key。SortedMap是一个按照升序排列key的Map。

集合框架中的实现类

实线表示继承类，虚线表示实现类。
(图如下)

.ArrayList: 我们可以将其看做是能够自动增长容量的数组。
.利用ArrayList的toArray()返回一个数组。
.Arrays.asList()返回一个列表。
.迭代器(Iterator)给我们提供了一种通用的方式来访问集合中的元素。

注意: 从集合类中获取一个数组 toArray(),从数组获取列表利用Arrays.asList()
例子:
import java.util.*;
class ArrayListTest
{
public static void printElement(Collection c)
{
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
}
public static void main(String[] args)
{
  ArrayList a = new ArrayList();
  /*
  a.add("abc");
  a.add("def");
  a.add("hjk");
  */

  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));
  /*
  Object[] o;
  o=a.toArray(); //将集合类转换为数组
  for(int i=0;i<o.length;i++)
  {
   System.out.println(o[i]);
  }

  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);

  for(int i=0;i<a.size();i++)
  {
   System.out.println(a.get(i));
  }

  System.out.println(a);
  System.out.println(a);
  */

  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用next方法
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //迭代器的作用: 提供一组通用的访问方式
  printElement(a);
}
}

class Point
{
int x, y;
Point(int x, int y)
{
  this.x=x;
  this.y=y;
}
public String toString()
{
  return "x="+x+","+"y="+y;
}
}

Collections类

.排序: Collections.sort(); [区别与Arrays.sort()]
(1) 自然排序(natural ordering);
(2) 实现比较器(Comparator)接口。
.取最大和最小的元素: Collections.max(),Collections.min();
.在已排序的List中搜索指定的元素: Collections.binarySearch()。

代码示例:
import java.util.*;
class ArrayListTest
{
public static void printElement(Collection c)
{
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
}
public static void main(String[] args)
{
  /*
  ArrayList a = new ArrayList();

  a.add("abc");
  a.add("def");
  a.add("hjk");


  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));

  Object[] o;
  o=a.toArray(); //将集合类转换为数组
  for(int i=0;i<o.length;i++)
  {
   System.out.println(o[i]);
  }

  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);

  for(int i=0;i<a.size();i++)
  {
   System.out.println(a.get(i));
  }

  System.out.println(a);
  System.out.println(a);
  */

  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用next方法
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //迭代器的作用: 提供一组通用的访问方式
  //printElement(a);

  Student s1 = new Student(1,"zhangsan");
  Student s2 = new Student(2,"lisi");
  Student s3 = new Student(3,"wangwu");
  Student s4 = new Student(3,"blovesaga");

  ArrayList a = new ArrayList();
  a.add(s1);
  a.add(s2);
  a.add(s3);
  a.add(s4);

  //Collections.sort(a);
  Collections.sort(a,new Student.StudentComparator());
  printElement(a);
}
}

class Point
{
int x, y;
Point(int x, int y)
{
  this.x=x;
  this.y=y;
}
public String toString()
{
  return "x="+x+","+"y="+y;
}
}

class Student implements Comparable
{
int num;
String name;
//实现比较器，它总是和我们的一个类相关,用内部类
static class StudentComparator implements Comparator //为了调用方便声明为静态的
{
  public int compare(Object o1,Object o2)
  {
   Student s1 = (Student)o1;
   Student s2 = (Student)o2;
   int result=s1.num > s2.num ? 1: (s1.num==s2.num ? 0 : -1);
   if(result==0)
   {
    return s1.name.compareTo(s2.name);
   }
   return result;
  }
}
Student(int num,String name)
{
  this.num=num;
  this.name=name;
}
public int compareTo(Object o)
{
  Student s=(Student)o;
  return num > s.num ? 1 :( (num==s.num) ? 0 : -1);
}

public String toString()
{
  return +num+":"+name;
}
}

posted @ 2006-06-09 11:28 蓝色Saga 阅读(190) | 评论 (0) | 编辑收藏

上万张高清晰桌面http下載

posted @ 2006-06-09 07:39 蓝色Saga 阅读(763) | 评论 (1) | 编辑收藏

清除Windows系统.垃.圾.我最行

清除Windows系统.垃.圾.我最行

为你的电脑系统清除淤塞的**！轻松流畅上网你是否注意到你的电脑系统磁盘的可用空间正在一天天在减少呢？是不是像老去的猴王一样动作一天比一天迟缓呢？没错！在Windows在安装和使用过程中都会产生相当多的**文件，包括临时文件（如：*.tmp、 *._mp）日志文件（*.log）、临时帮助文件（*.gid）、磁盘检查文件（*.chk）、临时备份文件（如：*.old、*.bak）以及其他临时文件。

　　特别是如果一段时间不清理IE的临时文件夹“Temporary Internet Files”，其中的缓存文件有时会占用上百MB的磁盘空间。这些**文件不仅仅浪费了宝贵的磁盘空间，严重时还会使系统运行慢如蜗牛。这点相信你肯定忍受不了吧！所以应及时清理系统的**文件的淤塞，保持系统的“苗条”身材，轻松流畅上网！朋友来吧，现在就让我们一起来快速清除系统**吧！！

　　新建一个记事本并输入以下的内容：

　　@echo off
　　echo 正在清除系统**文件，请稍等......
　　del /f /s /q %systemdrive%\*.tmp
　　del /f /s /q %systemdrive%\*._mp
　　del /f /s /q %systemdrive%\*.log
　　del /f /s /q %systemdrive%\*.gid
　　del /f /s /q %systemdrive%\*.chk
　　del /f /s /q %systemdrive%\*.old
　　del /f /s /q %systemdrive%\recycled\*.*
　　del /f /s /q %windir%\*.bak
　　del /f /s /q %windir%\prefetch\*.*
　　rd /s /q %windir%\temp & md %windir%\temp
　　del /f /q %userprofile%\cookies\*.*
　　del /f /q %userprofile%\recent\*.*
　　del /f /s /q "%userprofile%\Local Settings\Temporary Internet Files\*.*"
　　del /f /s /q "%userprofile%\Local Settings\Temp\*.*"
　　del /f /s /q "%userprofile%\recent\*.*"
　　echo 清除系统**完成！
　　echo. & pause

　　最后将它保存，然后更名为“清除系统**.bat”！ok！你的**清除器就这样制作成功了！

　　以后只要双击运行该文件，当屏幕提示“清除系统**完成！就还你一个“苗条”的系统了！！到时候再看看你的电脑，是不是急速如飞呢？

　　注：这招比那些所谓的优化大师好用！不会破坏系统文件！

特别提醒：“**” 是《垃.圾》复制后改成《垃.圾》就行了

posted @ 2006-06-08 15:33 蓝色Saga 阅读(148) | 评论 (0) | 编辑收藏

线程学习

多线程学习

* 程序，进程和线程
程序: 是指计算机指令的集合，它以文件的形式存储在磁盘上。
进程: 是一个程序在其自身的地址空间中的一次执行活动。

进程是资源的申请，调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请
系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不站用系统的运行资源。

线程: 是进程中一个单一的连接控制流程。一个进程可以有多个线程。

线程又称为轻量级进程，它和进程一样拥有独立的执行控制,由操作系统负责调度，区别在于线程
没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远
较进程简单。
* Java对多线程的支持
Java在语言级提供了对多线程程序设计的支持。
实现线程程序的两种方式:
(1)从Thread类继承；
(2)实现Runnable接口。

Java运行时系统实现了一个用于调度线程执行的线程调度器，用于确定某一时刻由哪一个线程在
CPU上运行。
在java技术中，线程通常是抢占式的而不需要时间片分配进程(分配给每个线程相等的CPU时间的
进程)。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在
运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优级的线程
变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得
运行的机会。
Java线程调度器支持不同优先级线程的抢占方式，但其本身不支持相同优先级线程的时间片轮换。
Java运行时系统所在的操作系统（例如:windows2000）支持时间片的轮换，则线程调度器就支持
相同优先级线程的时间片轮换。

用多线程技术模拟一个售票系统
实现代码如下:
class TicketSystem
{
public static void main(String[] args)
{
  SellTicket st = new SellTicket();
  new Thread(st).start();
  new Thread(st).start();
  new Thread(st).start();
  new Thread(st).start();
}
}
class SellTicket implements Runnable
{
int tickets=100;
Object o = new Object();
public void run()
{
  while(true)
  {
   /*
    synchronized(o) //同步块在关键字后得加个对象(任意的对象都可以)
    {
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println(Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
    }
    */
    sell();
  }
}
public synchronized void sell() //同步方法
{
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println(Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
}
}
* 线程的同步
The code segments within a program that access the same object from separate,concurrent
thread are called "critical sections"。
同步的两种方式：同步块和同步方法
没一个对象都有一个监视器(monitor),或者叫做琐。
同步方法利用的是this所代表的对象的琐。
每个class也有一个琐，是这个class所对应的Class对象的琐。
完整示例:
class TicketSystem
{
public static void main(String[] args)
{
  SellTicket st = new SellTicket();
  new Thread(st).start();
  /*
   *写一个try{}catch{}块让main()方法所在的线程睡1秒
   *主要是想要线程优先启动
  */
  try
  {
   Thread.sleep(1);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  st.b=true;
  new Thread(st).start();
  //new Thread(st).start();
  //new Thread(st).start();
}
}
class SellTicket implements Runnable
{
int tickets=100;
Object obj = new Object();
boolean b=false;
public void run()
{
  if(b==false)
  {
   while(true)
      sell();
  }
  else
  {
     while(true)
   {
    synchronized(this) //同步块在关键字后得加个对象(任意的对象都可以)
    {
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println("obj:"+Thread.currentThread().getName()+
          " sell tickets"+tickets);
          tickets--;
     }
    }
   // sell();
  }
  }

}
public synchronized void sell() //同步方法
{
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println("sell():"+Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
}
}

* 线程的死琐
哲学家进餐的问题
一帮哲学家在一起进餐，但是每个人都只有1支筷子，大家都在等待别人拿出一支筷子让自己
先吃，然后再把自己的拿出去，但是大家都不愿意拿出自己的筷子。
线程1琐住了对象A的监视器，等待对象B的监视器，线程2锁住了对象B的监视器，等待对象A的
监视器，就造成了死琐。

示例代码:
class TicketSystem
{
public static void main(String[] args)
{
  SellTicket st = new SellTicket();
  new Thread(st).start();
  /*
   *写一个try{}catch{}块让main()方法所在的线程睡1秒
   *主要是想要线程优先启动
  */
  try
  {
   Thread.sleep(1);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  st.b=true;
  new Thread(st).start();
  //new Thread(st).start();
  //new Thread(st).start();
}
}
class SellTicket implements Runnable
{
int tickets=100;
Object obj = new Object();
boolean b=false;
public void run()
{
  if(b==false)
  {
   while(true)
      sell();
  }
  else
  {
     while(true)
   {
    synchronized(obj) //同步块在关键字后得加个对象(任意的对象都可以)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
      synchronized(this)
      {
            if(tickets>0)
             {
                System.out.println("obj:"+Thread.currentThread().getName()+
                " sell tickets"+tickets);
                tickets--;
              }
      }
      }
    }
  }

}
public synchronized void sell() //同步方法
{
  synchronized(obj)
  {
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println("sell():"+Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
  }
}
}
* wait,notify,notifyAll
每个对象除了有一个琐之外，还有一个等待队列(wait set),当一个对象刚刚创建的时候，它
的等待队列是空的。
我们应该在当前线程锁住对象的琐后，去调用该对象的wait方法。
当调用对象的notify方法时，将从该对象的等待队列中删除一个任意的线程，这个线程将再次
成为可运行的线程。
当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将
成为可运行的线程。
wait和notify重要用于producer-consumer这种关系中。
代码示例:
class Test
{
public static void main(String[] args)
{
  Queque q = new Queque();
  Procedur p = new Procedur(q);
  Consumer c = new Consumer(q);
  p.start();
  c.start();

}
}

class Procedur extends Thread   //生产者
{
Queque q;
Procedur(Queque q)
{
  this.q=q;
}
public void run()
{
  for(int i=0;i<10;i++)
  {
   q.put(i);
   System.out.println("Procedur put"+ i);
  }
}
}

class Consumer extends Thread   //消费者
{
Queque q;
Consumer(Queque q)
{
  this.q=q;
}
public void run()
{
  while(true)
  {
   System.out.println("Consumer get"+q.get());
  }
}
}

class Queque    //放置数据
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
  if(!bFull)
  {
    value=i;
    bFull=true;
    notify();
  }
  try
  {
   wait();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
public synchronized int get()
{
  if(!bFull)
  {
   try
   {
    wait();
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
  }
  bFull=false;
  notify();
  return value;
}
}

线程的状态图

   |
   | new Thread
   |                   yield      sleep,wait,suspend,I/O阻塞
\|/ start                     |------------------------------------>|
New----->Runnable|                                                        |Not Runnable
                            \    |<------------------------------------|        /
                             \     sleep结束,notify,resume,I/O操作完成    /
                              \                                                                /
                               \                                                             /
                                \                                                           /
                                 \                                                       /
                                  \ run方法退出                               /
                                   \stop方法调用                            /
                                    \                                               /
                                     \                                           /
                                      \                                        / stop方法调用
                                       \                                      /
                                        \                                     /
                                         \                                   /
                                          \                               /
                                           \                             /
                                            \                          /
                                             \ ______ _____/
                                              |    Dead         |
                                              |____________|
线程的终止

设置一个flag变量。
结合interrupt()方法。
code:
class TestThread
{
public static void main(String[] args)
{
  Thread1 t1=new Thread1();
  t1.start();
  int index=0;
  while(true)
  {
   if(index++==500)
   {
    t1.stopThread();
    break;
   }
   System.out.println(Thread.currentThread().getName());
  }
}
}

class Thread1 extends Thread
{
private boolean bStop=false;
public void run()
{
  while(!bStop)
  {
   System.out.println(getName());
  }
}
public void stopThread()
{
  bStop=true;
}
}

posted @ 2006-06-08 12:21 蓝色Saga 阅读(147) | 评论 (0) | 编辑收藏

BloveSaga

常用链接

留言簿(6)

随笔分类(30)

随笔档案(34)

文章分类(12)

文章档案(12)

收藏夹(1)

DataBase

Developing Tools

Frame&&Mode

OpenSource

Software Engineering&&Management

Study Forum

优选Blog

搜索

最新评论

阅读排行榜

评论排行榜

En espa%ntilde;ol