生命是一种过程

事情的结果尽管重要,但是做事情的过程更加重要,因为结果好了我们会更加快乐,但过程使我们的生命充实!
posts - 13, comments - 1, trackbacks - 0, articles - 0
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理

2006年4月28日

转自 http://blog.csdn.net/arcow/

在b/s开发中经常用到的javaScript技术 
一、验证类
1、数字验证内
  1.1 整数
  1.2 大于0的整数 (用于传来的ID的验证)
  1.3 负整数的验证
  1.4 整数不能大于iMax
  1.5 整数不能小于iMin
2、时间类
  2.1 短时间,形如 (13:04:06)
  2.2 短日期,形如 (2003-12-05)
  2.3 长时间,形如 (2003-12-05 13:04:06)
  2.4 只有年和月。形如(2003-05,或者2003-5)
  2.5 只有小时和分钟,形如(12:03)
3、表单类
  3.1 所有的表单的值都不能为空
  3.2 多行文本框的值不能为空。
  3.3 多行文本框的值不能超过sMaxStrleng
  3.4 多行文本框的值不能少于sMixStrleng
  3.5 判断单选框是否选择。
  3.6 判断复选框是否选择.
  3.7 复选框的全选,多选,全不选,反选
  3.8 文件上传过程中判断文件类型
4、字符类
  4.1 判断字符全部由a-Z或者是A-Z的字字母组成
  4.2 判断字符由字母和数字组成。
  4.3 判断字符由字母和数字,下划线,点号组成.且开头的只能是下划线和字母
  4.4 字符串替换函数.Replace();
5、浏览器类
  5.1 判断浏览器的类型
  5.2 判断ie的版本
  5.3 判断客户端的分辨率
 
6、结合类
  6.1 email的判断。
  6.2 手机号码的验证
  6.3 身份证的验证
 

二、功能类

1、时间与相关控件类
  1.1 日历
  1.2 时间控件
  1.3 万年历
  1.4 显示动态显示时钟效果(文本,如OA中时间)
  1.5 显示动态显示时钟效果 (图像,像手表)
2、表单类
  2.1 自动生成表单
  2.2 动态添加,修改,删除下拉框中的元素
  2.3 可以输入内容的下拉框
  2.4 多行文本框中只能输入iMax文字。如果多输入了,自动减少到iMax个文字(多用于短信发送)
 
3、打印类
  3.1 打印控件
4、事件类
  4.1 屏蔽右键
  4.2 屏蔽所有功能键
  4.3 --> 和<-- F5 F11,F9,F1
  4.4 屏蔽组合键ctrl+N
5、网页设计类
  5.1 连续滚动的文字,图片(注意是连续的,两段文字和图片中没有空白出现)
  5.2 html编辑控件类
  5.3 颜色选取框控件
  5.4 下拉菜单
  5.5 两层或多层次的下拉菜单
  5.6 仿IE菜单的按钮。(效果如rongshuxa.com的导航栏目)
  5.7 状态栏,title栏的动态效果(例子很多,可以研究一下)
  5.8 双击后,网页自动滚屏
6、树型结构。
  6.1 asp+SQL版
  6.2 asp+xml+sql版
  6.3 java+sql或者java+sql+xml
7、无边框效果的制作
8、连动下拉框技术
9、文本排序


一、验证类
1、数字验证内
  1.1 整数
      /^(-|+)?d+$/.test(str)
  1.2 大于0的整数 (用于传来的ID的验证)
      /^d+$/.test(str)
  1.3 负整数的验证
      /^-d+$/.test(str)
2、时间类
  2.1 短时间,形如 (13:04:06)
      function isTime(str)
      {
        var a = str.match(/^(d{1,2})(:)?(d{1,2})2(d{1,2})$/);
        if (a == null) {alert('输入的参数不是时间格式'); return false;}
        if (a[1]>24 || a[3]>60 || a[4]>60)
        {
          alert("时间格式不对");
          return false
        }
        return true;
      }
  2.2 短日期,形如 (2003-12-05)
      function strDateTime(str)
      {
         var r = str.match(/^(d{1,4})(-|/)(d{1,2})2(d{1,2})$/);
         if(r==null)return false;
         var d= new Date(r[1], r[3]-1, r[4]);
         return (d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]);
      }
  2.3 长时间,形如 (2003-12-05 13:04:06)
      function strDateTime(str)
      {
        var reg = /^(d{1,4})(-|/)(d{1,2})2(d{1,2}) (d{1,2}):(d{1,2}):(d{1,2})$/;
        var r = str.match(reg);
        if(r==null)return false;
        var d= new Date(r[1], r[3]-1,r[4],r[5],r[6],r[7]);
        return (d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]&&d.getHours()==r[5]&&d.getMinutes()==r[6]&&d.getSeconds()==r[7]);
      }
  2.4 只有年和月。形如(2003-05,或者2003-5)
  2.5 只有小时和分钟,形如(12:03)
3、表单类
  3.1 所有的表单的值都不能为空
      <input onblur="if(this.value.replace(/^s+|s+$/g,'')=='')alert('不能为空!')">
  3.2 多行文本框的值不能为空。
  3.3 多行文本框的值不能超过sMaxStrleng
  3.4 多行文本框的值不能少于sMixStrleng
  3.5 判断单选框是否选择。
  3.6 判断复选框是否选择.
  3.7 复选框的全选,多选,全不选,反选
  3.8 文件上传过程中判断文件类型
4、字符类
  4.1 判断字符全部由a-Z或者是A-Z的字字母组成
      <input onblur="if(/[^a-zA-Z]/g.test(this.value))alert('有错')">
  4.2 判断字符由字母和数字组成。
      <input onblur="if(/[^0-9a-zA-Z]/g.test(this.value))alert('有错')">
  4.3 判断字符由字母和数字,下划线,点号组成.且开头的只能是下划线和字母
      /^([a-zA-z_]{1})([w]*)$/g.test(str)
  4.4 字符串替换函数.Replace();
5、浏览器类
  5.1 判断浏览器的类型
      window.navigator.appName
  5.2 判断ie的版本
      window.navigator.appVersion
  5.3 判断客户端的分辨率
      window.screen.height;  window.screen.width;
 
6、结合类
  6.1 email的判断。
      function ismail(mail)
      {
        return(new RegExp(/^w+((-w+)|(.w+))*@[A-Za-z0-9]+((.|-)[A-Za-z0-9]+)*.[A-Za-z0-9]+$/).test(mail));
      }
  6.2 手机号码的验证
  6.3 身份证的验证
      function isIdCardNo(num)
      {
        if (isNaN(num)) {alert("输入的不是数字!"); return false;}
        var len = num.length, re;
        if (len == 15)
          re = new RegExp(/^(d{6})()?(d{2})(d{2})(d{2})(d{3})$/);
        else if (len == 18)
          re = new RegExp(/^(d{6})()?(d{4})(d{2})(d{2})(d{3})(d)$/);
        else {alert("输入的数字位数不对!"); return false;}
        var a = num.match(re);
        if (a != null)
        {
          if (len==15)
          {
            var D = new Date("19"+a[3]+"/"+a[4]+"/"+a[5]);
            var B = D.getYear()==a[3]&&(D.getMonth()+1)==a[4]&&D.getDate()==a[5];
          }
          else
          {
            var D = new Date(a[3]+"/"+a[4]+"/"+a[5]);
            var B = D.getFullYear()==a[3]&&(D.getMonth()+1)==a[4]&&D.getDate()==a[5];
          }
          if (!B) {alert("输入的身份证号 "+ a[0] +" 里出生日期不对!"); return false;}
        }
        return true;
      }

3.7 复选框的全选,多选,全不选,反选
<form name=hrong>
<input type=checkbox name=All onclick="checkAll('mm')">全选<br/>
<input type=checkbox name=mm onclick="checkItem('All')"><br/>
<input type=checkbox name=mm onclick="checkItem('All')"><br/>
<input type=checkbox name=mm onclick="checkItem('All')"><br/>
<input type=checkbox name=mm onclick="checkItem('All')"><br/>
<input type=checkbox name=mm onclick="checkItem('All')"><br/><br/>


<input type=checkbox name=All2 onclick="checkAll('mm2')">全选<br/>
<input type=checkbox name=mm2 onclick="checkItem('All2')"><br/>
<input type=checkbox name=mm2 onclick="checkItem('All2')"><br/>
<input type=checkbox name=mm2 onclick="checkItem('All2')"><br/>
<input type=checkbox name=mm2 onclick="checkItem('All2')"><br/>
<input type=checkbox name=mm2 onclick="checkItem('All2')"><br/>

</form>

<SCRIPT LANGUAGE="JavaScript">
function checkAll(str)
{
  var a = document.getElementsByName(str);
  var n = a.length;
  for (var i=0; i<n; i++)
  a[i].checked = window.event.srcElement.checked;
}
function checkItem(str)
{
  var e = window.event.srcElement;
  var all = eval("document.hrong."+ str);
  if (e.checked)
  {
    var a = document.getElementsByName(e.name);
    all.checked = true;
    for (var i=0; i<a.length; i++)
    {
      if (!a[i].checked){ all.checked = false; break;}
    }
  }
  else all.checked = false;
}
</SCRIPT>

3.8 文件上传过程中判断文件类型
<input type=file onchange="alert(this.value.match(/^(.*)(.)(.{1,8})$/)[3])">

画图:
<OBJECT
id=S
style="LEFT: 0px; WIDTH: 392px; TOP: 0px; HEIGHT: 240px"
height=240
width=392
classid="clsid:369303C2-D7AC-11D0-89D5-00A0C90833E6">
</OBJECT>
<SCRIPT>
S.DrawingSurface.ArcDegrees(0,0,0,30,50,60);
S.DrawingSurface.ArcRadians(30,0,0,30,50,60);
S.DrawingSurface.Line(10,10,100,100);
</SCRIPT>

posted @ 2006-04-28 09:47 隐语者 阅读(156) | 评论 (0)编辑 收藏

2006年1月25日

压缩解压
linux下怎么解后缀名是gzip的文件?
1.以.a为扩展名的文件:
#tar xv file.a

2.以.z为扩展名的文件:
#uncompress file.Z

3.以.gz为扩展名的文件:
#gunzip file.gz

4.以.bz2为扩展名的文件:
#bunzip2 file.bz2

5.以.tar.Z为扩展名的文件:
#tar xvZf file.tar.Z
或 #compress -dc file.tar.Z | tar xvf -

6.以.tar.gz/.tgz为扩展名的文件:
#tar xvzf file.tar.gz
或 gzip -dc file.tar.gz | tar xvf -

7.以.tar.bz2为扩展名的文件:
#tar xvIf file.tar.bz2
或 bzip2 -dc file.tar.bz2 | xvf -

8.以.cpio.gz/.cgz为扩展名的文件:
#gzip -dc file.cgz | cpio -div

9.以.cpio/cpio为扩展名的文件:
#cpio -div file.cpio
或cpio -divc file.cpio

10.以.rpm为扩展名的文件安装:
#rpm -i file.rpm

11.以.rpm为扩展名的文件解压缩:
#rpm2cpio file.rpm | cpio -div

12.以.deb为扩展名的文件安装:
#dpkg -i file.deb

13.以.deb为扩展名的文件解压缩:
#dpkg-deb --fsys-tarfile file.deb | tar xvf - ar p
file.deb data.tar.gz | tar xvzf -

14.以.zip为扩展名的文件:
#unzip file.zip
在linux下解压Winzip格式的文件
  要是装了jdk的话,可以用jar命令;还可以使用unzip命令。
直接解压.tar.gz文件
  xxxx.tar.gz文件使用tar带zxvf参数,可以一次解压开。XXXX为文件名。 例如:
$tar zxvf xxxx.tar.gz 各种压缩文件的解压(安装方法)

文件扩展名 解压(安装方法)

.a ar xv file.a
.Z uncompress file.Z
.gz gunzip file.gz
.bz2 bunzip2 file.bz2
.tar.Z tar xvZf file.tar.Z
compress -dc file.tar.Z | tar xvf -
.tar.gz/.tgz tar xvzf file.tar.gz
gzip -dc file.tar.gz | tar xvf -
.tar.bz2 tar xvIf file.tar.bz2
bzip2 -dc file.tar.bz2 | xvf -
.cpio.gz/.cgz gzip -dc file.cgz | cpio -div
.cpio/cpio cpio -div file.cpio
cpio -divc file.cpio
.rpm/install rpm -i file.rpm
.rpm/extract rpm2cpio file.rpm | cpio -div
.deb/install dpkg -i file.deb
.deb/exrtact dpkg-deb --fsys-tarfile file.deb | tar xvf -
ar p file.deb data.tar.gz | tar xvzf -
.zip unzip file.zip

bzip2 -d myfile.tar.bz2 | tar xvf

tar xvfz myfile.tar.bz2

x 是解压
v 是复杂输出
f 是指定文件
z gz格式

gzip
gzip[选项]要压缩(或解压缩)的文件名
-c将输出写到标准输出上,并保留原有文件。
-d将压缩文件压缩。
-l对每个压缩文件,显示下列字段:压缩文件的大小,未压缩文件的大小、压缩比、未压缩文件的名字
-r递归式地查找指定目录并压缩或压缩其中的所有文件。
-t测试压缩文件是正完整。
-v对每一个压缩和解压缩的文件,显示其文件名和压缩比。
-num-用指定的数字调整压缩的速度。
举例:
把/usr目录并包括它的子目录在内的全部文件做一备份,备份文件名为usr.tar
tar cvf usr.tar /home
把/usr 目录并包括它的子目录在内的全部文件做一备份并进行压缩,备份文件名是usr.tar.gz
tar czvf usr.tar.gz /usr
压缩一组文件,文件的后缀为tar.gz
#tar cvf back.tar /back/
#gzip -q back.tar
or
#tar cvfz back.tar.gz /back/
释放一个后缀为tar.gz的文件。
#tar zxvf back.tar.gz
#gzip back.tar.gz
#tar xvf back.tar

tar的使用方法:


1:压缩一组文件为tar.gz后缀
tar cvf backup.tar /etc
或gzip -q backup.tar.gz

2:释放一个后缀为tar.gz的文件
gunzip backup.tar.gz
或tar xvf backup.tar

3:用一个命令完成压缩
tar cvf -/etc | gzip -qc > backup.tar.gz

4:用一个命令完成释放
gunzip -c backup.tar.gz | tar xvf -

5:如何解开ta.Z的文件
tar xvfz backup.tar.Z
或uncompress backup.tar.Z
tar xvf backup.tar

6:如何解开.tgz文件
gunzip backup.tgz

7:如何压缩和解压缩.bz2的包
bzip2 /etc/smb.conf 这将压缩文件smb.conf成smb.conf.bz2
bunzip2 /etc/smb.conf.bz2 在当前目录下还原smb.conf.bz2为smb.conf

posted @ 2006-01-25 14:28 隐语者 阅读(549) | 评论 (0)编辑 收藏

# /etc/hosts :“hosts”文件,定义了主机名和ip地址的对应,其中也有将要运行dns这台电脑的ip地址和主机名。内容:
127.0.0.1 localhost.localdomain localhost

#/etc/host.conf :“host.conf”文件,"order hosts bind"语句,指定了对主机名的解析顺序是先到hosts中查找,然后到dns服务器的记录里查找。“multi on”则是允许一个主机名对应多个ip地址。内容:
order hosts, bind
multi on
nospoof on

#/etc/resolv.conf:“resolv.conf”文件,“nameserver 11.0.0.1”指定了DNS服务器的地址。注意,这个文件对普通非dns服务器的电脑(非windows的系统;Windows系统是在“网络属性”中设置这项的)来说,是必不可少的。你如果没有设置本机为dns服务器,你又要能够解析域名,就必须指定一个dns服务器的地址。你可以最多写上三个地址,作为前一个失败时的候选dns服务器。“domain honston.com”指定默认的域。文件内容:
domain 21php.com
nameserver 11.0.0.1

网关配置文件:

#/etc/sysconfig/network-scripts/ifcfg-eth0(第一块网卡的网络配置文件)。文件内容:

DEVICE=eth0
BOOTPROTO=none
BROADCAST=192.168.0.255
HWADDR=00:50:FC:76:51:DB
IPADDR=192.168.0.2
NETMASK=255.255.255.0
NETWORK=192.168.0.0
ONBOOT=yes
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
GATEWAY=192.168.0.1

网络配置命令: ifconfig 具体用法使用, ifconfig --help命令查询。

down掉网关: ifconfig eth0 down(关掉第一块网卡)

激活网关: ifconfig eth0 up(激活第一块网卡)

posted @ 2006-01-25 11:36 隐语者 阅读(304) | 评论 (0)编辑 收藏

2005年12月29日

tomcat5的连接池配置:
    <Resource name="jdbc/testDB" auth="Container" type="javax.sql.DataSource"
        factory="org.apache.commons.dbcp.BasicDataSourceFactory"
        maxActive="10"
        maxIdle="10"
        maxWait="10"
        username="sa"
        password=""
        driverClassName="com.jnetdirect.jsql.JSQLDriver"
        defaultAutoCommit="true"
        url="jdbc:JSQLConnect://localhost/testDB"
        removeAbandoned="true"
        removeAbandonedTimeout="10"
    />
tomcat4的连接池配置:
    <Resource name="jdbc/testDB" auth="Container" type="javax.sql.DataSource"/>
    <ResourceParams name="jdbc/testDB">
        <parameter>
            <name>factory</name>
            <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
        </parameter>
        <parameter>
            <name>maxActive</name>
            <value>10</value>
        </parameter>
        <parameter>
            <name>maxIdle</name>
            <value>10</value>
        </parameter>
        <parameter>
            <name>maxWait</name>
            <value>10</value>
        </parameter>
        <parameter>
            <name>username</name>
            <value>sa</value>
        </parameter>
        <parameter>
            <name>password</name>
            <value></value>
        </parameter>
        <parameter>
            <name>driverClassName</name>
            <value>com.jnetdirect.jsql.JSQLDriver</value>
        </parameter>
        <parameter>
            <name>defaultAutoCommit</name>
            <value>true</value>
        </parameter>
        <parameter>
            <name>url</name>
            <value>jdbc:JSQLConnect://localhost/testDB</value>
        </parameter>
        <parameter>
            <name>removeAbandoned</name>
            <value>true</value>
        </parameter>
        <parameter>
            <name>removeAbandonedTimeout</name>
            <value>10</value>
        </parameter>
        <parameter>
            <name>logAbandoned</name>
            <value>true</value>
        </parameter>
    </ResourceParams>

如果将tomcat4的连接池配置直接用到tomcat5中的话,会出现:
Cannot create JDBC driver of class '' for connect URL 'null'的错误

posted @ 2005-12-29 17:01 隐语者 阅读(602) | 评论 (0)编辑 收藏

2005年12月19日

parseInt(obj) —— 判断obj是否为整数,如果为有小数点的数字(包括后面多个小数点)则自动截掉小数后的所有位数(不四舍五入);如果不为数字,则返回NaN。

parseFloat(obj)——判断obj是否为浮点数,如果为有小数点的数字(包括后面多个小数点)则自动截掉第2个小数点的所有位数(不四舍五入);如果不为数字,则返回NaN。

isNaN(obj)——判断obj是否为字符串,如果返回true,则为字符串;如果返回为false,则为数值(带小数点)。


文章来源:http://java.mblogger.cn/love_java/posts/18171.aspx

posted @ 2005-12-19 09:34 隐语者 阅读(2053) | 评论 (0)编辑 收藏

转载地址:

http://www.matrix.org.cn/resource/article/43/43634_java_generics.html

J2SE 5.0中的泛型

作者:Budi Kurniawan

翻译:RR00

email:di_feng_ro@hotmail.com


版权声明:可以任意转载,转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
英文原文地址:
http://www.onjava.com/pub/a/onjava/2005/07/06/generics.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43634_java_generics.html
关键词: java generics java5

摘要
泛型是J2SE 5.0最重要的特性。他们让你写一个type(类或接口)和创建一个实例通过传递一个或多个引用类型。这个实例受限于只能作用于这些类型。比如,在 java 5,java.util.List 已经被泛化。当建立一个list对象时,你通过传递一个java类型建立一个List实例,此list实例只能作用于所传递的类型。这意味着如果你传递一个String ,此List实例只能拥有String对象;如果你传递一个Integer,此实例只能存贮Integer对象。除了创建参数化的类型,你还能创建参数化的函数。
泛型的第一个好处是编译时的严格类型检查。这是集合框架最重要的特点。此外,泛型消除了绝大多数的类型转换。在JDK 5.0之前,当你使用集合框架时,你不得不进行类型转换。
本文将教你如何操作泛型。它的第一部分是“没有泛型的日子”,先让我们回忆老版本JDK的不便。然后,举一些泛型的例子。在讨论完语法以及有界泛型的使用之后,文章最后一章将解释如何写泛型。


没有泛型的日子
所有的java类都源自java.lang.Object,这意味着所有的JAVA对象能转换成Object。因此,在之前的JDK的版本中,很多集合框架的函数接受一个Object参数。所以,collections是一个能持有任何对象的多用途工具,但带来了不良的后果。

举个简单的例子,在JDK 5.0的之前版本中,类List的函数add接受一个Object参数:

public boolean add(java.lang.Object element)


所以你能传递任何类型给add。这是故意这么设计的。否则,它只能传递某种特定的对象,这样就会出现各种List类型,如,StringList, EmployeeList, AddressList等。
add通过Object传递能带来好处,现在我们考虑get函数(返回List中的一个元素).如下是JDK 5之前版本的定义:

public java.lang.Object get(int index) throws IndexOutOfBoundsException


get返回一个Object.不幸的事情从此开始了.假如你储存了两个String对象在一个List中:

List stringList1 = new ArrayList();
stringList1.add("Java 5");
stringList1.add("with generics");


当你想从stringList1取得一个元素时,你得到了一个Object.为了操作原来的类型元素,你不得不把它转换为String。

String s1 = (String) stringList1.get(0);


但是,假如你曾经把一个非String对象加入stringList1中,上面的代码会抛出一个ClassCastException. 有了泛型,你能创建一个单一用途的List实例.比如,你能创建一个只接受String对象的List实例,另外一个实例只能接受Employee对象. 这同样适用于集合框架中的其他类型.


泛型入门

像一个函数能接受参数一样,一个泛型也能接受参数.这就是一个泛型经常被称为一个参数化类型的原因.但是不像函数用()传递参数,泛型是用<>传递参数的.声明一个泛型和声明一个普通类没有什么区别,只不过你把泛型的变量放在<>中.
比如,在JDK 5中,你可以这样声明一个java.util.List : List<E> myList;
E 称为类型变量.意味着一个变量将被一个类型替代.替代类型变量的值将被当作参数或返回类型.对于List接口来说,当一个实例被创建以后,E 将被当作一个add或别的函数的参数.E 也会使get或别的参数的返回值.下面是add和get的定义:

boolean add<E o>
E get(int index)


NOTE:一个泛型在声明或例示时允许你传递特定的类型变量: E.除此之外,如果E是个类,你可以传递子类;如果E是个接口,你可以传递实现接口的类;

-----------------------------译者添加--------------------
List<Number> numberList= new ArrayList<Number>();
numberList.add(2.0);
numberList.add(2);
-----------------------------译者添加--------------------


如果你传递一个String给一个List,比如:

List<String> myList;


那么mylist的add函数将接受一个String作为他的参数,而get函数将返回一个String.因为返回了一个特定的类型,所以不用类型转化了。

NOTE:根据惯例,我们使用一个唯一的大写字目表示一个类型变量。为了创建一个泛型,你需在声明时传递同样的参数列表。比如,你要想创建一个ArrayList来操作String ,你必须把String放在<>中。如:

List<String> myList = new ArrayList<String>();


再比如,java.util.Map 是这么定义的:

public interface Map<K,V>


K用来声明map键(KEY)的类型而V用来表示值(VALUE)的类型。put和values是这么定义的:

V put(K key, V value)
Collection<V> values()


NOTE:一个泛型不准直接的或间接的是java.lang.Throwable的子类。因为异常是在运行时抛出的,所以它不可能预言什么类型的异常将在编译时抛出.

列表1的例子将比较List在JDK 1.4 和JDK1.5的不同

package com.brainysoftware.jdk5.app16;
import java.util.List;
import java.util.ArrayList;

public class GenericListTest {
  public static void main(String[] args) {
    // in JDK 1.4
    List stringList1 = new ArrayList();
    stringList1.add("Java 1.0 - 5.0");
    stringList1.add("without generics");
    // cast to java.lang.String
    String s1 = (String) stringList1.get(0);
    System.out.println(s1.toUpperCase());

    // now with generics in JDK 5
    List<String> stringList2 = new ArrayList<String>();
    stringList2.add("Java 5.0");
    stringList2.add("with generics");
    // no need for type casting
    String s2 = stringList2.get(0);
    System.out.println(s2.toUpperCase());
  }
}


在列表1中,stringList2是个泛型。声明List<String>告诉编译器List的实例能接受一个String对象。当然,在另外的情况中,你能新建能接受各种对象的List实例。注意,当从List实例中返回成员元素时,不需要对象转化,因为他返回的了你想要的类型,也就是 String.

NOTE:泛型的类型检查(type checking)是在编译时完成的.

最让人感兴趣的事情是,一个泛型是个类型并且能被当作一个类型变量。比如,你想你的List储存lists of Strings,你能通过把List<String>作为他的类型变量来声明List。比如:

List<List<String>> myListOfListsOfStrings;


要从myList中的第一个List重新取得String,你可以这么用:

String s = myListOfListsOfStrings.get(0).get(0);


下一个列表中的ListOfListsTest类示范了一个List(命名为listOfLists)接受一个String List作为参数。

package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;
public class ListOfListsTest {
  public static void main(String[] args) {
    List<String> listOfStrings = new ArrayList<String>();
    listOfStrings.add("Hello again");
    List<List<String>> listOfLists = new ArrayList<List<String>>();
    listOfLists.add(listOfStrings);
    String s = listOfLists.get(0).get(0);
    System.out.println(s); // prints "Hello again"
  }
}


另外,一个泛型接受一个或多个类型变量。比如,java.util.Map有两个类型变量s。第一个定义了键(key)的类型,第二个定义了值(value)的类型。下面的例子讲教我们如何使用个一个泛型Map.

package com.brainysoftware.jdk5.app16;
import java.util.HashMap;
import java.util.Map;
public class MapTest {
  public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("key1", "value1");
    map.put("key2", "value2");
    String value1 = map.get("key1");
  }
}


在这个例子中,重新得到一个key1代表的String值,我们不需要任何类型转换。

没有参数的情况下使用泛型

既然在J2SE 5.0中收集类型已经泛型化,那么,原来的使用这些类型的代码将如何呢?很幸运,他们在JAVA 5中将继续工作,因为你能使用没有参数的泛型。比如,你能继续像原来一样使用List接口,正如下面的例子一样。

List stringList1 = new ArrayList();
stringList1.add("Java 1.0 - 5.0");
stringList1.add("without generics");
String s1 = (String) stringList1.get(0);


一个没有任何参数的泛型被称为原型(raw type)。它意味着这些为JDK1.4或更早的版本而写的代码将继续在java 5中工作。

尽管如此,一个需要注意的事情是,JDK5编译器希望你使用带参数的泛型。否则,编译器将提示警告,因为他认为你可能忘了定义类型变量s。比如,编译上面的代码的时候你会看到下面这些警告,因为第一个List被认为是原型。

Note: com/brainysoftware/jdk5/app16/GenericListTest.java
uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

当你使用原型时,如果你不想看到这些警告,你有几个选择来达到目的:
1.编译时带上参数-source 1.4
2.使用@SupressWarnings("unchecked")注释
3.更新你的代码,使用List<Object>. List<Object>的实例能接受任何类型的对象,就像是一个原型List。然而,编译器不会报错。

使用 ? 通配符
前面提过,如果你声明了一个List<aType>, 那么这个List对aType起作用,所以你能储存下面这些类型的对象:
1.一个aType的实例
2.它的子类的实例(如果aType是个类)
3.实现aType接口的类实例(如果aType是个接口)
但是,请注意,一个泛型本身是个JAVA类型,就像java.lang.String或java.io.File一样。传递不同的类型变量给泛型可以创建不同的JAVA类型。比如,下面例子中list1和list2引用了不同的类型对象。

List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();


list1 指向了一个类型变量s为java.lang.Objects 的List而list2指向了一个类型变量s为String 的List。所以传递一个List<String>给一个参数为List<Object>的函数将导致compile time错误。下面列表可以说明:
package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;

public class AllowedTypeTest {
  public static void doIt(List<Object> l) {
  }
  public static void main(String[] args) {
    List<String> myList = new ArrayList<String>();
    // 这里将产生一个错误
    doIt(myList);
  }
}

上面的代码无法编译,因为你试图传递一个错误的类型给函数doIt。doIt的参数是List<Object>二你传递的参数是List<String>。
可以使用 ? 通配符解决这个难题。List<?> 意味着一个对任何对象起作用的List。所以,doIt可以改为:

public static void doIt(List<?> l) {}


在某些情况下你会考虑使用 ? 通配符。比如,你有一个printList函数,这个函数打印一个List的所有成员,你想让这个函数对任何类型的List起作用时。否则,你只能累死累活的写很多printList的重载函数。下面的列表引用了使用 ? 通配符的printList函数。
package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;

public class WildCardTest {

  public static void printList(List<?> list) {
    for (Object element : list) {
      System.out.println(element);
    }
  }
  public static void main(String[] args) {
    List<String> list1 = new ArrayList<String>();
    list1.add("Hello");
    list1.add("World");
    printList(list1);

    List<Integer> list2 = new ArrayList<Integer>();
    list2.add(100);
    list2.add(200);
    printList(list2);
  }
}


这些代码说明了在printList函数中,List<?>表示各种类型的List对象。然而,请注意,在声明的时候使用 ? 通配符是不合法的,像这样:

List<?> myList = new ArrayList<?>(); // 不合法


如果你想创建一个接收任何类型对象的List,你可以使用Object作为类型变量,就像这样:

List<Object> myList = new ArrayList<Object>();


在函数中使用界限通配符
在之前的章节中,你学会了通过传递不同的类型变量s来创建不同JAVA类型的泛型,但并不考虑类型变量s之间的继承关系。在很多情况下,你想一个函数有不同的List参数。比如,你有一个函数getAverage,他返回了一个List中成员的平均值。然而,如果你把List<Number>作为getAverage的参数,你就没法传递List<Integer> 或List<Double>参数,因为List<Number>和List<Integer> 和List<Double>不是同样的类型。

你能使用原型或使用通配符,但这样无法在编译时进行安全类型检查,因为你能传递任何类型的List,比如List<String>的实例。你可以使用List<Number>作为参数,但是你就只能传递 List<Number>给函数。但这样就使你的函数功能减少,因为你可能更多的时候要操作List<Integer>或 List<Long>,而不是List<Number>。

J2SE5.0增加了一个规则来解决了这种约束,这个规则就是允许你定义一个上界(upper bound) 类型变量.在这种方式中,你能传递一个类型或它的子类。在上面getAverage函数的例子中,你能传递一个List<Number>或它的子类的实例,比如List<Integer> or List<Float>。

使用上界规则的语法这么定义的:GenericType<? extends upperBoundType>. 比如,对getAverage函数的参数,你可以这么写List<? extends Number>. 下面例子说明了如何使用这种规则。
package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;
public class BoundedWildcardTest {
  public static double getAverage(List<? extends Number> numberList)
  {
    double total = 0.0;
    for (Number number : numberList)
      total += number.doubleValue();
    return total/numberList.size();
  }

  public static void main(String[] args) {
    List<Integer> integerList = new ArrayList<Integer>();
    integerList.add(3);
    integerList.add(30);
    integerList.add(300);
    System.out.println(getAverage(integerList)); // 111.0
    List<Double> doubleList = new ArrayList<Double>();
    doubleList.add(3.0);
    doubleList.add(33.0);
    System.out.println(getAverage(doubleList)); // 18.0
  }
}

由于有了上界规则,上面例子中的getAverage函数允许你传递一个List<Number> 或一个类型变量是任何java.lang.Number子类的List。

下界规则
关键字extends定义了一个类型变量的上界。通过使用super关键字,我们可以定义一个类型变量的下界,尽管使用的情况不多。比如,如果一个函数的参数是List<? super Integer>,那么意味着你可以传递一个List<Integer>的实例或者任何java.lang.Integer的超类 (superclass)。

创建泛型

前面的章节主要说明了如何使使用泛型,特别是集合框架中的类。现在我们开始学习如何写自己的泛型。

基本上,除了声明一些你想要使用的类型变量s外,一个泛型和别的类没有什么区别。这些类型变量s位于类型后面的<>中。比如,下面的Point 就是个泛型。一个Point对象代表了一个系统中的点,它有横坐标和纵坐标。通过使Point泛型化,你能定义一个点实例的精确程度。比如,如果一个 Point对象需要非常精确,你就把Double作为类型变量。否则,Integer 就够了。
package com.brainysoftware.jdk5.app16;
public class Point<T> {
  T x;
  T y;
  public Point(T x, T y) {
    this.x = x;
    this.y = y;
  }
  public T getX() {
    return x;
  }
  public T getY() {
    return y;
  }
  public void setX(T x) {
    this.x = x;
  }
  public void setY(T y) {
    this.y = y;
  }
}


在这个例子中,T是Point的类型变量 。T是getX和getY的返回值类型,也是setX和setY的参数类型。此外,构造函数结合两个T参数。
使用point类就像使用别的类一样。比如,下面的例子创建了两个Point对象:ponint1和point2。前者把Integer作为类型变量,而后者把Double作为类型变量。

Point<Integer> point1 = new Point<Integer>(4, 2);
point1.setX(7);
Point<Double> point2 = new Point<Double>(1.3, 2.6);
point2.setX(109.91);


总结
泛型使代码在编译时有了更严格的类型检查。特别是在集合框架中,泛型有两个作用。第一,他们增加了对集合类型在编译时的类型检查,所以集合类所能持有的类型对传递给它的参数类型起了限制作用。比如你创建了一个持有strings的java.util.List实例,那么他就将不能接受Integers或别的类型。其次,当你从一个集合中取得一个元素时,泛型消除了类型转换的必要。
泛型能够在没有类型变量的情况下使用,比如,作为原型。这些措施让Java 5之前的代码能够运行在JRE 5中。但是,对新的应用程序,你最好不要使用原型,因为以后Java可能不支持他们。

你已经知道通过传递不同类型的类型变量给泛型可以产生不同的JAVA类型。就是说List<String>和List< Object>的类型是不同的。尽管String是java.lang.Object。但是传递一个List<String>给一个参数是List<Object>的函数会参数会产生编译错误(compile error)。函数能用 ? 通配符使其接受任何类型的参数。List<?> 意味着任何类型的对象。
最后,你已经看到了写一个泛型和别的一般JAVA类没有什么区别。你只需要在类型名称后面的<>中声明一系列的类型变量s就行了。这些类型变量s就是返回值类型或者参数类型。根据惯例,一个类型变量用一个大写字母表示。


Budi Kurniawan是一个高级 J2EE 架构师和作家。

文章来源:http://java.mblogger.cn/love_java/posts/18270.aspx

posted @ 2005-12-19 09:34 隐语者 阅读(157) | 评论 (0)编辑 收藏

select owner, view_name, text? from all_views where view_name='';

使用该sql语句能查询指定的视图的创建脚本.


文章来源:http://java.mblogger.cn/love_java/posts/18281.aspx

posted @ 2005-12-19 09:34 隐语者 阅读(480) | 评论 (0)编辑 收藏

假设select对象为oSelect,删除该对象下面所有选项的方法是:

oSelect.options.length=0;


文章来源:http://java.mblogger.cn/love_java/posts/18309.aspx

posted @ 2005-12-19 09:34 隐语者 阅读(799) | 评论 (1)编辑 收藏

相同:
           
XSL和CSS都是属于样式的一种。样式是用来设定外观的,它并不影响原来的XML源代码,
            XSL虽然用的是转换的方式,但转换并不代表源代码会遭到篡改。通常XSL转换后的输出码是
            另存到一个新的档案或暂存在浏览器的记忆体中,原来的XMl文档内容保持不变。

不同:
           1、XSL采用的是转换方式,将一种格式的XML转换为另一种,比如将Big5码转换为UTF-8码一
                 样。而CSS则来自完全不同的理念:它不含任何转换动作,只针对XML文件中各个成分的外
                 观属性一一加以设定。浏览器便按照CSS样式里的指示,将XML文件呈现为设定的样式。整
                 个过程中没有任何新码产生。XML配上CSS、ECMAScript和DOM可以营造出类似DHTML般
                  的动态效果。XSL转换则是死的,没有互动性。

           2、XSL样式都是XML文件,完全按照XML的语法来;相对地,CSS在语法上自成一格,和
                 XML的写法大相径庭。 


文章来源:http://java.mblogger.cn/love_java/posts/18639.aspx

posted @ 2005-12-19 09:34 隐语者 阅读(658) | 评论 (0)编辑 收藏

使用hex编辑器打开你vss数据库所在的文件夹,打开data目录下的um.dat文件.将文件中对应位置改为如下字符:

 0:80  55 55 bc 7f 41 64 6d 69 6e 00 00 00 00 00 00 00
 0:90  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 0:a0  00 00 00 00 90 6e 00 00 a8 01 00 00 00 00 00 00

保存修改文件,启动vss admin工具,直接就能登录.


文章来源:http://java.mblogger.cn/love_java/posts/18676.aspx

posted @ 2005-12-19 09:34 隐语者 阅读(862) | 评论 (0)编辑 收藏