BloveSaga

在希腊帕尔纳斯山南坡上,有一个驰名世界的戴尔波伊神托所,在它的入口处的巨石上赫然锈刻着这样几个大字: 认识你自己!

  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  34 随笔 :: 12 文章 :: 122 评论 :: 0 Trackbacks

2006年6月4日 #

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

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

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

 

posted @ 2006-06-21 12:23 蓝色Saga 阅读(220) | 评论 (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&ntilde;ol</title></head>");
   out.println("<body>");
   out.println("<h3>En espa%ntilde;ol</h3>");
   out.println("&iexcl;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 阅读(171) | 评论 (0)编辑 收藏

在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">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
        <title>JSP Page</title>
    </head>
    <body>

    <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 阅读(218) | 评论 (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 阅读(239) | 评论 (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 阅读(145) | 评论 (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 阅读(1160) | 评论 (3)编辑 收藏

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 ,LastnameFirstname与Lastname,以此顺序
|"或"Firstname | LastnameFirstname或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 阅读(433) | 评论 (0)编辑 收藏

  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的兼容.最后输入两个横杠和一个大于号来结束注释.例如:
<!-- Writing comments in XML Documents-->
这就是注释.


结构良好的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 阅读(191) | 评论 (0)编辑 收藏

理解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 阅读(130) | 评论 (0)编辑 收藏

  编码:将一个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 阅读(86) | 评论 (0)编辑 收藏

               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 阅读(613) | 评论 (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 阅读(121) | 评论 (0)编辑 收藏

上萬張高畫質各式精選桌布http下載

所有圖片均上傳至 MEGAUPLOAD 空間!

若您要查看每集有哪些圖片,請自行瀏覽…在此就不貼出了

各集預覽http://www.lin.biz/viewforum.php?f=5

第A001集http://www.megaupload.com/?d=LMRY00AW
第A002集http://www.megaupload.com/?d=MIMTZMHN
第A003集http://www.megaupload.com/?d=JZDNKV70
第A004集http://www.megaupload.com/?d=KB7WS1TN
第A005集http://www.megaupload.com/?d=A8COTU6R
第A006集http://www.megaupload.com/?d=1WJUON4A
第A007集http://www.megaupload.com/?d=DP8C5I4Y
第A008集http://www.megaupload.com/?d=FC71IIUE
第A009集http://www.megaupload.com/?d=7RNVJABQ
第A010集http://www.megaupload.com/?d=BKMAZFQ2
第A011集http://www.megaupload.com/?d=0CUN79QQ
第A012集http://www.megaupload.com/?d=61RYJ8Q2
第A013集http://www.megaupload.com/?d=LG3L8NVL
第A014集http://www.megaupload.com/?d=RCFCV1LH
第A015集http://www.megaupload.com/?d=QFF81PUF

3月21更新

第A016集http://www.megaupload.com/?d=0FEVLSFL
第A017集http://www.megaupload.com/?d=UHLZ7NT5
第A018集http://www.megaupload.com/?d=8L3B4RNG
第A019集http://www.megaupload.com/?d=712YBM8C
第A020集http://www.megaupload.com/?d=82GJA4QI
第A021集http://www.megaupload.com/?d=7J827HKR
第A022集http://www.megaupload.com/?d=9OD2XC7H
第A023集http://www.megaupload.com/?d=QXO4ZMG7
第A024集http://www.megaupload.com/?d=IBT187D7
第A025集http://www.megaupload.com/?d=K52RYT2C
第A026集http://www.megaupload.com/?d=645LT7V4
第A027集http://www.megaupload.com/?d=SXZBFLCN
第A028集http://www.megaupload.com/?d=XU91RTCC
第A029集http://www.megaupload.com/?d=R5ZTF0IX
第A030集http://www.megaupload.com/?d=EAEC9DRK
第A031集http://www.megaupload.com/?d=TUVSJCYV
第A032集http://www.megaupload.com/?d=BOKLM691
第A033集http://www.megaupload.com/?d=5EIDGC25
第A034集http://www.megaupload.com/?d=LUEP78CJ
第A035集http://www.megaupload.com/?d=BQM78MHQ
第A036集http://www.megaupload.com/?d=2D5QVWNN
第A037集http://www.megaupload.com/?d=YHZGWGJR
第A038集http://www.megaupload.com/?d=CBGG07DP
第A039集http://www.megaupload.com/?d=P67HJMK4
第A040集http://www.megaupload.com/?d=Y2K4PDJN
第A041集http://www.megaupload.com/?d=T0TBVI47
第A042集http://www.megaupload.com/?d=EY1PRZ2U
第A043集http://www.megaupload.com/?d=SV35PL36
第A044集http://www.megaupload.com/?d=8COIIHYT
第A045集http://www.megaupload.com/?d=16QT2KJC

3月22更新

第A046集http://www.megaupload.com/?d=P1G8INRJ
第A047集http://www.megaupload.com/?d=8NDN001I
第A048集http://www.megaupload.com/?d=2ZMQNEU3
第A049集http://www.megaupload.com/?d=WR64P2A7
第A050集http://www.megaupload.com/?d=ARM9J9H9
第A051集http://www.megaupload.com/?d=HF1AKEEK
第A052集http://www.megaupload.com/?d=8MX7VZO4
第A053集http://www.megaupload.com/?d=IKXZSRFC
第A054集http://www.megaupload.com/?d=TOI28KAE
第A055集http://www.megaupload.com/?d=4F1ENKTI
第A056集http://www.megaupload.com/?d=X28NSWHR
第A057集http://www.megaupload.com/?d=CT1BI9UH
第A058集http://www.megaupload.com/?d=2SWK4M5J
第A059集http://www.megaupload.com/?d=BGKLGCTE
第A060集http://www.megaupload.com/?d=1YIEWRC4
第A061集http://www.megaupload.com/?d=CVG0I42V
第A062集http://www.megaupload.com/?d=SLPMCYP4
第A063集http://www.megaupload.com/?d=5CEGRWS8
第A064集http://www.megaupload.com/?d=ETOMOETI
第A065集http://www.megaupload.com/?d=G3YGVUEF
第A066集http://www.megaupload.com/?d=YP8WAMLU
第A067集http://www.megaupload.com/?d=1N3Z085J
第A068集http://www.megaupload.com/?d=383CL4DR
第A069集http://www.megaupload.com/?d=F5ADPD9T

3月23更新

第A070集http://www.megaupload.com/?d=HYUV4R8R
第A071集http://www.megaupload.com/?d=IOSS9GME
第A072集http://www.megaupload.com/?d=8PGJEA16
第A073集http://www.megaupload.com/?d=92ROO4NB
第A074集http://www.megaupload.com/?d=164C1FUS
第A075集http://www.megaupload.com/?d=FOCBJI92
第A076集http://www.megaupload.com/?d=HZEOFAV9
第A077集http://www.megaupload.com/?d=2I08TIPR
第A078集http://www.megaupload.com/?d=BT3Q8T90
第A079集http://www.megaupload.com/?d=FLUXH8M1
第A080集http://www.megaupload.com/?d=MFWG9WMW
第A081集http://www.megaupload.com/?d=Y6P70NQJ
第A082集http://www.megaupload.com/?d=3ML82FT1
第A083集http://www.megaupload.com/?d=RYXNIX15
第A084集http://www.megaupload.com/?d=8XF0F3B4
第A085集http://www.megaupload.com/?d=GO4HVW1T
第A086集http://www.megaupload.com/?d=7N18JIZ7
第A087集http://www.megaupload.com/?d=5YQDH9AT
第A088集http://www.megaupload.com/?d=K829N8LI
第A089集http://www.megaupload.com/?d=46OFDJGW
第A090集http://www.megaupload.com/?d=3G13IYZV
第A091集http://www.megaupload.com/?d=KX8K998Q
第A092集http://www.megaupload.com/?d=3YGNUT3Y
第A093集http://www.megaupload.com/?d=5ZFZUDCG
第A094集http://www.megaupload.com/?d=KQF5MD5U
第A095集http://www.megaupload.com/?d=Y7NEVBBX

4月3更新

第A096集http://www.megaupload.com/?d=HR4JBEY5
第A097集http://www.megaupload.com/?d=YLBK3TRP
第A098集http://www.megaupload.com/?d=79PA3MSS
第A099集http://www.megaupload.com/?d=P7ZPQBYW
第A100集http://www.megaupload.com/?d=220YFCNH
第A101集http://www.megaupload.com/?d=CGEP67IR
第A102集http://www.megaupload.com/?d=CILPUMOB
第A103集http://www.megaupload.com/?d=CBB6KRS7
第A104集http://www.megaupload.com/?d=ZU4K6O7G
第A105集http://www.megaupload.com/?d=TW9Z3KHP
第A106集http://www.megaupload.com/?d=7TN5VJEA
第A107集http://www.megaupload.com/?d=44WTE3YE
第A108集http://www.megaupload.com/?d=86EUYGGQ
第A109集http://www.megaupload.com/?d=347NYMQO
第A110集http://www.megaupload.com/?d=6UAA1XBH
第A111集http://www.megaupload.com/?d=EFON6OX2
第A112集http://www.megaupload.com/?d=PBCDTS8E
第A113集http://www.megaupload.com/?d=15XSJIT6
第A114集http://www.megaupload.com/?d=VIO3P9OV
第A115集http://www.megaupload.com/?d=86SEMC44
第A116集http://www.megaupload.com/?d=VG2Z3SDB
第A117集http://www.megaupload.com/?d=C7IFH8FL
第A118集http://www.megaupload.com/?d=0FY7AEEY
第A119集http://www.megaupload.com/?d=E86DJTKI
第A120集http://www.megaupload.com/?d=NFAA05SB
第A121集http://www.megaupload.com/?d=6CQ31JVW
第A122集http://www.megaupload.com/?d=Z9T9GIBH
第A123集http://www.megaupload.com/?d=LZBK52RL
第A124集http://www.megaupload.com/?d=S1N60HYV
第A125集http://www.megaupload.com/?d=L0LQ8L52
第A126集http://www.megaupload.com/?d=OG6T81CZ
第A127集http://www.megaupload.com/?d=PRALKKKF
第A128集http://www.megaupload.com/?d=2J8856C5
第A129集http://www.megaupload.com/?d=SKA24Y7F
posted @ 2006-06-09 07:39 蓝色Saga 阅读(667) | 评论 (1)编辑 收藏

清除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 阅读(113) | 评论 (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 阅读(101) | 评论 (0)编辑 收藏

我这里有些视频教程,需要的流下email,我会把具体的地址,我下载文件email给你!

视频目录:

1.HTTP协议详解
    详细介绍了 HTTP 协议的内容,包括: HTTP URL 、 HTTP 请求、 HTTP 响应和 HTTP 消息。
    最后给出了两个实验,帮助大家更好地理解 HTTP 协议。
    本课程将为您深入学习 Java Web 开发打下基础。
2. Eclipse开发工具介绍
     Eclipse是一个开放源代码的、基于 Java 的可扩展的开发平台,是目前非常流行的Java开发工具。
    本课程将为您介绍Eclipse的安装、配置和使用。
3. HTML语言速成
    帮助您快速掌握HTML语言,为学习XML和JSP开发打下基础。
4.  MySQL视频教程
5.  面向对象程序设计
6.  LINUX视屏教程

如果以上有你需要的,就留下email地址,晚上我会统一发!
posted @ 2006-06-07 15:30 蓝色Saga 阅读(1372) | 评论 (110)编辑 收藏

匹配中文字符的正则表达式:  [\u4e00-\u9fa5]

匹配双字节字符 ( 包括汉字在内 ) [^\x00-\xff]

应用:计算字符串的长度(一个双字节字符长度计 2 ASCII 字符计 1

String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}

匹配空行的正则表达式: \n[\s| ]*\r

匹配 HTML 标记的正则表达式: /<(.*)>.*<\/\1>|<(.*) \/>/ 

匹配首尾空格的正则表达式: (^\s*)|(\s*$)

应用: javascript 中没有像 vbscript 那样的 trim 函数,我们就可以利用这个表达式来实现,如下:

String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, "");
}

利用正则表达式分解和转换 IP 地址:

下面是利用正则表达式匹配 IP 地址,并将 IP 地址转换成对应数值的 Javascript 程序:

function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //
匹配 IP 地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}

不过上面的程序如果不用正则表达式,而直接用 split 函数来分解可能更简单,程序如下:

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP
值是: "+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配 Email 地址的正则表达式: \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配网址 URL 的正则表达式: http://( [\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

利用正则表达式去除字串中重复的字符的算法程序: [ 注:此程序不正确,原因见本贴回复 ]

var s="abacabefgeeii"
var s1=s.replace(/(.).*\1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"") 
alert(s1+s2) //
结果为: abcefgi

这个方法对于字符顺序有要求的字符串可能不适用。

得用正则表达式从 URL 地址中提取文件名的 javascript 程序,如下结果为 page1

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
alert(s)

利用正则表达式限制网页表单里的文本框输入内容:

用正则表达式限制只能输入中文: onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

用正则表达式限制只能输入全角字符:  onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

用正则表达式限制只能输入数字: onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

用正则表达式限制只能输入数字和英文: onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData

几个常用正则表达式:
('text',clipboardData.getData('text').replace(/[^\d]/g,''))" 
Email : /^\w+([-+.]\w+)*@\w+([-.]\\w+)*\.\w+([-.]\w+)*$/,    
Phone : /^((\(\d{3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}$/,    
Mobile : /^((\(\d{3}\))|(\d{3}\-))?13\d{9}$/,    
Url : /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/,    
IdCard : /^\d{15}(\d{2}[A-Za-z0-9])?$/,    
Currency : /^\d+(\.\d+)?$/,
Number : /^\d+$/,    
Zip : /^[1-9]\d{5}$/,    
QQ : /^[1-9]\d{4,8}$/,    
Integer : /^[-\+]?\d+$/,    
Double : /^[-\+]?\d+(\.\d+)?$/,    
English : /^[A-Za-z]+$/,    
Chinese :  /^[\u0391-\uFFE5]+$/,    
UnSafe :/^(([A-Z]*|[a-z]*|\d*|[-_\~!@#\$%\^&\*\.\(\)\[\]\{\}<>\?\\\/\'\"]*)|.{0,5})$|\s/,

posted @ 2006-06-05 22:40 蓝色Saga 阅读(144) | 评论 (0)编辑 收藏

     摘要: 正则表达式是一个描述字符模式的对象。 JavaScript 的 RegExp 对象和 String 对象定义了使用正则表达式来执行强大的模式匹配和文本检索与替换函数的方法 .'***********************'              \\JavaScript//''***************...  阅读全文
posted @ 2006-06-05 22:37 蓝色Saga 阅读(618) | 评论 (0)编辑 收藏

JavaScript语法

什么是脚本程序和JavaScript

 *什么是脚本程序
 <html>
 <script language="javascript">
    alert(new Date());
 </script>
 </html>

 *JavaScript简介
  前身叫作Livescript,是一种基于对象(Object)和事件驱动(Event Driver),并具有安全性能的脚本语言.
 *JavaScript与Java
  是两个公司开发的两个不同产品,作用与用途大不一样,但两者语法上有很多相似之处,JavaScript并不是
  Java的子集.
 *JavaScript,JScript与ECMAScript
 *脚本代码的位置
  我们可以把代码放到<script></script>标签之间:
  <script>
    var x=3;
  </script>
  <p>This is a HTML 段落</p>
  <script>
    alert(x);
  </script>
  也可以放在一个单独的文件中:
  <html>
  <script src="script.js" language="javascript">
 *将脚本程序代码作为属性值
  <a href="javascript:alert(new Data());">javascript</a>
  </html>
=======================================================================================
JavaScript的基本语法

 *JavaScript中的标识符
 标识符是指JavaScript中定义的符号,例如,变量名,函数名,数组名等.标识符可以由任意顺序的
 大小写字母,数字,下划线(_)和美元符号($)组成,但标识符不能以数字开头,不能是JavaScript
 中的保留关键字.
 合法的标识符举例: indentifler,username,user_name,_username,$username
 非法的标识符举例: int,98.3,Hello World
 *Java严格区分大小写
 computer和Computer是两个完全不同的标识符
 *JavaScript程序代码格式
 每条功能语句的最后必须用分号(;)结束,每个词之间用空格,制表符,换行符或大括号,小括号这样
 的分隔符隔开.
 *JavaScript程序的注释
 /*...*/中可以嵌套"//"注释,但不能嵌套"/"...."/".

================================================================================
基本数据类型与常量

 *正型常量
 十六进制以Ox或OX开头,例如:Ox8a.八进制必须以O开头,例如: 0123.十进制的第一位不能为0
 (数字0除外),例如: 123
 *字符常量
 12.32,123.42,5E7,4e5等.
 *布尔值
 true和false.
 *字符串常量
 例如: "a book of JavaScript",'abc',"a",""(空字符串) .
 特殊字符需要用反斜杠(\)来转意.
 例如: \r, \n, \t, \b, \', \\
 在JavaScript中一个连续的字符串不能分开在两行中来写.可以使用"+"号连起来.
 *null常量
 表示变量的值为空
 *undefined常量
 表示一个变量还没有被复值时的状态,或某个对象的属性不存在.

=========================================================================================
变量

 *定义一个变量,系统就会为之分配一块内存,程序可以用变量名来表示这块内存中的数据.
 *声明变量用var关键字
 例如: var x; (这个时候就是undifeined)
 *声明变量的同时为其赋值
 例如: var name="lisi";
 *对已赋值的变量赋于一个其他类型的数据
 例如: name=123;
 *不事先声明变量而直接使用
 例如: x=1234;

算术运算符

 *+ 加法运算符或正值运算符,例如, x+5, +6.
  它还能实现多个字符串的想加,也能将字符串与其他的数据类型连成一个新的字符串,条件
  条件是该表达式中至少有一个字符串,例如: "x"+123的结果为"x123".
 *- 减法运算符或负预算符,例如, 7-3, -8.
 ** 乘法运算符,例如, 3*7.
 */ 除法运算符,例如 9/4.
 *% 求模运算符(算术中的求余),例如, 5%2
 *++将变量值加1后再将结果赋给这个变量,分为两种,例如a++和++a
 *--用法与++预算符一样
 

赋值运算符
 
  赋值运算符的作用是将一个值赋给一个变量,最常用的是"=",还可以由"="运算符和其他的一些
  预算符组合成新的运算符,例如:
  "+=","-="等.

比较运算符

  *>大于
   当左边的操作数大于右边的操作数时,返回true.
  *<小与
  *=
  *<=
  *>=
  *==
  *!=
  注意: 不要把"=="写成"="

逻辑运算符
 
  *&&
  逻辑与,当左右两边的操作数都为true时,返回值为true,否则为false.
  *||
  逻辑或,当左右两边的操作数都为false时,返回值为false,否则为true.
  *!
  逻辑非,当操作数为ture的时,返回值为false,否则为true.

========================================================================
程序流程控制
 
 *顺序结构
 *if条件选择语句
 *switch选择语句
 *while循环语句
 *do while语句
 *for循环语句
 *break与continue语句

 if条件语句语法1:
 if(条件语句)
 {
   执行语句块
 }
 注意:if(x==null)或if(typeof(x)=="undefined")可以简写成if(!x)
 if条件语句语法2:
 if(条件语句)
 {
   执行语句块1
 }
 else
 {
   执行语句块2
 }
 变量=布尔表达式? 语句1 :语句2
 if条件语句语法3:
 if(条件语句)
 {
   执行语句块1
 }
 else if(条件语句2)
 {
   执行语句块2
 }
 ....
 else if(条件语句块n)
 {
   执行语句块n
 }
 else
 {
   执行语句块n+1
 }
 if语句块的嵌套
 if(x<1)
 {
  if(y==1)
    alert("x<1,y==1");
  else
    alert("x<1,y!=1");
  }
  else if(x>10)
  {
    if(y==1)
      alert("x>10,y==1);
    else
      alert("x>10,y!=1");  
  }

===================================================================
函数
 
 *函数的作用与定义
 *全局变量与局部变量
 *参数个数可变的函数
 *创建动态函数
 *JavaScript中的系统函数

  定义一个函数的语法如下:
  function 函数名 (参数列表)
  {
     程序代码
     return 表达式;
  }
  对函数调用的几种方式:
  1.函数名(传递函数的参数1,传递给函数的参数2,.....)
  2.变量=函数名(传递函数的参数1,传递给函数的参数2,.....)
  3.对于有返回值的函数调用,也可以在程序中直接使用返回结果,例如:
  alert("sum="+square(2,3));

  全局变量与局部变量,看下面的代码:
  <script language="javascript">
   var msg="全局变量";
   function show()
   {
      msg="局部变量";
   }
   show();
   alert(msg);
  </script>

  参数个数可变的的函数:
 <script language="javascript">
  function testparams()
  {
    var params="";
    for(var i=0;i<arguments.length;i++)
    {
      params +=" "+ arguments[i];
    }
    alert(params);
  }
    testparams("abc",123);
    testparams(123,456,"abc");
 </script>
  注意:arguments代表了传递给函数的所有参数的所有集合。当函数的个数不确定,
  获得参数个数很多,你又不想为每个参数定义一个变量,那么你就可以定义一个
  像上面那个一样的,定义一个为空的参数名,在内部用循环来实现。
 创建动态函数的语法:
 var varName=new Function(argument1,....,lastArgument);
 说明:
 所有的参数都必须是字符串型的,最后的参数必须是这个动态函数的功能程序代码.
 例子:
 <script>
   var square=new Function("x","y",
            "var sum;sum=x*x+y*y; return sum;");
   alert(square(3,2));
 </script>
 动态函数有什么作用,在什么情况下使用?
 
 JavaScript中的系统函数:
 .encodeURI方法(比URL的描述的范围更大,一般情况下可以等同)
 返回一个URI字符串编码后的效果。例如:
 <script language="javascript">
   var uriStr=encodeURI("http://www.doit.org/index.html?country=中国&name=z x");
   alert(uriStr);
 </script>

 .decodeURI方法
 将一个已编码的URI字符串解码成最初的字符串并返回.
 .parseInt方法
  第一字符串按指定的进制转换成一个整数,语法格式为:parseInt(numString,[redix])。
  如果没有指定第二个参数,则前缀为'Ox'的字符串被视为十六进制,前缀为'O'的字符串
  被视为八进制,所有其他的字符串被视为十进制。
  例如: alert(parseInt("123abc",10));
 .parseFloat方法
  将一个字符串转换为小数。
 .isNaN方法(用与检测)
 .escape方法(用于对文本的简单加密)
  返回对一个字符串进行编码后的结果字符串。所有空格,标点,重音符号以及任何其他
  ASCII字符都用%xx编码替换,其中xx等于表示该字符的Unicode编码的十六进制数,字符
  值大于255字符以%uxxxx格式表示。
 .unescape方法
  将一个用escape方法编码的字符串解码成原始字符串。
 .eval方法
  将其中的参数字符串作为一个JavaScript表达式执行。

=======================================================================
  对象
 *对象与对象实例
 *构造方法与this关键字的作用
 *在函数中修改参数值的问题

 对象与对象实例
 .对象中所包含的变量就是对象的属性,对象中所包含的对属性进行操作的函数就是对象的
  方法,对象的属性和方法都叫对象的成员。
 .对象是某一类事物的描述,是抽象的概念;而对象实例是一类事物中的具体个例。
 .能够被用来创建对象实例的函数就是对象的构造函数,只要定义一个对象的构造函数,就
  等于被定义了一个对象。使用new关键字和对象的构造函数就可以创建对象实例,语法格式
  如下: var ObjectInstance = new ObjName(传递给该对象的实际参数列表)。
  <script language="javascript">
  function Person()
  {
    //这是一个构造函数
  }
  var person1 = new Person();  //创建了一个实例变量(对象实例)
  person1.age = 18;
  person1.name = "blovesaga"; //age和name为对象属性
  //alert(person1.name+"."+person1.age);
  function sayFunc()
  {
    alert(person1.name+"."+person1.age);//我们也可以使用person["age"](对象实例["成员变量"])来访问
  }
  person1.say=sayFunc;  //把方法名赋值给了person1.say成员,我们可以在其他地方像
                        //调用方法一样来调用
  person1.say();
  </script>

看下面的例子:
<html>
 <script language="javascript">
   //定义一个构造函数,也就是对象的名称为person
   function Person()
   {
   }
   //创建一个对象实例
   var person1=new Person();
   person1.age=18;
   person1.name="zxy";
   //编写一个成员方法
   function sayFunc()
   {
      var x="name";
      eval("alert(person1."+ x + ");");  //这个字符串中的内容将被作为JavaScipt代码来执行
      alert(person1.name+":"+person1.age);
   }
   person1.say=sayFunc; //把方法名赋值给了person1.say成员
   person1.say=sayFunc(); //写了括号表示执行sayFunc()函数在复值
   person1.say();
 </script>
</html>

===================================================================
构造方法与this关键字

 .为一个对象实例新增加的属性和方法,不会增加到同一个对象所产生的其它对象实例上。
 .所有的实例对象在创建都会自动调用构造函数,在构造函数中增加的属性和方法会被
  增加到每个对象实例上。
 .对象实例是使用new关键字创建的,在构造方法中不要有返回结果的return语句。
 .调用对象的成员方法时,需要使用“对象实例.成员方法"的形式,很显然,用作成
  员方法的函数被调用,一定伴随有某个对象实例。this关键字代表某个成员方法执行时
   ,引用该方法的当前对象实例,所以,this关键字一般只在用作对象成员方法的
  函数中出现。
  <script language="javascript">
   function Person(name,age)
   {
     this.age=age;
     this.name=name;
     this.say=sayFunc;
   }
   function sayFunc()
   {
      alert(this.name+":"+this.age);
   }
   var person1=new Person("张山",18);
   person1.say();
   var person2 = new Person("里四",30);
   person2.say();
  </script>
例子代码:
<html>
 <script language="javascript">
   //定义一个构造函数
   function Person(name,age)
   {
     this.name=name;//当前的对象实例增加一个成员变量name,成员变量的通过Person()参数name传递进来
     this.age=age;//当前的对象实例增加一个成员变量age,成员变量的通过Person()参数age传递进来
     this.say=sayFunc; //增加一个sayFunc()函数
   }
   function sayFunc()
   {
     alert(this.name + ":" + this.age);
   }
   //创建一个对象实例
   var person1=new Person("张三",18);
   person1.say();  //调用person1的say()成员方法
   var person2=new Person("李四",29);
   person2.say();  //调用person2的say()成员方法
 </script>
</html>

=====================================================================
在函数中修改参数值的问题

 将基本数据类型的变量作为函数参数传递的情况:
 <script language="javascript">
  function changeValue(x)
  {
    x=5;
  }
  var x=3;
  changeValue(x);
  alert(x);
 </script>
注意: 在函数changeValue(x)中的x=5并不能修改主程序中的x值,函数接受的参数
就相当于一个局部变量,当函数调用完也就没用了。所以该程序的结果为x=3;如果
我们把一个对象的实例传递给函数,而我们有在函数中修改了对象实例的属性,那么
最后的结果也会变化的。

posted @ 2006-06-05 22:34 蓝色Saga 阅读(207) | 评论 (0)编辑 收藏

     摘要: JAVA 程序员面试 32 问 第一,谈谈 final , ...  阅读全文
posted @ 2006-06-05 15:16 蓝色Saga 阅读(273) | 评论 (2)编辑 收藏

>>>>>>>>>>>>>>>>Runtime和Process类<<<<<<<<<<<<<<<<<<<
1> 每一个Java程序都有一个Runtime类的单一实例。
2> 通过Runtime.getRuntime()获取Runtime类的实例。
3> Runtime类是使用单例模式的一个例子。
   Runtime没有public的构造方法。我们必须用Runtime的静态方法getRuntime();我们可以用
   Runtime的exec来执行一个外部程序,也可以用来编译一个源文件(用来做图形界面的编译器)。
import java.io.*;
class RuntimeTest
{
 public static void main(String[] args)
 {
  Runtime rt=Runtime.getRuntime();
  //System.out.println(rt.freeMemory());
  try
  {
   //rt.exec("notepad");
   Process p=rt.exec("java ArrayTest");
   InputStream is=p.getInputStream(); //从执行ArrayTest类所得来的
   int data;
   while((data=is.read())!=-1)
   {
    System.out.print((char)data);
   }
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 }
}

------------->>设计模式<<-------------
1> 在我们进行程序设计时,逐渐形成了一些典型问题和问题解决方案,这就是软件模式。
2> 每一个模式描述了一个在我们程序设计中经常发生的问题,以及该问题的解决方案。
3> 当我们碰到模式所描述的问题,就可以直接用相应的解决方法去解决这个问题,这就是设计模式。
<$>单例(Singleton)模式
1> 一个类只有一个实例,而且自行实例化并像整个系统提供这个实例,这个类称为单例类。
2> 单例类的一个重要特点就是类的构造方法是私有的,从而避免了外部用利用构造方法直接创建多个实例。
   如:Runtime类。

单例类的实现:(code)
class Singleton
{
 private static final Singleton st=new Singleton();
 private Singleton()
 {
  
 }
 public static Singleton getInstance()
 {
  return st;
 }
}

posted @ 2006-06-05 14:47 蓝色Saga 阅读(249) | 评论 (0)编辑 收藏

=============================封装类===============
针对八种基本数据类型定义的相应的引用类型-封装类(包装类,包裹类)
基本数据类型          封装类
 boolean               Boolean
 byte                  Byte
 short                 Short
 int                   Integer
 long                  Long
 char                  Character
 float                 Float
 double                Double
所有的封状类都是一个只读类(不能修改的).针对没个基本类型我们只能建立一个这读的。

class Test
{
 public static void main(String[] args)
 {
  int i=3;
  Integer in=new Integer(i);
  int j=in.intValue();
  System.out.println(j);
  String str=in.toString();  //把Integer对象转换为String类型
  System.out.println("str="+str);
  
  String str1="123";
  System.out.println(Integer.valueOf(str1));  //把String类型转换为Integer类型
  
  boolean b1=false;
  Boolean b=new Boolean(b1);
  String s1=b.toString();
  System.out.println(s1);
  
  String s2="NO";
  System.out.println(Boolean.valueOf(s2));
 }
}

*****************Class*********************
1> 在Java中,每个class都有一个相应的Class对象。也就是说,当我们编写一个类,编译完成后,在生成
   的.class文件中,就会产生一个Class对象,用于表示这个类的类型信息。
2> 获取Class实例的方法有三种:
   <1>利用对象调用getClass()方法获得该对象的Class实例。
   <2>使用Class类的静态方法forName(),用类的名字获取一个Class的是实例。
   <3>运用.class的方式来获取Class实例,对于基本数据类型的封装类,还可以用.TYPE来获取相应的
      基本数据类型的Class实例。
   <4>在运行期间,如果我们要产生某个类的对象,JAVA虚拟机(JVM)会检查该类型的Class对象是否被
      加载,如果没有加载,JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已
      经被加载到内存,就可以用它来产生该类型所有的对象。
   <5>newInstance()调用类中缺省的构造方法。(好处是我们在不知道类的名字的情况下去创造一个实例)
import java.lang.reflect.*;       //子包必须手动导入
class ClassTest
{
 public static void main(String[] args)//throws Exception
 {
  /*
  Point pt=new Point();             
  Class c1=pt.getClass();//利用对象调用getClass()方法获得该对象的Class实例
  System.out.println(c1.getName());
  
  Class c2=Class.forName("Point");//使用Class类的静态方法forName(),用类的名字获取一个Class的是实例
  System.out.println(c2.getName());
  
  Class c3=Point.class;//运用.class的方式来获取Class实例
  System.out.println(c3.getName());
  
  Class c4=Integer.TYPE;//封装类用.TYPE来获取相应的基本数据类型的Class实例。
  System.out.println(c4.getName());
  */
  /*
  System.out.println("before new Point()");
  new Point();
  System.out.println("after new Point()");
  Class.forName("Line");
  */
  /*
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Point pt=(Point)c.newInstance();
   pt.output();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  */
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Constructor[] cons=c.getDeclaredConstructors();
   /*
   for(int i=0;i<cons.length;i++)
   {
    System.out.println(cons[i]);
   }
   Method[] ms=c.getDeclaredMethods();
   for(int i=0;i<ms.length;i++)
   {
    System.out.println(ms[i]);
   }*/
   Class[] params=cons[0].getParameterTypes();
   Object[] paramValues=new Object[params.length];
   for(int i=0;i<params.length;i++)
   {
    if(params[i].isPrimitive())
    {
     paramValues[i]=new Integer(i+3);
    }
   }
   Object o=cons[0].newInstance(paramValues);
   Method[] ms=c.getDeclaredMethods();
   ms[0].invoke(o,null);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  
 }
}

class Point
{
 static
 {
  System.out.println("Loading Point");
 }
 int x,y;
 void output()
 {
  System.out.println("x="+x+","+"y="+y);
 }
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

class Line
{
 static
 {
  System.out.println("Loading Line");
 }
}

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

~~~~~~~~~~~~~~~~~~~~~~~~~~函数的调用~~~~~~~~~~~~~~~~~~~~
1> 在java中,传参时,都是以传值的形式惊行。
2> 对于基本数据类型,传递的是数据的拷贝,对于引用类型,传递的引用的拷贝。
3> 当我们在打印一个对象的时候,比如System.out.println(pt);,它会自动调用类的toString()方法
   ,所以建议在所有的子类中重写toString()方法。
我们写一个函数用来交换两个变量(x,y)的值.
 code:
class StringTest
{
 public static void change(int x, int y)
 {
  x=x+y;
  y=x-y;
  x=x-y;
 }
 /*
 public static void change(int[] num)
 {
  num[0]=num[0]+num[1];
  num[1]=num[0]-num[1];
  num[0]=num[0]-num[1];
 }
 public static void change(Point pt)
 {
  pt.x=pt.x+pt.y;
  pt.y=pt.x-pt.y;
  pt.x=pt.x-pt.y;
 }
 */
 public static void main(String[] args)
 {
 int x=3;
 int y=4;
 change(3,4);
 System.out.println("x="+x+","+"y="+y);
 }
我们期望的输出结果是 x=4,y=3 然后你运行后发现结果为x=3,y=4,并没有达到我们的要求,为什么呢?那是因为对于基本数据类型,传递的是数据的拷贝,对于引用类型,传递的是引用(首地址)的拷贝。看看下面的内存图解应该你就能看出来了.看看引用类型怎么来实现:


code:
class StringTest
{
 /*
 public static void change(int x, int y)
 {
  x=x+y;
  y=x-y;
  x=x-y;
 }
 */
 public static void change(int[] num)
 {
  num[0]=num[0]+num[1];
  num[1]=num[0]-num[1];
  num[0]=num[0]-num[1];
 }
 public static void change(Point pt)
 {
  pt.x=pt.x+pt.y;
  pt.y=pt.x-pt.y;
  pt.x=pt.x-pt.y;
 }
 public static void main(String[] args)
 {
  /*
   int x=3;
   int y=4;
   change(3,4);
   System.out.println("x="+x+","+"y="+y);
   */
   int[] num=new int[]{3,4};
   change(num);
   System.out.println("x="+num[0]+","+"y="+num[1]);
  
   Point pt=new Point();
   pt.x=3;
   pt.y=4;
   change(pt);
   System.out.println("x="+pt.x+","+"y="+pt.y); 
 }
class Point
{
 int x,y; 
}
再看看引用类型的内存变化图:
以上说明了在Java中函数的调用:
a> 在Java中,传参时,都是以传值的方式进行。
b> 对于基本数据类型,传递的是数据的拷贝,对于引用类型,传递的是引用(首地址)的拷贝。
posted @ 2006-06-05 04:19 蓝色Saga 阅读(71) | 评论 (0)编辑 收藏

^^^^^^^^^^^^^^^对象的克隆^^^^^^^^^^^^^
1> 为了获取对象的一份拷贝,我们可以利用Object类的clone()方法。
2> 在派生类中覆盖基类的clone(),并声明为public。
3> 在派生类的clone()方法中,调用super.clone()。
4> 在派生类中实现Cloneable接口。
4> 没有抽象方法的接口叫标识接口。
5> 为什么我们在派生类中覆盖Object的clone()方法时,一定要调用super.clone()呢?在运行时刻,Object
   的clone()方法能识别出你要复制的是哪一个对象,然后为此对象分配空间,并进行对象的复制,将原
   始对象的内容一一复制到新的对象空间去。

* 浅克隆是针对没有引用类型的变量来克隆。针对引用类型的克隆应该用Deeply Clone。
浅克隆:
Code:
class FleetClone
{
 public static void main(String[] args)
 {
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="feifei";
   s2.p.age=30;

   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
 }
}
class Professor
{
 String name;
 int age;
 Professor(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}
改变学生s2的教授信息,打印s1教授信息,结果为:name=feifei,age=30.产生这个结果是因为String是一个常量类型.
 
深克隆
code:
class DeeplyClone
{
 public static void main(String[] args)
 {
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="Bill.Gates";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
 }
}
class Professor implements Cloneable
{
 String name;
 int age;
 Professor(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  //Object o=null;
  Student o=null;
  try
  {
   o=(Student)super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  o.p=(Professor)p.clone();
  return o;
 }
}
打印结果为:name=Bill.Gates,age=30,这就是深克隆.
posted @ 2006-06-05 04:15 蓝色Saga 阅读(98) | 评论 (0)编辑 收藏

     人生在世,最要紧的不是我们所处的位置,而是我们活动的方向.何时,何地一何种方式开始我们的一生,是无法选择的.我们一生下来就处于一种身不由己的环境中.但随着年龄增长,我们的选择就越多.我们可以选择居处,婚姻,朋友,可以选择人生方向.做出越多的人生选择,就越应该为在的处境负责任.
    有了目标,内心的力量才能找到方向.满腔的热血,能量才有着落,才有责任,使命,荣誉,甚至"健康"......
posted @ 2006-06-05 04:11 蓝色Saga 阅读(136) | 评论 (0)编辑 收藏

Java数组的相关操作

1> 在Java中所有的数组都有一个缺省的属性length,用于获取数组元素的个数。
2> 数组的复制: System.arraycopy()。
3> 数组的排序: Arrays.sort()。
4> 在已排序的数组中查找某个元素:Arrays.binarySearch()。
具体的看看下面的2个例子:
code1:
class ArrayTest
{
 public static void main(String[] args)
 {
  /*数组的copy
  int[] num1=new int[]{1,2,3};
  int[] num2=new int[3];
  System.arraycopy(num1,0,num2,0,num1.length);
  for(int i=0;i<num2.length;i++)
  {
   System.out.println(num2[i]);
  }
  */
  //引用类型的数组copy
  Point[] pts1=new Point[]{new Point(1,1),new Point(2,2),new Point(3,3)};
  Point[] pts2=new Point[3];
  System.arraycopy(pts1,0,pts2,0,pts1.length);
  for(int i=0;i<pts2.length;i++)
  {
   System.out.println("x="+pts2[i].x+","+"y="+pts2[i].y);
  }
  /*
  *因为引用类型传递的是引用的拷贝,所以我们修改pts2数组的第二个点的坐标,
  *当我们打印pts1数组的第一个点的坐标时,它的坐标点已经被修改为(5,5)了
  pts2[1].x=5;
  pts2[1].y=5;
  System.out.println("x="+pts1[1].x+","+"y="+pts1[1].y);
  */
 }
}

class Point
{
 int x, y;
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}


code2:
import java.util.*;
class TestArray
{
 public static void main(String[] args)
 {
  /*
  int[] num=new int[]{3,2,1};
  Arrays.sort(num);
  for(int i=0;i<num.length;i++)
  {
   System.out.println(num[i]);
  }
  int index=Arrays.binarySearch(num,3);
  System.out.println("index="+index);
  System.out.println("Element="+num[index]);
  */
  Student[] ss=new Student[]{new Student("zhangshan",1),
                            new Student("lisi",2),
                            new Student("wangwu",3),
                            new Student("mybole",3)};
   Arrays.sort(ss);
   for(int i=0;i<ss.length;i++)
   {
    System.out.println(ss[i]);
   }
   int index=Arrays.binarySearch(ss,new Student("lisi",2));
   System.out.println("name="+ss[index].name+","+"index="+index);
 }
}

class Student implements Comparable
{
 String name;
 int num;
 Student(String name,int num)
 {
  this.name=name;
  this.num=num;
 }
 public String toString()
 {
  return "name="+name+","+"number="+num;
 }
 public int compareTo(Object o)  //对于Object[]排序要求实现Comparable接口
 {
  Student s=(Student)o;
  //return num>s.num ? 1 :(num==s.num ? 0 : -1);
  int result=num>s.num ? 1 :(num==s.num ? 0 : -1);//按名字排序
  if(0==result)
  {
   result=name.compareTo(s.name);
  }
  return result;
 }
}

posted @ 2006-06-04 17:30 蓝色Saga 阅读(85) | 评论 (0)编辑 收藏

     你年轻聪明、壮志凌云。你不想庸庸碌碌地了此一生,渴望名声,财富和权利。因此你常常在我耳边抱怨那个著名的苹果为什么不是掉在你的头上?那只藏着“老子珠”的巨贝怎么就产在巴拉旺而不是在你常去游泳 的海湾?拿破仑偏能碰上约瑟芬而英俊高大的你总没有人垂青? 
    于是我想成全你,先是照样给你掉下一个苹果,结果你把它吃了。我决定换一个方法,在你闲逛时将硕大无朋的卡里南钻石偷偷放在你的脚边,将你绊倒,可你爬起后,怒气冲天地将它一脚踢下阴沟。最后我干脆就让你做拿破仑,不过像对待他一样,先将你抓进监狱,撤掉将军官职,赶出军队,然后将你身无分文地抛进塞纳河边。就在我催促约瑟芬驾着马车匆匆赶到河边时,远远地听到“扑通”一声,你投河自尽了。 
     唉!你错过的仅仅是机会吗?
posted @ 2006-06-04 15:23 蓝色Saga 阅读(96) | 评论 (0)编辑 收藏

     西谚说得好:"上帝只拯救能够自救的人."成功属于愿意成功的人.成功有明确的方向和目的.你不愿意成功,谁也拿你没办法;你自己不行动,上帝也帮不了你.
     成功并不是一个固定的蛋糕,数量有限,别人切了,你就没有了。不是那样,成功的蛋糕是切不完的,关键是你是否去切.你能否成功,与别人的成败毫无关系.只有你想成功,才有成功的可能.
     宋朝著名的禅师大慧,门下有一个弟子道谦.道谦参禅多年,仍无开悟.一天晚上,道谦诚恳的向师兄宗元诉说自己不能悟道的苦恼,并求师兄帮忙.
     宗元说:
     "我能帮你当然乐意之至,不过有三件事我无能为力,你必须自己去做!"
     道谦忙问是哪三件.
     宗元说:
     "当你口渴时,我的饮食不能填饱你的肚子,我不能帮你吃喝,你必须自己饮食;当你想大便时,你必须亲自解决,我一点也帮不上忙;最后,除了你自己之外,谁也不能驮着你的身子在路上走."
     道谦听罢,心扉豁然洞开,快乐无比,他感到了自我的力量.
     成功,首先始于自愿自觉.
     当一个人失去生活的目的和意义,万念俱灰时,我们说"无药可救";当一个人动了念头,人了死理,哪怕上刀山下火海不达目的不罢休时,我们说"矢志不渝".
     自己的事自己做.始于心动,成与行动.
      坚定的行动,必然源于深刻的认识和觉悟.
posted @ 2006-06-04 12:30 蓝色Saga 阅读(349) | 评论 (0)编辑 收藏

 通过覆盖父类的方法来实现,在运行时根据传递对象的引用,来调用相应的方法.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 static void fn(Animal an)
 {
  an.breathe();
 }
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fh=new Fish();
  Animal an;
  an=fh;
  DoMain.fn(an);
 }
}

posted @ 2006-06-04 11:40 蓝色Saga 阅读(114) | 评论 (0)编辑 收藏

   理解继承是理解面向对象程序设计的关键.在Java中,通过关键字extends继承一个已有的类,被继承的类称为父类(超类,基类),新的类称为子类(派生类).在Java中不允许多继承.code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 
}
class DoMain
{
 public static void main(String[] args)
 {
  Animal an=new Animal();
  Fish fn=new Fish();
  
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
Result:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Animal breathe!
(这说明派生类继承了父类的所有方法和成员变量.)

方法的覆盖(override)
在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法,称为方法的覆盖,方法的覆盖发生在子类与父类之间.
code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 int weight,height;   //隐藏了父类的weight,height;
 void breathe()  //override method breathe()
 {
  super.breathe();  //用super调用父类的构造方法
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
 // Animal an=new Animal();
  Fish fn=new Fish();
  
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Fish bubble

特殊变量super
* 使用特殊变量super提供对父类的访问
* 可以使用super访问父类被子类隐藏的变量或覆盖的方法
* 每个子类构造方法的第一条语句都是隐含的调用super,如果父类没有这种形式的构造函数就会报错.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fn=new Fish();
  
  //an.breathe();
  //fn.breathe();
  //fn.height=30;
  //fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal construct
Fish construct

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

  苏东坡和佛印和尚是好朋友,但二人喜欢言语相讽,各不相让,经常是苏东坡占下风.
  有一次,苏东破问佛印说:
  "你看我像什么?"
  "我看你像尊佛."佛印说.
  苏东破暗喜,随即就问佛印:
  "那你可知道我看你像什么呢?"
  "像什么?"
  "像一堆屎!"
  佛印语塞.苏东坡哈哈大笑.
  回家后,苏东坡面带笑容哼哼叽叽.
  苏小妹见状问道:
  "哥哥,什么事情这么高兴呀?"
  "哼,佛印这次总算载我手里了!"苏东坡得意的说.
  问明原委,苏小妹大叫道:
  "哥哥,这次你输得更惨了!"
  "为什么?"苏东坡急忙问.
  苏小妹说:
  "因为心中有什么,外在才看到什么.心中有佛,看别人才是佛;心中有屎,看别人就是屎!"
posted @ 2006-06-04 10:54 蓝色Saga 阅读(104) | 评论 (0)编辑 收藏

   E=MC^2,这是伟大的爱因斯坦著名的质能公式:能量等于质量乘以速度的平方。
  人与人在质量,能力(智商)上的差别是很小的,也就是说“M”基本上是个常数。因此,人能发出的能量(success),就取决于其速度(C^2)。

   时间就是胜利。

    竞赛以快取胜,搏击以快打慢,军事先下手为强,商战从"大鱼吃小鱼"到"快鱼吃慢鱼"。跆拳道要求心快,眼快,手快;中华武学一言以蔽之,百法有百解,唯快无解!
    大而慢等于弱,小而快可变强,大而快王中王!快就是机会,快就是效率,快就是瞬间的"大",无数的瞬间构成长久的"强"。
    竞争的实质,就是在最快的时间内做最好的东西。人生最大的成功,就在于在最短的时间里达到最多的目标。质量是"常量",经过努力都可以做好以至于难分伯仲;而时间,永远是"变量”:一流的质量可以有很多,而最快的冠军只有一个-任何领先,都是时间的领先!

  我们慢,不是因为我们不快,而是因为对手更快。
  盛田昭夫说:
  "如果你每天落后人家半步,一年后就是一百八是三步,十年后即为十万八千里。"

   在非洲的大草原上,一天早晨,曙光刚刚划破夜空,一只羚羊从睡梦中猛然惊醒。
  "赶快跑!" 它想到,“如果慢了,就可能被狮子吃掉!“
   于是,起身就跑,向着太阳的方向飞奔而去。
   就在羚羊醒来的同时,一只狮子也醒了。
  ”赶快跑“,狮子也想到,”如果慢了,就可能被饿死!“
   于是,起身就跑,也向着太阳的方向飞奔而去。

   谁快就谁赢,谁快就谁生存。一个是自然界兽中之王,一个是事草的羚羊,等级差异,实力悬殊,但生存却面临同一个问题-如果羚羊快,狮子就饿死;如果狮子快,羚羊被吃掉。
  贝尔在研究电话时,另一个叫格雷的人也在研究。两人同时取得突破。但贝尔在专利局赢了-比格雷早了两个钟头。当然,他们两人当时是不知道对方的,但贝尔就因为这120分钟而一举成名,誉满天下,同时也获得了巨大的财富。

  谁快谁赢得机会,谁快谁赢的财富。
  全世界的目光只会聚焦在第一名的身上。冠军才是真正的成功者。第一名后面,都是输家。
  时间的"量"不变,但"质"却不同。关键时刻一秒值万金。
posted @ 2006-06-04 10:53 蓝色Saga 阅读(230) | 评论 (0)编辑 收藏

    从今天开始从零学习JAVA,希望可以认识到更多的朋友,可以让自己的JAVA之路走得更为顺利一些!买了几本书来看也听了几接课,觉得JAVA很吸引我,我想我可以走得更远的.自信是最重要的.
    OOP(Object Oriented Programming)描述的是对象与对象之间的相互作用.听老师将面向过程与面向对象的最大区别是: 过程化程序设计先确定算法,再确定数据结构,再确定运算.面向过程编程,习惯于先建立数据结构存放数据并定义方法(函数)来操作数据;而面向对象的则是构建一个模型,将数据与方法组织在一起.
    我们可以把现实世界的事物抽象为对象.对象一般都有两个特征:状态(Status),行为(Behavior).软件的对象概念是由显示世界对象抽象而来.把现实世界的状态保存软件对象的变量中;现实世界对象的行为通过软件对象的方法(函数)来实现.
    我们把相似的对象划分成一个类.在软件中类就是一个模板,它定义了通用于一个特定种类的所有对象的状态(变量)和行为(方法).类是创建对象的模板,对象是类的实例.
    面向对象编程的难点在于思路的转变.我们通常习惯与考虑解决问题的方法,而不是抽象成对象再去解决它.
 类的构造方法
* 构造方法的名字和类名相同,并且没有返回值.
* 构造方法主要用于定义类的初始化状态.
* 我们不能直接调用构造方法,必须通过new关键字来自动调用,从而创建类的实例.
* Java的类都要求有构造方法,如果没有定义构造方法,Java编译器会提供一个缺省的构造方法,也就是不参数的构造方法.
方法的重载(overload)
 重载
构成的条件:方法的名称相同,但参数类型或参数个数不同,才能构成方法的重载.
code:
class Point
{
 int x,y;
 /*
  *带参数的构造方法和不带参数的构造方法就构成了方法(函数)的重载
 */
 Point(int a,int b)
 {
  x=a;
  y=b;
 }
 Point()
 {
  
 }
 void output()
 {
  System.out.println(x);
  System.out.println(y);
 }
 public static void main(String[] args)
 {
  //调用不带参数的构造方法
  //Point p=new Point();
  //pt.x=10;
  //pt.y=20;
  //p.output();
  Point p1=new Point(3,3); //调用带参数的构造方法
  p1.output();
 }
}
特殊变量this
* this变量代表对象本身
* 当类中有两个同名变量,一个属于类(类的成员变量),一个属于某个特定的方法(方法中的局部变量),使用this区分成员变量和局部变量.
* 使用this简化构造函数的调用
code:
class Point
{
 int x,y;
 /*
  *带参数的构造方法和不带参数的构造方法就构成了方法(函数)的重载
 */
 Point(int a,int b)
 {
  x=a;
  y=b;
 }
 Point()
 {
  this(1,1);
 }
 void output()
 {
  System.out.println(x);
  System.out.println(y);
 }
 /*output()方法定义的形参与成员变量同名了,
 *那么在output()里就看不到成员变量的x,y了,它被隐藏了.
 */
 void output(int x, int y)
 {
  this.x=x;
  this.y=y;
 }
 public static void main(String[] args)
 {
  Point pt=new Point(3,3);
  pt.output(5,5);
  pt.output();
 }
}
一个类所有的实例(对象)调用的成员方法在内存中只有一份拷贝,尽管在内存中可能有多个对象,而数据成员在内的没个对象中都存在着一份拷贝.this变量允许相同的实例方法为不同的对象工作.每当调用一个实例方法时,this变量被设置成引用该实例方法的特定的类的对象.方法的代码接着会与this所代表的对象的特定数据建立关联.
posted @ 2006-06-04 10:51 蓝色Saga 阅读(94) | 评论 (0)编辑 收藏