日本的新一代

IN THIS ARTICLE: Japanese students seem to be losing patience with work ... (and) prefer easy jobs without heavy responsibility.

本文简介：日本学生似乎正对工作失去耐心…（而且）更喜欢无需负重大责任的轻松工作。

[1]Japan's post-World War II value system of diligence, cooperation, and hard work is changing. Recent surveys show that Japanese youth have become a "Me Generation" that rejects traditional values.

[2] "Around 1980 many Japanese, especially young people, abandoned the values of economic success and began searching for new sets of values to bring them happiness," writes sociologist Yasuhiro Yoshizaki in Comparative Civilizations Review. Japanese youth are placing more importance on the individual's pursuit of happiness and less on the values of work, family, and society.

[3] Japanese students seem to be losing patience with work, unlike their counterparts in the United States and Korea. In a 1993 survey of college students in the three countries, only 10% of the Japanese regarded work as a primary value, compared with 47% of their Korean counterparts and 27% of American students. A greater proportion of Japanese aged 18 to 24 also preferred easy jobs without heavy responsibility.

[1]日本二战以后形成的勤奋、合作和努力工作的价值体系正在发生变化。最近的调查显示，日本青年已变成了拒绝传统价值观的“自我一代”。

[2]“1980年前后，许多日本人，特别是年轻人，摒弃了经济上成功的价值基准，开始寻找能给他们带来幸福快乐的新的价值准则，”社会学家吉崎康宏在《文明比较评论》一书中这样写道。日本青年人现在越来越重视追求个人幸福而越来越少关注工作、家庭和社会的价值基准。

[3]日本学生似乎正对工作失去耐心，而美国和韩国学生却不是这样。在一项1993年的对这三个国家的高校学生进行的调查中，只有10％的日本人认为工作是一个主要的价值体现物，而韩国人和美国人分别是47％和27％。年龄在18到24岁的大多数日本人还更喜欢无需负重大责任的轻松工作。

[4] Concern for family values is waning among younger Japanese as they pursue an inner world of private satisfaction. Data collected by the Japanese government in 1993 shows that only 2304 of Japanese youth are thinking about supporting their aged parents, in contrast to 63% of young Americans. It appears that many younger-generation Japanese are losing both respect for their parents and a sense of responsibility to the family. Author Yoshizaki attributes the change to Japanese parents' over-indulgence(过分溺爱) of their children, material affluence, and growing concern for private matters.

[5] The shift toward individualism among Japanese is most pronounced among the very young. According to 1991 data from the Seimei Hoken Bunka Center of Japan, 50% of Japanese youth aged 16 to 19 can be labeled "self-centered(以自我为中心)", compared with 33% among those aged 25 to 29 To earn the self-centered label, the young people responded positively to such ideas as "I would like to make decisions without considering traditional values" and "I don't want to do anything I can't enjoy doing".

[6] Diminishing social responsibility, according to Yoshizaki, is tied to the growing interest in pleasure and personal satisfaction. A study comparing society-conscious youth from 1977 to 1990 found that the Japanese had slipped far behind(落后) American and Australian students. Only 11 % of Japanese aged 18 to 24 said they get personal satisfaction in doing something on behalf of(代表) society, according to 1993 data from the Japanese government, while four limes as many Americans said 50.

[7] Yoshizaki concludes that the entire value system of Japanese youth is undergoing major transformation, but the younger generation has not yet found a new organized value system to replace the old.

[4]日本小青年中对家庭价值基准的关心在逐渐衰退，取而代之的是追求个人内心世界的满足。日本政府于1993年搜集的数据表明，只有23%的日本青年想着要供养年迈的父母，与美国青年的63%形成鲜明对比。这显示出很多年轻一代的日本人正丧失对父母的重视和对家庭的负任感。作者吉崎康宏将这种变化归咎于父母对对孩子的纵容溺爱、物质的富有和对个人事物关注程度的增强。

[5]日本人向个人主义的转变在青少年中最为显著。根据日本生命保险文化中心1991年的数据，50％的16到19岁的日本青年可被列为“以自我为中心”，则比之下在25到29岁的青年中这一数字仅为33％。对诸如“我作决定时无意考虑传统价值观”和“我不想做我无法喜欢做的任何事情”这样的想法持肯定态度为青年人赢得了以自我为中心的标签。

[6]吉崎康宏认为，社会责任感的削弱与个人满足和享乐的兴趣增长密切相关。一项从1977年到1990年对有社会意识的青年进行对比的研究发现，日本人远远落后于美国和澳大利亚学生。18到24岁的日本人中，只有11％说他们从为社会做事中得到个人满足，根据1993年日本政府的数据，这么说的美国人是日本人的四倍之多。

[7]吉崎康宏得出结论：日本青年整个价值体系正在发生重大变化，但年轻的一代尚未找到一个新的有组织的价值体系来取代旧的。

        “企业家”这一概念由法国经济学家让－巴蒂斯特在1800年首次提出，即：企业家使经济资源的效率由低转高；“企业家精神”则是企业家特殊技能（包括精神 和技巧）的集合。或者说，“企业家精神”指企业家组织建立和经营管理企业的综合才能的表述方式，它是一种重要而特殊的无形生产要素。例如，伟大的企业家、 索尼公司创始人盛田昭夫和井深大，他们创造的最伟大的“产品”不是收录机，也不是栅条彩色显像管，而是索尼公司和它所代表的一切；沃尔特•迪斯尼最伟大的 创造不是《木偶奇遇记》,也不是《白雪公主》，甚至不是迪斯尼乐园，而是沃尔特•迪斯尼公司及其使观众快乐的超凡能力；萨姆•沃尔顿最伟大的创造不是“持 之以恒的天天平价”而是沃尔玛公司——一个能够以最出色的方式把零售要领变成行动的组织。

送情（送礼物）。烧锅（做饭），嘿嘿。。。。。。。。。懂不懂哇。嘿嘿

-A-
AJAX: [Asynchronous JavaScript and XML，异步JavaScript及XML]
annotation: 注解
AOP: [aspect-oriented programming, 面向方面编程]
argument: 参数
-B-
B2B: [Business-to-Business, 业务对业务]
BAM: [Business Activity Monitoring, 业务活动监测]
BMP: [bean-managed persistence, Bean管理的持久化]
BPEL: [Business Process Excution Language, 业务流程执行语言]
BPM: [Business Process Modeling, 业务流程建模]
build: 建立；编译
-C-
C2B: [Consumer-to-Business, 客户对业务]
CAD: [Computer Aided Design, 计算机辅助设计]
CAM: [Computer Aided Modeling, 计算机辅助建模]
case-insensitive: 大小写不敏感
case-sensitive: 大小写敏感
container: 容器
cluster: 集群
CMP: [container-managed persistence, 容器管理的持久化]
component: 组件，部件
configuration: 配置
context: 上下文，环境
control: 控件
convention: 约定
CORBA: [Common Object Request Broker Architecture，公共对象请求代理体系]
COS: [Common Object Services，公共对象服务]
couple: 耦合
CRUD: 专指数据库操作create, read, update, delete
-D-
Daemon: [Internet中用于邮件收发的后台程序]
DAO: [Data Access Object, 数据访问对象]
data: 数据
DBMS: [Database Management System, 数据库管理系统]
DDL: [Data Definition Language, 数据定义语言]
Declarative Programming: 声明式编程
delegate: 委托
Dependency Injection: 依赖注入
deploy: 部署
deserialize: 反序列化(也可译为反串行化)，即取出
dialect: (行业)术语
directive: 指令
DIT: [Directory Information Tree, 目录信息树]
DML: [Data Manipulation Language, 数据操作语言]
DNS: [Internet Domain Name System, 因特网域名系统]
domain: 域
DSL: [Domain-Specific Languages, 特定领域语言]
DTOs: [data transfer objects, 数据传输对象]
-E-
EAI: [Enterprise Application Integration: 企业应用集成]
ECC: [error correcting codes: 错误纠正代码]
EIS: [Enterprise Information System: 企业信息系统]
EJB: [Enterprise JavaBean, 企业JavaBean]
encapsulate: 封装
ESB: [Enterprise Service Bus, 企业服务总线]
-F-
FAQs: [Frequently Asked Questions, 经常提问的问题]
FIFO: 先进先出 [First in, First out]
fire: 触发
firewall: 防火墙
framework: 框架
function: 函数
-G-
GoF: "四人帮"，对名著Design Patterns-Elements of Reusable Object-Oriented Software的四名作者的"戏"称。[Gang of Four]
granularity: 颗粒性，颗粒度
GUI: [Graphic User Interface: 图形用户接口]
GUID: [Globally Unique Identifier: 全球唯一标识符]
-H-
hard-coding: 硬碥码
Hibernate: [一种为应用程序提供持久化服务的框架]
-I-
IDE: 集成开发环境 [Integrated Development Environment]
implement: 实现
internet: 因特网 (也可以不译，原因：在中文环境下已经得到充分理解及认同)
intranet: 企业内部网
IoC: [Inversion of Control, 控制反转]
-J-
JavaBean:
JCP: [Java Community Process, Java社区研究]
JDBC: [Java DataBase Connectivity, Java数据库连接]
JDO: [Java Data Objects, Java数据对象]
JES: [Java Enterprise System, Java企业系统]
JFC: [JavaTM Foundation Classes, JAVA基础类集合了GUI组件以及其他能简化开发和展开桌面和Internet/Intranet应用的服务]
JOnAS: [ Java Open Application Server, Java开放应用服务器]
JNI: [ Java Native Interface , Java本地化接口]
JNDI: [Java Naming and Directory Interface, Java命名与目录接口]
JTA: [Java Transaction API: Java事务API]
JVM: [Java Virtual Machine: Java虚拟机]
JXTA: [一个用于P2P应用开发的网络计算平台]
-L-
Laszlo: [一个大量应用于internet应用程序的基于XML平台的开源项目]
LDAP: [Lightweight Directory Access Protocol, 轻量目录访问协议]
leverage: 均衡
-M-
MEPs: [message exchange patterns，消息交换模式]
meta: 元
metadata: 元数据
method signature: 方法签名
middleware: 中间件
mock: 虚拟的
modal dialog: 模态对话框
modular: 模组。是模块module的集合，它由多个独立的模块构成。
modular organization: 模组结构
module: 模块
MOM: [message-oriented middleware，面向消息的中间件]
MVC: [Model-View-Control，模型-视图-控制]
-N-
NDS: [Novell Directory Service，Novell目录服务]
NIS: [Network Information Service，网络信息服务]
node: 节点
-O-
ODMG: [Object Data Management Group, 对象数据管理组织]
OGNL: [Object Graph Navigation Language, 对象图导航语言]
OODBMS: [Object-Oriented Database Management System, 面向对象数据库管理系统]
ORM: [object-relational (O-R) mapping, 对象关系映射]
-P-
persistence: 持久化(使用SQL语句在关系数据库中存储数据)
POJO: [Plain Old Java Objects，简单初始Java对象]
POJI: [Plain Old Java Interface，简单初始Java接口]
procedural: 过程的
profiling: 配置
prototype: 原型
-R-
RAD: [Rapid application development，快速应用开发]
RCS: [Revision Control System，修订控制系统]
RMI: [Remote Method Invocation: 远程方法调用]
retrieve: 检索
RIAs: 丰富的Internet应用程序 [Rich Internet Applications]
RPC: [remote procedure calls，远程过程调用]
-S-
schema: 规划，设计，方案
serialize: 序列化(也可译为串行化)，即保存
session: 会话
SOA: [Service-Oriented Architecture: 面向服务体系]
SOAP: [Simple Object Access Protocol，简单对象访问协议]
SPI: [Service Provider Interface，服务提供接口]
Spring:
SQL: [Structured Query Language，结构化查询语言]
Struts: [一种基于MVC模式的Web应用程序框架]
surrogate keys: 替代键
-T-
tag: 标签
TDD: [Test Driven Development，测试驱动的开发]
third-party: 第三方，泛指其他开发商，生产商等
transaction: 事务
Tomcat: [一个非常有名的Java Web容器]
-U-
UDT: [user-defined column types: 用户定义字段类型]
use case: 用例
UI: 用户界面 (User Interface)
-W-
wizard: 向导
Web service: (可以不译，原因：专有名词) [Web服务]
WS-addressing: [web service寻址]
WSDL: [Web Service Description Language: Web服务描述语言]
WYSIWYG: 所见即所得 [What You See is What You Get]

HSQL 数据库引擎

HSQL 数据库引擎
开 放源码的数据库引擎―HSQL是基于Thomas Mueller的Hypersonic SQL项目。它完全是由Java是编写的同时也是一种广泛用于 嵌入式的数据库。它被包含在许多J2EE应用服务器中。在移动设备上，HSQL运行在PersonalJava和FP/PP平台上。HSQL是完全免费 的。你能自由地将它重新部署到你的应用程序中，这对移动应用程序来说是容易的。
HSQL提供一个支持％95JDBC接口和所有JDBC数据类型的 JDBC驱程。它支持事务，外键甚至Java存储过程。在HSQL中的表能寄存在内存中和保存在磁盘文件中。HSQL只有少于160-KB的存储器足迹 footprint。它也为PersonalJava设备发布了一个数据库管理控制台（经过Sharp Zaurus上的测试）
然而，HSQL缺少一些商业移动数据库上所需的高级性能和安全功能。更重要的是，HSQL不能提供任何同步解决方案。它也缺少一个为MIDP设备的解决方案。

Groovy <1> 语言特性

前言

Groovy 是基于 JRE 的脚本语言( Script )，是由James Strachan 和 Bob McWhirter 这两位天才发明的，（JSR 241 2004 年 3 月）。

和Perl，Python等等Script的设计初衷一样，作者希望Groovy能快速简洁地完成一些工作：如访问数据库以编写报告，编写单元测试用例(Unit Test Case)，快速实现产品原型（ProtoType) 等等。

同时为了降低学习曲线，Groovy 的语法和Java 近似，并吸收了 Ruby,Python 和SmallTalk 的一些特点，因此 Groovy 在某些场合可以扮演一种 “咖啡伴侣”的角色。

那么Groovy 和 Java 相比，有什么变化呢？ Groovy 和大部分Scripts一样：

1. 不用编译,通过解释运行。
2. 允许动态类型。
3. 合成结构容易。

因此,Groovy 是一种特别容易学习和使用的语言.

我们先借用IBM Groovy教程中的例子，下面的代码利用了Freemarker模板引擎来创建一个Template对象，然后将内容打印到标准输出。例(1)是Java代码，例(2)是Groovy代码。可以看到二者非常的类似。

//简单的 TemplateReader Java 类
import java.io.File;
import java.io.IOException;
import freemarker.template.Configuration;
import freemarker.template.Template;
public class TemplateReader {  
      public static void main(String[] args){
           try{
               Configuration cfg = Configuration.getDefaultConfiguration();
               cfg.setDirectoryForTemplateLoading(new File("C:/dev/projects/http-tester/src/conf"));
               Template temp = cfg.getTemplate("vendor-request.tmpl");
               System.out.println(temp.toString());
           }
           catch(IOException e){
               e.printStackTrace();
           }
     }
}

和例2 中的 Groovy 作为对比.

//用 Groovy 编写的更简单的 TemplateReader
//语法目前基于Groovy 1.0-JSR3
import freemarker.template.Configuration as tconf
import java.io.File
cfg = tconf.getDefaultConfiguration()
cfg.setDirectoryForTemplateLoading( new File("C:/dev/projects/http-tester/src/conf"))  
temp = cfg.getTemplate("vendor-request.tmpl")
println temp.toString()

Groovy显然精简得多：

1. Groovy 代码只需要更少的import 语句。此外，freemarker.template.Configuration 还使用了别名 tconf。
2. Groovy 允许直接使用类型为Template 的变量 tmpl 而不用声明其类型。
3. Groovy 不需要class 声明或者main 方法。
4. Groovy 不关心异常，可以不用导入Java需要的IOException。

对Groovy感兴趣吗？别忘了拜访它的主页 http://groovy.codehaus.org/ 并下载最新的Groovy发布包哦。（ray_linn）

Groovy的基础语法

Groovy 有很多优点。它很好地融合了 Ruby、Python 和 Smalltalk 的一些最有用的功能，同时保留了基于 Java 语言的核心语法。对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。对于刚接触 Java 平台的开发人员，它可以作为有更复杂语法和要求的 Java 语言的一个容易的入口点。

语法

Groovy的语句和Java类似，但是有一些特殊的地方。例如语句的分号是可选的。如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。

x = [1, 2, 3]
println x
y = 5; x = y + 7
println x
assert x == 12

另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。

动态类型

//Groovy 动态类型
myStr = "Hello World"

由于使用了动态类型，不需要继承就可以得到多态的全部功能：

class Song{  
  @Property length
  @Property name
}
class Book{
  def public name
  def public author
}
def doSomething(thing){  
  println "going to do something with a thing named = " + thing.name
}

这 里定义了两个Groovy 类，Song 和 Book。这两个类都包含一个 name 属性。函数 doSomething，它以一个 thing 为参数，并试图打印这个对象的 name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个 name 属性，那么它就可以工作。可见， Song 和 Book 的实例都可以作为 doSomething 的输入参数。

mySong = new Song(length:90, name:"Burning Down the House")
myBook = new Book(name:"One Duck Stuck", author:"Phyllis Root")
doSomething(mySong) //prints Burning Down the House
doSomething(myBook) //prints One Duck Stuck
def doSth=this.&doSomething
doSth(mySong)
doSth(myBook)

在例子的最后，我们还创建了doSomething的一个函数指针 doSth，最后的执行结果与调用doSoemthing是一样的。

值 得注意的是：与Groovy Beta不同，在使用新的JSR Groovy类时，类里面的所有的变量都必须加上 def 关键字或者 private、protected 或 public 这样的修饰符。当然，也可以用 @Property 关键字声明成员变量。在Script中则不必。

字符串

Groovy中的字符串允许使用双引号和单引号。

当使用双引号时，可以在字符串内嵌入一些运算式，Groovy允许您使用 与 bash 类似的 ${expression} 语法进行替换。可以在字符串中包含任意的Groovy表达式。

name="James"
println "My name is ${name},'00${6+1}'" //prints My name is James,'007'

Groovy还支持"uXXXX" 引用（其中X是16进制数），用来表示特殊字符，例如 "u0040" 与"@"字符相同。

大块文本

如果有一大块文本（例如 HTML 和 XML）不想编码，你可以使用Here-docs. here-docs 是创建格式化字符串的一种便利机制。它需要类似 Python 的三重引号(""")开头，并以三重引号结尾。

name = "James"
text = """
hello 
there ${name} how are you today?
"""
assert text != null
println(text)

在Groovy-JSR中，不再支持下面这种多行字符串，个人觉得似乎与Here-docs功能重叠：

foo = "hello 
           there
              how are things?"
println(foo)

对字符串的操作

1. contains 字符串中是否包含子字符串，'groovy'.contains('oo')将返回true;
2. count 返回字符串中子字符串出现的次数，'groooovy'.count('oo')将返回3.
3. tokenize 根据分隔符将字符串分解成子串，'apple^banana^grap'.tokenize('^')返回['apple','banana','grape']。
4. 减操作 'groovy'-'oo'，结果是'grvy'。
5. 乘操作 'oo'*3，结果是'oooooo'。

Groovy主要结构

逻辑分支

if-else语句

Groovy提供Java相同的if-else语句。

x = false
y = false
if ( !x ) {
    x = true
}
assert x == true
if ( x ) {
    x = false
} else{
    y = true
}
assert x == y

Groovy也支持三元操作符。

y = 5
x = (y > 1) ? "worked" : "failed"
assert x == "worked"

switch语句

Groovy的switch语句兼容Java代码，但是更灵活，Groovy的switch语句能够处理各种类型的switch值，可以做各种类型的匹配：

1. case值为类名，匹配switch值为类实例
2. case值为正则表达式，匹配switch值的字符串匹配该正则表达式
3. case值为集合，匹配switch值包含在集合中，包括ranges

除了上面的，case值与switch值相等才匹配。

x = 1.23
result = ""
switch ( x ) {
    case "foo": 
       result = "found foo"
        // lets fall through
    case "bar":
        result += "bar"
    case [4, 5, 6, 'inList']:
        result = "list"
        break
    case 12..30:
        result = "range"
        break
    case Integer:
        result = "integer"
        break
    case Number:
        result = "number"
        break
    default:
        result = "default"
}
assert result == "number"

Switch 语句的工作原理：switch语句在做case值匹配时，会调用isCase(switchValue)方法，Groovy提供了各种类型，如类，正则表 达式、集合等等的重载。可以创建自定义的匹配类，增加isCase(switchValue)方法来提供自定义的匹配类型。

循环

while和do 循环

Groovy支持Java相同的while循环，但目前暂不支持do循环

x = 0
y = 5
while ( y-- > 0 ){    
x++
}
assert x == 5

for循环

Groovy的for循环更简单，而且能够和各种类型的数组、集合、Map、范围等一起工作，我们稍候会详细介绍这些内容。

// iterate over a range
x = 0
for ( i in 0..9 ) {
    x += i
}
assert x == 45
// iterate over a list
x = 0
for ( i in [0, 1, 2, 3, 4] ) { 
   x += i
}
assert x == 10
// iterate over an array
array = (0..4).toArray()
x = 0
for ( i in array ) {
    x += i
}
assert x == 10
// iterate over a map
map = ['abc':1, 'def':2, 'xyz':3]
x = 0
for ( e in map ) {
    x += e.value
}
assert x == 6
// iterate over values in a map
x = 0
for ( v in map.values() ) 
{
    x += v
}
assert x == 6
// iterate over the characters in a string
text = "abc"
list = []
for (c in text) {
    list.add(c)
}
assert list == ["a", "b", "c"]

运行Groovy脚本

你可以象使用Perl一样编写Groovy脚本，不需要class，不需要Main入口点，也不需要声明变量；此外，你还可以用def语句来定义自己的函数，并在脚本中使用它。

像许多脚本语言一样，Groovy 是 在运行时解释的，无编译的代码在构建-运行周期中可以提供很多好处。运行时编译使 Groovy 成为快速原型设计、构建不同的实用程序和测试框架的理想平台。通过以下代码可以很简单的运行Groovy.

groovy HelloWorld.groovy

除了利用解释器来运行Groovy脚本外，Groovy 提供了两种不同的解释器Shell，使所有有效的 Groovy 表达式可以交互地执行：

1. 运行groovysh启动命令Shell，可以输入Groovy语句直接执行
2. 运行groovyConsole启动Swing方式的Groovy控制台，这是一个简单的Groovy编辑器

函数编程

我们知道例如Lisp、Scheme、Haskell、ML （或其他一些语言）采用了函数式编程。但“到底什么是函数式编程 (FP)？”不幸的是，即使是函数程序员他们自己也很难对 FP 究竟是什么有个一致的认识。

David Mertz 认为函数式编程粗略地描绘为至少具有以下几个特征：

1. 函数是第一类（对象）。即，可以对“数据”进行的每样操作都可以使用函数本身做到（例如将一个函数传递给另一个函数）。
2. 将递归用作主要的控制结构。在某些语言中，不存在其它“循环”构造。
3. 重点集中在列表 LISt 处理（例如，名称 Lisp ）。列表经常和子列表的递归一起使用以替代循环。
4. “纯”函数语言能够避免副作用。这不包括在命令语言中最普遍的模式，即指定第一个，然后将另一个值指定给同一个变量来跟踪程序状态。
5. FP 不鼓励或根本不允许出现 语句，取而代之是使用表达式求值（换句话说，即函数加上自变量）。在很纯粹的情况下，一个程序就是一个表达式（加上支持的定义）。
6. FP 关心的是计算 什么而不是 如何计算。
7. 许多 FP 利用了“更高等级”函数（换句话说，就是函数对一些函数操作，而这些函数又对其它函数操作）。

函数编程的提倡者认为所有这些特征都导致更快速的开发更短以及错误更少的代码。而且，计算机科学、逻辑和数学领域的高级理论学家发现证明函数语言和程序的正式性能比命令语言和程序容易得多。

无独有偶，新发布的C# 3.0 规格书也加入了函数式编程的味道，从某些方面看起来，C# 3.0和Groovy 有点神似。

类

1. 方法可以基于类（static）或实例
2. 可以为public、protected或private
3. 支持常用的Java修饰符，如synchronized

请注意，Groovy 1.0-JSR3与Groovy 1.0-Beta3在类定义上语法差别较大：

1. Groovy JSR 变量前都必须加上 def 关键字或者 private、protected 或 public 这样的修饰符；Groovy Beta3的类定义中的变量相当灵活，不需要任何关键字；（类定义外的变量不受影响。）
2. 声明属性可以用 @Property 关键字声明成员变量 ；有别于Beta3，这里P是大写的!
3. 变量默认为Private，方法默认为Public，除非使用了特定的访问修饰符；Groovy Beta3 类中定义的所有内容都默认为 public，除非定义了特定的访问修饰符；

例子 1 显示了在 Groovy 语言中如何声明一个Greeter的类，它有两个public的字段name和age。注意我们是如何为它们赋值的。

//无构造子的Groovy Greeter
class Greeter
{
   public name
   public age
   def SayHello(){
      println "Hello,${name},I am Groovy"
      println "I am ${age} years old!"
   }
   def static Introduce(){
	println "I am groovy greeter";
   }
}
Greeter.Introduce()
Greeter greeter=new Greeter(name:"Toms",age:2)
greeter.SayHello()

上面的例子等价于使用传统构造子的Greeter，但是更灵活。

//使用传统构造子的Groovy Greeter
class Greeter
{
   def name
   def age
   Greeter(name,age){
     this.name=name
     this.age=age
   }
   def SayHello(){
      println "Hello,${name},I am Groovy"
      println "I am ${age} years old!"
   }
   def static Introduce(){
	println "I am groovy greeter";
   }
}
Greeter.Introduce()
Greeter greeter=new Greeter("Toms",2)
greeter.SayHello()

接下来是一个复杂点的例子，其中类 Dog 有一个 getFullName 方法，它实际上返回一个表示 Dog 的全名的 String。

class Dog{
  public name
  def bark(){
    println "RUFF! RUFF!"
  }
  def getFullName(master){
    name + " " + master.lname
  }
  def obeyMaster(){ 
    println "I hear you and will not obey."
  }
}

我们可以看到，动态类型可以应用到字段和方法，因此参数类型是可选的（但是指定方法的参数类型和返回类型可以在通常的Java代码中更好的工作）。注意，最后return语句是可选（只要最后一条语句被执行，它的值就会被返回），缺省返回的是Object。

例子 4 是有两个属性 fname 和 lname 和一个方法的类 DogOwner。

class DogOwner{
  @Property fname
  @Property lname
  def trainPet(pet){
    pet.obeyMaster()
  }
}

方法调用的语法和Java类似，支持静态和实例方法。在例 5 中，我们用 Groovy对Dog和DogOwner的实例设置属性并调用了方法。

//使用 Groovy 类
myDog = new Dog()
myDog.name = "Mollie"
myDog.bark()
myDog.obeyMaster()
me = new DogOwner()
me.fname = "Ralf"
me.lname = "Waldo"
me.trainPet myDog //不需要括号
str = myDog.getFullName(me)
println str  // prints Mollie Waldo

我们看到在 Dog 类的 getFullName 方法返回一个 String 对象，在这里它是 “Mollie Waldo”。 在Groovy中方法的调用可以省略括号，只要有参数，并且没有歧义。

传递命名参数 在调用方法时，可以传递命名参数，参数的名字和值用分号分隔（象Map语法），参数名是唯一标识字符串。

bean = new Expando(name:"James", location:"London", id:007)
println "Hey " + bean.name
assert bean.id == 007

注意：当前这种方法传递只实现具有Map的方法调用或JavaBean。

闭包

Groovy 中最令人兴奋和最强大的功能是支持闭包。闭包（Closure）类似于 Java 语言中的匿名内部类。闭包和匿名内部类都是可执行的一段代码，不过这两者之间有一些细微的不同。状态是自动传入传出闭包的。闭包可以有名字。它们可以重复 使用。而且，最重要且对 Groovy 同样成立的是，闭包远比匿名内部类要灵活得多！闭包用以下方法定义：

{[comma-separated-Arguments-list ->] statements }

闭包用“{}”括起，“->”前面是参数，后面是处理语句。下面的例子演示了如何定义并使用一个闭包。第一个闭包演示了在字符串中使用参数的形式:${param}；第二个闭包演示了多参数形式：用逗号隔离参数。

closure = { name ->
               println("hello ${name}") }
closure.call("world!") 
closure = { greeting, name -> 
               println(greeting + name) }
closure("hello ", "world!")

有趣的是，闭包至少会有一个参数 “it”，它其实是参数表中的第一个参数，所以如果闭包定义中只有一个参数，可以省略不写，而使用缺省的参数“it”。对于没有参数定义的闭包，“it”的值就是 null 。

closure = { println "hello " + it }
closure("world!")

例子 9 展示了闭包的强大功能。新改进的 Dog 类包括一个 train 方法，它实际上执行创建了 Dog 实例的闭包。

class Dog{
    def train(action){
       action.call()
    }
}
sit = { println "Sit, Sit! Sit! Good dog"}
myDog = new Dog()
myDog.train(sit)  //prints Sit, Sit! Sit! Good dog
mollie = new Dog()
mollie.train { println "Down! DOWN!" } //prints DOWN! DOWN!

在 上面的例子里，我们还看到，闭包通过 call() 方法被调用。（在底层，call() 方法实现了对闭包隐含的doCall()方法的调用）。Groovy 中的大多数对象具有像 each 和 find 这样的以闭包为参数的方法。用闭包来迭代对象会产生几种令人兴奋的可能性：

[2, 4, 6, 8, 3].find { x |
     if (x == 3){
       println x
     }
}

其实就是：（你也许已经发现，可以用it代替x)

myFinder={ x |
    if(x==3)
        println x
}
[2,4,6,8,3].find(myFinder)

这里我们使用了一个 Groovy-Beta3 闭包定义，只是为了让您能看懂老版本Groovy的一些例子。在新的Groovy JSR中对闭包的定义略有改动，因为 | 字符同时也是 Java 中的位操作符；Groovy JSR 建议使用 Nice (另外一种JRE语言）样式的 -> 分隔符代替它。

这种以闭包为参数的代码在Groovy里十分普遍：

//each
(1..100).each{ println it}
//times 
1000.times{ println it} //values go from 0 to 9999
//upto
1.upto(1000){ println it}
//step 
1.step(1001,1){ println it} //values go from 1 to 1000;

http://groovy.codehaus.org/Closures

列表

创建一个列表与在 Java 语言中创建一个数组很类似。

collect = ['groovy', 29, 'Hello', 'Groovy']
empty=[]
assert empty.size() == 0
//添加元素
empty.add 1
assert empty.size() == 2

在上面的例子里，列表 collect 的第二项自动装箱为一个 Integer 类型。此外“[]”表示一个空列表,这个例子还演示了如何向列表中添加元素。

Groovy 还为集合增加了几个新方法，这些方法使得对列表的一些操作变得更加容易，如统计值出现的次数、将整个列表结合到一起、对列表排序等等。可以在例2 中看到这些集合方法的使用。

collect = [5, 9, 2, 2, 4, 5, 6] 
println collect.join(' - ')  // prints 5 - 9 - 2 - 2 - 4 - 5 - 6
println collect.count(2)     // prints 2
println collect.sort()       // prints [2, 2, 4, 5, 5, 6, 9]

Maps

像列表一样，映射也是一种在 Groovy 中非常容易处理的数据结构。例 3 中的映射包含两个对象，键是 name 和 date。注意可以用不同的方式取得值。 可以用“[:]”创造一个空的映射。

myMap = ["name" : "Groovy", "date" : new Date()]
println myMap["date"]
println myMap.date

Map可以象beans一样操作，但key值（类似属性名）必须为有效的String标识。下面的例子详细演示了Map的用法。

map = ["name":"Gromit", "likes":"cheese", "id":1234]
assert map.name == "Gromit"
assert map.id == 1234
//Create an empty maps
emptyMap = [:]
assert emptyMap.size() == 0
emptyMap.foo = 5 
assert emptyMap.size() == 1
assert emptyMap.foo == 5
emptyMap.put("bar",6)
assert emptyMap.get("bar") == 6
players = ['baseball':'Albert Pujols', 'golf':'Tiger Woods']
println players['golf'] // prints Tiger Woods
println players.golf // prints Tiger Woods
for (player in players) 
{
      println "${player.value} plays ${player.key}"
}
// This has the same result as the previous loop.
players.each {
      player |println "${player.value} plays ${player.key}"
}

范围

而且由于Range扩展java.util.List，所以Range可以作为List使用。

myRange = 29..<32
myInclusiveRange = 2..5
println myRange.size() // prints 3
println myRange[0]   // prints 29
println myRange.contains(32) //prints false
println myInclusiveRange.contains(5) //prints true
// an inclusive range and operations
range = 'a'..'d'
assert range.size() == 4
assert range.get(2) == 'c'
assert range instanceof java.util.List
assert range.contains('a')
assert range.contains('d')
assert ! range.contains('e')

迭代器

我们可以直接在集合上使用类似迭代器的方法。而且， Groovy 的迭代器方法接受闭包，每个迭代中都会调用闭包。

class IteratorExample1{
   static void main(args) {
     coll = ["JMS", "EJB", "JMX"]
     coll.each{ item | println item }
   }
}

范围可以用于循环遍历。例如，将 rang 定义为一个排除范围，循环打印 a、b、c 和 d。

aRange = 'a'..<'e'
for (i in aRange){
  println i
}

集合的其他功能

如果不熟悉 Python 和其他脚本语言，那么您在 Groovy 集合中发现的一些其他功能会让您印象深刻。例如，创建了集合后，可以用负数在列表中反向计数：

aList = ['python', 'ruby', 'groovy']
println aList[-1] // prints groovy
println aList[-3] // prints python

Groovy 还让您可以用范围分割列表。分割可获得列表的准确子集：

fullName = "Andrew James Glover"
mName = fullName[7..<13]
println "middle name: " + mName // prints James

Ruby的语法

集合类似于 Ruby如果愿意的话，还可以将 Groovy 集合作为 Ruby 集合。可以用类似 Ruby 的语法，以 << 语法附加元素、用 + 串接和用 - 对集合取差，甚至还可以用 * 语法处理集合的重复。 注意，还可以用 == 比较集合。

collec = [1, 2, 3, 4, 5]
collec << 6 //appended 6 to collec
acol = ['a','b','c'] * 3 //acol now has 9 elements
coll =  [10, 11]
coll2 = [12, 13]
coll3 = coll + coll2 //10,11,12,13
difCol = [1,2,3] - [1,2] //difCol is 3
assert [1, 2, 3] == [1, 2, 3] //true

集合的索引

可以在字符串、Lists、Maps...中使用下标进行索引

text = "nice cheese gromit!"
x = text[2]
assert x == "c"
assert x.class == String
sub = text[5..10]
assert sub == 'cheese'
map = ["name":"Gromit", "likes":"cheese", "id":1234]
assert map['name'] == "Gromit"
list = [10, 11, 12]
answer = list[2]
assert answer == 12 
list = 100..200
sub = list[1, 3, 20..25, 33]
assert sub == [101, 103, 120, 121, 122, 123, 124, 125, 133]

可以使用下标操作符更新项目：

list = ["a", "b", "c"]
list[2] = "d"
list[0] = list[1]
list[3] = 5
assert list == ["b", "b", "d", 5]

可以使用负索引从最后开始计数：

text = "nice cheese gromit!"
x = text[-1]
assert x == "!"
name = text[-7..-2]
assert name == "gromit"

也可以使用向后范围（开始索引大于结束索引），返回的结果是反转的

text = "nice cheese gromit!"
name = text[3..1]
assert name == "eci"

GroovySql 简介

在 Java 中，我们是这样利用JDBC来打印Music CD的样品：

package cc.ejb.groovy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class CdList {
     public static void main(String[] args) {
	 Connection con = null;
	 Statement stmt = null;
	 ResultSet rs = null;
	 try{
	      Class.forName("com.mysql.jdbc.Driver");
	      con = DriverManager.getConnection("jdbc:mysql://localhost:3306/samples","root", "");
	      stmt = con.createStatement();
	      rs = stmt.executeQuery("select * from cdbean");
	      while (rs.next()) {
	        System.out.println("id:" + rs.getLong(1) + " artist:" + rs.getString(2) + " type:" + rs.getString(3));
	      }
	 }catch(SQLException e){
	      e.printStackTrace();
	 }catch(ClassNotFoundException e){
	      e.printStackTrace();
	 }finally{
	      try{
	           rs.close();
	      }catch(Exception e){}
	      try{
	           stmt.close();
	      }catch(Exception e){}
	      try{
	           con.close();
	      }catch(Exception e){}
         } 
    }
}

利用迭代器和闭包，我们只需要短短的几行：

import groovy.sql.Sql
sql = Sql.newInstance("jdbc:mysql://localhost:3306/samples", "root","", "com.mysql.jdbc.Driver")
sql.eachRow("select * from cdbean"){ 
   println "id:${it.id} artist:${it.artist} type:${it.type}"
}

在上面这段脚本中，你看不到try...catch，也不用捕获任何exception，甚至你不用关闭 Connection，也不用关闭 ResultSet，或者在 JDBC 编程中可以找到的任何其他熟悉的重要特性。

脚本中eachRow 方法可以当成查询结果上的迭代器。每个迭代都会执行传递进去的闭包，并在闭包中打印出每一次迭代的内容，id,artist,type等等。

为了运行上面的例子，必须将MySql JDBC Driver添加到classpath中。

执行更复杂的查询

在下面的脚本中，您看到一个简单的 insert，它再次以 ${} 语法使用变量替换。这个代码只是向 cdbean 表插入一个新行。

id = 999
title ="Concept"
artist = "Nefarious"
type = "Blues"
sql.execute("insert into cdbean (id, title,artist, type, notes) values(${id},${title}, ${artist}, ${type},NULL)")

Groovy 还提供 execute 方法的一个重载版本，它接收一列值，这些值与查询中发现的 ? 元素对应。下面的例子查询了刚插入 cdbean 表中的数据。在底层，GroovySql 创建了普通 Java 语言 java.sql.PreparedStatement 的一个实例。

val = sql.execute("select * from cdbean where id = ?", [999])

更新的方式基本相同，也使用 executeUpdate 方法。executeUpdate 方法接收一列值，与查询中的 ? 元素对应。

id= 556 
artist = "Nefarious" 
sql.executeUpdate("update cdbean set id = ? where artist = ?", [id, artist])

删除实际上与插入相同，当然，语法不同，如例 9 所示。

sql.execute("delete from cdbean where id = ?" , [556])

数据集(DataSet)

构建于 GroovySql 简单性的基础之上，GroovySql 支持 DataSet 类型的概念，这基本上是数据库表的对象表示。使用 DataSet，您可以在行中遍历，也可以添加新行。实际上，用数据集是方便地表示表格的公共数据集合的方式。

但是，目前 GroovySql DataSet 类型的不足之处是它们没有代表关系；它们只是与数据库表的一对一映射。

import groovy.sql.Sql
class CdDataSetExample{
  static void main(args) {
    def sql = Sql.newInstance("jdbc:mysql://localhost:3306/samples", "root", "", "com.mysql.jdbc.Driver")
    def myCD = sql.dataSet("cdbean")
    myCD.each{ cd -> println "${cd.id}+ ${cd.title}"}
    myCD.add(id:"9999", title:"clerisy", artist:"Mary",type:"POP")
  }
}

GroovySql 的 DataSet 类型可以容易地用 each 方法对表的内容进行遍历，容易地用 add 方法添加新行，add 方法接受一个 map 表示需要的数据。

使用存储过程和负索引

存储过程调用和负索引（negative indexing）可能是数据操纵的重要方面。GroovySql 使存储过程调用简单得就像在 Sql 类上使用 call 方法一样。对于负索引， GroovySql 提供了自己增强的 ResultSet 类型，它工作起来非常像 Groovy 中的 collections。例如，如果您想获取结果集中的最后一个项目，您可以像例子 所示的那样做：

sql.eachRow("select * from cdbean where id=556"){ cd ->  println "-1  = " + cd.getAt(-2) 
//prints type
 println "2  = " + cd.getAt(3)
//prints type 
}

编写一个简单的报告应用程序

我们将利用 GroovySql 编写一个报告所需数据库统计信息的应用程序，您的目标数据库是 MySQL，它恰好支持用查询发现状态信息这一概念。以下是您有兴趣的状态信息：

1. 运行时间。
2. 处理的全部查询数量。
3. 特定查询的比例，例如 insert、update 和 select。

import groovy.sql.Sql
class StatusReport{
  static void main(args) {
     def uptime,questions,insertnum,selectnum,updatenum
     def sql = Sql.newInstance("jdbc:mysql://localhost:3306/samples", "root", "", "com.mysql.jdbc.Driver")
     sql.eachRow("show status"){ status ->
           if(status.variable_name == "Uptime"){
                  uptime =  status[1]
           }else if (status.variable_name == "Questions"){
                  questions =  status[1]
           }
     }
     println "Uptime for Database: " + uptime
     println "Number of Queries: " + questions
     println "Queries per Minute = " + Integer.valueOf(questions) / Integer.valueOf(uptime)
     sql.eachRow("show status like 'Com_%'"){ status ->
        if(status.variable_name == "Com_insert"){
           insertnum =  Integer.valueOf(status[1])
        }else if (status.variable_name == "Com_select"){
           selectnum =  Integer.valueOf(status[1])
        }else if (status.variable_name == "Com_update"){
           updatenum =  Integer.valueOf(status[1])
        }
    }
    println "% Queries Inserts = " + 100 * (insertnum / Integer.valueOf(uptime))
    println "% Queries Selects = " + 100 * (selectnum / Integer.valueOf(uptime))
    println "% Queries Updates = " + 100 * (updatenum / Integer.valueOf(uptime))
    }
}

结束语

如果你常玩计算机，你可能知道 Java 是一个运算平台，而非咖啡或印尼的一个岛。在 Java 技术诞生后的这五年，Java 变成了大家朗朗上口的名词，种种的说法中，有些是事实，有也一些夸大不实。你可能会想知道：你该不该去学 Java，我给你的答案是肯定的，请听听我的说法。

Java 是什么？

你必须先了解 Java 究竟是什么？当人们提到「Java」，他们指的可能是：

1.       Java 程序语言：一个类似 C++ 或 Smalltalk 的对象导向程序语言。学习 Java 程序语言类似学人类语言，都有一套规则和文法。

2.       Java 虚拟机器（JVM）：用来执行 Java 程序。JVM 有许多平台的版本，比方说 Linux 和 Windows 版。有了 JVM，Java 程序就可以在不同的平台上执行，也就是所谓的「写一次，到处都可执行」。

3.       Java APIs（指的是函式库的程序设计接口）：是一组预先定义好的类别，可以在你的程序中直接使用。这些东西是免费的，功能包含了像是档案存取，网络读写，图形接口等等。

当人们提到「学习 Java」，通常他们指的是 Java 语言和 API。大家可能对 JVM 所知不多，虽然对 JVM 有基本的认识对 Java 的学习是很有帮助的。

学习 Java 的理由中，有些是技术性的，有些则是非技术性的。我先描述两个程序的特色（垃圾搜集和例外处理），然后我告诉你：为什么在程序设计的领域中，Java 几乎是必备的技能。我也会告诉你 Java 开发工具的信息和它们吸引人的售价。

感谢老天，有「垃圾收集」真好！

使用 C++，你可能一不小心就写出会当机的程序；如果使用 Java，情况就大不相同了。C++ 程序的头号 bug 是内存配置的失误。C++ 的程序员很辛苦，必须直接配置一块内存，这块内存不用时还必须主动归还。这听起来简单，做起来可不容易，所以 C++ 的程序常常会耗尽内存。
Java 就不同了。虽然你仍需要主动配置内存，但此内存一旦不再使用时就会自动释放，这就称为「垃圾收集（garbage collection）」。垃圾收集机制使得写程序时轻松许多，虽然因此执行时效率稍微变差，但影响可能轻微得你根本感觉不到。

例外处理机制让程序更稳固

不管是什么程序语言，都可以轻易地写出很糟糕的程序，但是使用 Java 想写出很糟糕的程序就不容易了。原因之一是垃圾收集，原因之二是「例外处理机制」。良好的程序员写出来的程序应该在一些意外状况发生时程序依然正常。档案无法开启，怎么办？万一读档读到一半时出问题，怎么办？如果你是用 C++ 或 其它语言，你可能会疏于考虑而没进行这些意外状况的处理。你可能会辩白：「我只是在试试看这样写能否行得通，我稍后会回过头来把程序改得更周延」。但结果 通常是：程序执行正常后，你又会忙着写新的程序，这么一拖后来就忘了回头处理还不完整的部分。问题终究还是会爆发出来，你终究还是要面对烂摊子。
Java 强迫你在一遇到有可能出问题的地方就要准备好因应之道。Java 的 method 可以丢出例外，用来通知呼叫者程序出状况了，这是相当好的机制。即使你的程序要开启档案，你都必须在程序中写好例外处理方式。

到处都是 Java

到处都可见到 Java，这是一大好处。如果你靠写程序为生，你可能迟早都会接触到 Java。Java 已经渐渐地渗透到各领域，你可以写出 Java servlet，将其挂在 Apache 或其它网页服务器上，你可以写出 Java applet，在网页浏览器上执行。你甚至可以用 Java 写出数据库的 stored procedure，然后安装到 Oracle 8i 上。
我打赌，你身边使用 Java 的同事也会渐渐多起来。1997 年开始，许多大学已经用 Java 取代 C 当作程序设计教学的语言。如此一来，Java 变成了程序员共通的语言。如果学习 Java 所为你带来的唯一好处是方便和同事沟通，那么也值得。
最后，我要提的是：「写一次，到处都可执行」。Java 早期版本（1.0 和 1.1）比较无法完全跨平台，但现在就好多了。如果你想散布一个程序到多个平台，又不想改写大部分的程序，那么 Java 是绝佳的选择。Java 2 现在已经可以在 Linux、许多 Unix、和 Windows 上执行了。
MacOS 9 的 Java 仍在 1.1 时代。然而，Apple 的下一代操作系统 OS X 是以 Unix 为核心，这使得移植软件的过程大大简化了。我不知道 Apple 官方的说法为何，但是在今年三月的时候，我就已经看到 OS X developer release 3 上面执行着 Java 2。我很有自信 Java 2 将可以在 Linux、OS X、和 Windows 上执行，这样已经涵盖了大部分的计算机世界。

Java 免费

Sun 提供 Java 相关的工具，让你可以开发与执行 Java 程序。你无须支付授权费，你也不用花钱买 Java 开发工具。当然，Sun 这么做自有他们的如意算盘，Scott McNealy（Sun 的老板）恨不得能征服世界，但是不管怎样，我们的的确确是不用付钱给任何人就可以享受 Java。
而且，Java 的 API 是珍贵的宝藏，让我们可以轻易地写出功能强大的程序。想写网络程序？已经有 API 了！想连接数据库？已经有 API 了！想写 GUI 程序？已经有 API 了！或者是想做数字影像处理、音乐文件处理、字符串剖析、数字签章？通通有 API 了！身为一个程序员，有这么多好用的 API 真的是再高兴不过的事了，这些 Java API 让我们不用「重新发明轮子」，省却不少功夫。Java 有这么广泛、标准、先进的 API，简直是让 C++ 程序员忌妒死了。C++ 程序员常要花时间学一些 C++ 类别库（比方说 MFC），然后到 Linux 上又得归零学另一套（因为 Linux 上没有 MFC）。一旦你学会了某 Java API，到哪儿都一样不会变动，不用重学。
最后，Java 的信息文件都可从网站上免费取得。如果你有网络而且有空，你可以直接透过网络学习对象导向、Java 语言、以及 Java API。Sun 在网站上放了一大堆很棒的线上教材。如果你习惯看书来学习，市面上有一堆 Java 的书可以参考（比方说，我写的 Learning Java）。

日光浴

Java 比其它语言来得有趣许多。Java 程序语言有许多「防呆装置」让你不会在程序中犯下大错，所以你可以很快地把程序写完，而如果使用其它语言必须要花更多时间。一份有趣的资料显示：用 Java 写程序比用其它语言快了四到十倍。我知道这听起来很不可思议，不过你可以问问周遭懂 Java 的人看看。不用花很多时间找 bug，意味着你可以在海滩上休息更久，意味着你可以接受阳光的日光浴而非「屏幕的日光浴」。用 Java 为你赚进的银两为自己买一副太阳眼镜吧！

本文作者：Jonathan Knudsen（着有「Learning Java」、「Java 2D Graphics」等书）
本文译者：蔡学镛

语言、平台、链接库，这三者之间有很密切的关系。本文尝试着以链接库为中心，探讨它们之间的现况。

语言与链接库

语言通常会伴随着链接库，没有链接库的语言，差不多什么程序都写不出来。比方说，用 C 语言写出一个印出 Hello 的小程序，你需要用到 stdio 的链接库。用 Python 写 GUI 程序，你需要 Tkinter 链接库。

平台与链接库

平台通常也会伴随着链接库，没有链接库的平台，等于是摆明了不希望别人开发此平台的程序。比方说，你想用 Visual C++ 6 开发 Windows 程序，你需要用到 GDI32 以及 USER32 或 MFC 等链接库。写 Mac OS 9 的程序，需要 Carbon 链接库。

平台的链接库 vs 语言的链接库

在 A 平台上用 B 语言开发软件，你会同时面对 A 平台的链接库和 B 语言的链接库，此二链接库因为是不同厂商所提供的，所以可能无法百分之百契合，特别是牵涉到内存管理、资源管理、执行绪等和操作系统有密切关系的主题时。如果你想进行的某功能在 A 平台的链接库和 B 语言的链接库都有提供，那么你应该使用 A 平台链接库的版本，通常比较安全些。比方说，用 C 语言开发 Windows 平台的程序，如果你想配置内存，那么你应该呼叫 Win32 API 的版本（比方说 GlobalAlloc()），而非 C 语言的版本（比方说 malloc()）。

跨平台的链接库

你为某平台所开发的程序，为什么不能在别的平台上重新编译之后就能执行？问题就出在平台的链接库上。比方说，你用 C 语言搭配 C 的标准链接库和 Win32 链接库，在 Windows 平台上开发出一个演示文稿软件 WeakPoint 2000；你将 WeakPoint 2000 的原始程序拿到 Linux 上编译，却无法编译成功，问题就出在 Linux 没有 Win32 的链接库。

那么，如果有一个链接库将各个主要平台的链接库萃取（abstract）出一个共通的链接库，不就可以解决这个问题了。例如 Qt 正是这么做，你的 C++ 程序如果只使用标准的 C++ 链接库和 Qt 链接库，你就可以把程序重新编译之后在不同的平台（Linux，Unix，Windows）上执行。

语言 + 平台 + 链接库

Java 就更了不起了，不但将链接库统一起来，更将平台统一起来，也就是说程序不用重新编译，就可以直接执行。但是也因此，多了一层 JVM，牺牲了一部分的效率。

跨语言的链接库

Borland 的 VCL 链接库是在 Windows 平台上相当受好评的一套链接库，可以被 C++ 和 Object Pascal（Delphi）使用。其实「跨语言的链接库」不是一种很好的说法，毕竟许多语言都可以连结外部原生链接库，两者不需要是同一种语言。但是这样的连结是否需要大费周章，则有相当大的差异。而 Delphi 和 C++ Builder 使用 VCL 则是相当方便的。

即将在本月底问世的 Mac OS X，提供了 Cocoa 链接库。Cocoa 链接库可以被 Objective-C 和 Java 语言使用。Objective-C 和 Java 语言版的 Cocoa 链接库相似性在九成以上。Java 在 Mac OS X 的原生程序设计上被简化成一个纯语言，完全不使用 Java 的 API，只使用 Cocoa 链接库，这倒是挺特别的。（当然 Mac OS X 也另外会有 JVM 来支持一般的 J2SE）

语言规格 + 平台 + 链接库 = 包山包海 ?

.NET 比 Java 的眼光更高，甚至准备将语言规格也统一起来。.NET 有一个 CLS（common language specification），任何语言只要符合 CLS 这个标准，就可以轻易地整合进 .NET 平台，享用 .NET 平台的资源。这一点就是 Java 比不上的。虽然别的语言一样可以设计出编译器来将程序编译成 Java bytecode，在 JVM 上执行，但 Java 并没有提供直接的支持，所以要移植一个语言到 Java，比移植一个语言到 .NET 来得困难。

.NET 虽然允许各种语言，但是为了因应 CLS，所以各个语言常常需要做出妥协更改语言本身，比方说 Visual Basic 的更改幅度就很大（Visual Basic 7 差不多是一个新的语言了），而 JScript 和 Visual C++ 的语言也都有改变。这种方式的语言中立性，无疑是削足适履。有了 CLS 的规范，这些语言会趋于一致，思维模式如出一辙，只有一些微不足道的小差异。历史会证明，C# 会是 .NET 平台上独大的语言，.NET 上的其它语言都将沦为点缀，这么一来，跨语言的宣示，竟成了一个幌子。虽然我对 .NET 的语言中立性这点颇有疑异，但我倒是挺喜欢 .NET framework 的，我忍不住竖起大拇指称赞 .NET framework 是「歹竹出好笋」。

.NET 的语言规格和链接库都是统一的。命运多舛的 Eiffel 将 .NET 视为救命的浮木，准备将 Eiffel 移植到 .NET，但这么一来，Eiffel 势必得放弃自行开发的 Windows 专用链接库 WEL（Windows Eiffel Library）与跨平台的链接库（比方说 EiffelVision 等）。难道 Eiffel 没有发现它所以为的浮木，其实是鳄鱼伪装的？

同样的问题也会发生在 Delphi 上，如果 Delphi 准备移植到 .NET，也必须更改一部分的语言特性，并可能要放弃在 .NET 上使用 VCL（CLX）。Delphi 这么做一点好处都没有。

最乱的时代，最好的选择

看完这篇文章，你可能已经头昏脑胀了。没关系，你只要记得下面这句话就好了：最乱的时代，最好的选择 ...Java。

这一阵子，软件、网络大红，许多人对程序设计开始感兴趣，我收到好一些 Sleepless in Java专栏读者的来信，不少读者共同的问题是：如何进入程序设计的领域？所以我选这 个主题当作 Sleepless in Java 专栏「复刊」的第一篇文章。

写程序是很有趣的事，可以把自己的想法付诸实行。写程序的工具很简单，只要有一部PC，适当的开发环境，就可以上工了。这样有限的工具却可以创造无限的可能，这也正是程序 设计迷人的地方。只要你能力够，你可以将你脑海中的创意写成程序，变成一套软件。

培养程序能力，不是一蹴可及的，下面提供我的一些建议，希望对有志进入程序设计领域的你有所帮助。

培养兴趣

把程序设计当成兴趣可以让你学得更快乐，学习效果自然会更好。在我到一个单位面试时，主管看了我的履历之后问我：「你怎么有这么多时间学会这么多东西、做这么多事？」 我的回答是：「把工作、学习、和娱乐结合在一起，时间就会是别人的三倍。」

我承认我很幸运，可以把程序设计当作赚钱的工作，学习的题材，以及茶余饭后的休闲活动。不是每个人都像我这般幸运，但是我相信至少大家都可以把它当成兴趣。相信我， 调整你的心境，把它当成是兴趣，而非苦差事，你非发现你的「程序功力」与日俱增。

慎选程序语言

慎选程序语言很重要，一开始就学太难的程序语言很容易让你遭遇到挫折而放弃。你可以挑比较容易且有趣的语言下手，建议您可以从下面的语言中择一：

VB：简单，好用，书籍多。
Java：比VB稍难，比C/C++简单，书籍多，用途非常广，相当有前途。可以当作学习C++的跳板。
Python：简单，好用，各个平台都支持（包括Windows，Linux，MacOS，BeOS，...）。国外很红，国内较少人用。原文书不少， 但中文书目前只有一本（欧莱礼出版）。我预期 Python 会是下一个热门的程序语言。

这三个语言只是我给各位的建议，你也可以多听听别人的意见。在选定一个程序语言之后，就要执着，不可以很快放弃，又改学另一个程序语言，否则永远都只懂皮毛。有句谚语是 这么说的：「A jack of all trades is master of none」。如果你号称会C++、Java、…等十种程序语言，只不过每种程序语言都停留在Say Hello的阶段，相信面谈主管很快就会 对你 Say Goodbye。

当你学精某程序语言，然后想再学另一个程序语言，你会发现有了前一个程序语言札实的根基，学任何新的程序语言都很快。

使用适当的开发工具

现在RAD工具软件盛行，Visual Basic、Delphi、JBuilder、VisualAge、VisualCafe都是。有了RAD工具，只要「拉一拉，选一选」程序就完成一半了。许多硬底子的程序员 颇不以为然，认为初学者使用RAD工具不是好习惯，不过我倒不这么认为。我认为RAD工具可以降低初学者学习的门槛，提高兴趣。只是，在你学会「拉一拉，选一选」的简单步骤之后， 应该要找机会精进自己，弄懂内部的机制，不然不仅会有一种不踏实的感觉，甚至有许多程序会写不出来。我再强调一次：RAD可以当初学者入门的工具，但小心不要使它变成让你 停滞不前的借口。

另外也要学会使用开发工具所附的诸多功能（特别是除错功能）。许多人买了昂贵的 Enterprise 版开发工具，却只用到copy-paste功能，那么这套开发工具和 Windows 所附的 记事本就没有两样了。建议您开始使用一套新的开发工具前先花些时间把 User Guide 翻一翻。

现在许多开发工具都有免费版本可以下载，初学者不妨多多利用。

多读好书，少上课

大量阅读好书，是精进自己的不二法门。在这种快餐时代，许多人没耐心读书，反而喜欢到处上课，所以现在到处都是计算机班。如果遇到厉害的好老师，当然上过他（或她）的课 会收获很大，只是目前好老师的比例实在不高（虽然我自己也在开 Java/Enterprise Java/Java Swing 的课，但我还是得这么说）。我曾在网络上看到有人说：「没听过补习班教 出什么程序高手」，这倒也有几分真实性。不过一方面要归咎老师之外，一方面也要归咎学生，因为我发现通常上课的学生会在家里读书和写程序练习的比例不高。

相较于上课动辄花费上万元的高代价，买书只需要区区几百上千，划算多了，更何况书上的内容又比上课来得多且详细。不过「买书容易，看书难」。怕自己偷懒的话，找志同道合 的朋友组织「读书会」，彼此加油打气，还可以互相切磋。最好是像我前面提到的：把它变成兴趣。

加强英文阅读能力

加强英文和崇洋无关，而是有它实际的价值。许多信息都是要直接看英文的资料，因为没有中文版可看。

「可是我的英文很烂！」

这不是理由。没人生下来就能阅读英文，都是一点一点累积起阅读能力的。给自己一个机会，找一本单字文法都比较简单、且页数又少的书籍下手，很快地，你会发现技术书籍的 单字就是哪几个在重复出现，阅读这样的书一点都不难。

请注意：原文书的写作风格也有相当大的差异，有的书的确是不好读。所以，如果你刚开始要尝试阅读原文书，不要挑到像 Bjarne Stroustrup 所写的 The C++ Programming Language 这类难懂的书……尽管它是经典。

问人之前，先问自己

遇到问题，可以到国内外的程序设计相关讨论区去请教别人，如果态度谦逊，且问题叙述清楚，相信许多有经验的前辈会很乐于参与讨论。不过，凡是遇到问题就发问，这不是好事， 因为你会因此越来越依赖别人，而失去了自我解决问题的能力。自己应该尝试着查书、写程序测试、甚至阅读原始码，来找出答案。如此一来，真的没办法而请教别人时，也才能 比较深入地讨论。

多写程序

学程序设计不可以只看书，将随书光盘的程序执行一次，就认为自己已经学会了。应该开始写一些程序，且由小到大，由简单到复杂。找一些有趣的题目（比方说：计算器，踩地雷， 小画家，俄罗斯方块），可以提升写程序的动力。

我看到许多学生大一的程序作业都是copy同学的，失去了练习的机会。等到二年级之后，想开始写程序，却写不出来了。初学程序设计的阶段，应该给自己多一些机会写程序。

向上延伸，向下延伸，向旁延伸

当你发现你已经可以掌握此程序语言之后，你可以选择：

向上延伸：学习对象导向分析设计、Design Patterns、以及软件工程。让自己具有做大型计划的能力。

向下深入：深入了解内部底层的机制，例如操作系统（甚至硬件）内部。

向旁延伸：学习不同的API，例如：多媒体、数据库、企业运算…。

另外，数据结构、算法等基础也很重要。

结论

一分耕耘，一分收获，用对方法，持之以恒。每半年检阅自己这段期间以来的进步，相信你也会很高兴地说「我做到了」！

Windows 2k/2003 Server
1.最基本，最常用的，测试物理网络的
ping 192.168.10.88 －t ，参数－t是等待用户去中断测试

2.查看DNS、IP、Mac等
A.Win98：winipcfg
B.Win2000以上：Ipconfig/all

C.NSLOOKUP：如查看河北的DNS
C:\>nslookup
Default Server: ns.hesjptt.net.cn
Address: 202.99.160.68
>server 202.99.41.2 则将DNS改为了41.2
> pop.pcpop.com
Server: ns.hesjptt.net.cn
Address: 202.99.160.68

Non-authoritative answer:
Name: pop.pcpop.com
Address: 202.99.160.212

3.网络信使
Net send 计算机名/IP|* (广播) 传送内容，注意不能跨网段
net stop messenger 停止信使服务，也可以在面板－服务修改
net start messenger 开始信使服务

4.探测对方对方计算机名，所在的组、域及当前用户名
ping －a IP －t ，只显示NetBios名
nbtstat -a 192.168.10.146 比较全的

5.netstat -a 显示出你的计算机当前所开放的所有端口
netstat -s -e 比较详细的显示你的网络资料，包括TCP、UDP、ICMP 和 IP的统计等

6.探测arp绑定（动态和静态）列表，显示所有连接了我的计算机，显示对方IP和MAC地址
arp -a

7.在代理服务器端
捆绑IP和MAC地址，解决局域网内盗用IP：
ARP －s 192.168.10.59 00－50－ff－6c－08－75
解除网卡的IP与MAC地址的绑定：
arp -d 网卡IP

8.在网络邻居上隐藏你的计算机
net config server /hidden:yes
net config server /hidden:no 则为开启

9.几个net命令
A.显示当前工作组服务器列表 net view，当不带选项使用本命令时，它就会显示当前域或网络上的计算机上的列表。
比如：查看这个IP上的共享资源，就可以
C:\>net view 192.168.10.8
在 192.168.10.8 的共享资源
资源共享名 类型 用途 注释
--------------------------------------
网站服务 Disk
命令成功完成。

B.查看计算机上的用户帐号列表 net user
C.查看网络链接 net use
例如：net use z: \\192.168.10.8\movie 将这个IP的movie共享目录映射为本地的Z盘

D.记录链接 net session
例如：
C:\>net session
计算机 用户名 客户类型 打开空闲时间
-------------------------------------------------------------------------------
\\192.168.10.110 ROME Windows 2000 2195 0 00:03:12

\\192.168.10.51 ROME Windows 2000 2195 0 00:00:39
命令成功完成。

10.路由跟踪命令
A.tracert pop.pcpop.com
B.pathping pop.pcpop.com 除了显示路由外，还提供325S的分析，计算丢失包的％

11.关于共享安全的几个命令
A.查看你机器的共享资源 net share
B.手工删除共享
net share c$ /d
net share d$ /d
net share ipc$ /d
net share admin$ /d
注意$后有空格。
C.增加一个共享：
c:\net share mymovie=e:\downloads\movie /users:1
mymovie 共享成功。
同时限制链接用户数为1人。

12.在DOS行下设置静态IP
A.设置静态IP
CMD
netsh
netsh>int
interface>ip
interface ip>set add "本地链接" static IP地址 mask gateway
B.查看IP设置
interface ip>show address

Arp
显 示和修改“地址解析协议 (ARP)”缓存中的项目。ARP 缓存中包含一个或多个表，它们用于存储 IP 地址及其经过解析的以太网或令牌环物理地址。计算机上安装的每一个以太网或令牌环网络适配器都有自己单独的表。如果在没有参数的情况下使用，则 arp 命令将显示帮助信息。

语法
arp [-a [InetAddr] [-N IfaceAddr] [-g [InetAddr] [-N IfaceAddr] [-d InetAddr [IfaceAddr] [-s InetAddr EtherAddr [IfaceAddr]

参数
-a [InetAddr] [-N IfaceAddr]
显 示所有接口的当前 ARP 缓存表。要显示指定 IP 地址的 ARP 缓存项，请使用带有 InetAddr 参数的 arp -a，此处的 InetAddr 代表指定的 IP 地址。要显示指定接口的 ARP 缓存表，请使用 -N IfaceAddr 参数，此处的 IfaceAddr 代表分配给指定接口的 IP 地址。-N 参数区分大小写。
-g [InetAddr] [-N IfaceAddr]
与 -a 相同。
-d InetAddr [IfaceAddr]
删除指定的 IP 地址项，此处的 InetAddr 代表 IP 地址。对于指定的接口，要删除表中的某项，请使用 IfaceAddr 参数，此处的 IfaceAddr 代表分配给该接口的 IP 地址。要删除所有项，请使用星号 通配符代替 InetAddr。
-s InetAddr EtherAddr [IfaceAddr]
向 ARP 缓存添加可将 IP 地址 InetAddr 解析成物理地址 EtherAddr 的静态项。要向指定接口的表添加静态 ARP 缓存项，请使用 IfaceAddr 参数，此处的 IfaceAddr 代表分配给该接口的 IP 地址。
/?
在命令提示符显示帮助。
注释
InetAddr 和 IfaceAddr 的 IP 地址用带圆点的十进制记数法表示。
物理地址 EtherAddr 由六个字节组成，这些字节用十六进制记数法表示并且用连字符隔开（比如，00-AA-00-4F-2A-9C）。
通过 -s 参数添加的项属于静态项，它们不会 ARP 缓存中超时。如果终止 TCP/IP 协议后再启动，这些项会被删除。要创建永久的静态 ARP 缓存项，请在批处理文件中使用适当的 arp 命令并通过“计划任务程序”在启动时运行该批处理文件。
只有当网际协议 (TCP/IP) 协议在 网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要显示所有接口的 ARP 缓存表，可键入：

arp -a

对于指派的 IP 地址为 10.0.0.99 的接口，要显示其 ARP 缓存表，可键入：

arp -a -N 10.0.0.99

要添加将 IP 地址 10.0.0.80 解析成物理地址 00-AA-00-4F-2A-9C 的静态 ARP 缓存项，可键入：

arp -s 10.0.0.80 00-AA-00-4F-2A-9C

At
计划在指定时间和日期在计算机上运行命令和程序。at 命令只能在“计划”服务运行时使用。如果在没有参数的情况下使用，则 at 列出已计划的命令。

语法
at [\\ComputerName] [{[ID] [/delete]|/delete [/yes]}]

at [\\ComputerName] hours:minutes [/interactive] [{/everyate[,...]|/nextate[,...]}] command]

参数
\\computername
指定远程计算机。如果省略该参数，则 at 计划本地计算机上的命令和程序。
ID
指定指派给已计划命令的识别码。
/delete
取消已计划的命令。如果省略了 ID，则计算机中所有已计划的命令将被取消。
/yes
删除已计划的事件时，对来自系统的所有询问都回答“是”。
hours:minutes
指定命令运行的时间。该时间用 24 小时制（即从 00:00 [午夜] 到 23:59）的 小时: 分钟格式表示。
/interactive
对于在运行 command 时登录的用户,允许 command 与该用户的桌面进行交互。
/every:
在每个星期或月的指定日期（例如，每个星期四，或每月的第三天）运行 command 命令。
date
指定运行命令的日期。可以指定一周的某日或多日（即，键入 M、T、W、Th、F、S、Su）或一个?械哪橙栈蚨嗳眨�矗氪?1 到31 之间的数字）。用逗号分隔多个日期项。如果省略了 date，则 at 使用该月的当前日。
/next:
在下一个指定日期（比如，下一个星期四）到来时运行 command。
command
指 定要运行的 Windows 命令、程序（.exe 或 .com 文件）或批处理程序（.bat 或 .cmd 文件）。当命令需要路径作为参数时，请使用绝对路径，也就是从驱动器号开始的整个路径。如果命令在远程计算机上，请指定服务器和共享名的通用命名协定 (UNC) 符号，而不是远程驱动器号。
/?
在命令提示符显示帮助。
注释
Schtasks 是功能更为强大的超集命令行计划工具，它含有 at 命令行工具中的所有功能。对于所有的命令行计划任务，都可以使用 schtasks 来替代 at。有关 schtasks 的详细信息，请参阅“相关主题”。

使用 at
使用 at 命令时，要求您必须是本地 Administrators 组的成员。

加载 Cmd.exe
在运行命令之前，At 不会自动加载 Cmd.exe （命令解释器）。如果没有运行可执行文件 (.exe)，则在命令开头必须使用如下所示的方法专门加载 Cmd.exe：

cmd /c dir > c:\test.out。

查看已计划的命令
当不带命令行选项使用 at 时，计划任务会出现在类似于以下格式的表中：

Status ID Day Time Command Line
OK 1 Each F 4:30 PM net send group leads status due
OK 2 Each M 12:00 AM chkstor > check.file
OK 3 Each F 11:59 PM backup2.bat
包含标识号 (ID)
当在命令提示下使用带有标识号 (ID) 的 at 命令时，单个任务项的信息会显示在类似于下面的格式中：

Task ID： 1

Status:OK

Schedule:Each F

Time of Day:4:30 PM

Command:net send group leads status due当计划带有 at 的命令（尤其是带有命令行选项的命令）后，要通过键入不带命令行选项的 at 来检查该命令语法是否输入正确。如果显示在“命令行”列中的信息不正确，请删除该命令，然后重新键入它。如果还不正确，则可以在重新键入该命令时让它少带 些命令行选项。

查看结果
使用 at 的已经计划的命令作为后台程序运行。运行结果不会显示在计算机上。要将输出重定向到文件，请使用重定向符号 (>。如果将输出重定向到文件，则不论是在命令行还是在批处理文件中使用 at，都需要在重定向符号之前使用转义符 。例如，要重定向输出到 Output.text 文件，则要键入：

at 14:45 c:\test.bat ^>c:\output.txt

执行命令的当前目录为 systemroot 文件夹。

更改系统时间
在使用 at 命令计划了要运行的命令之后，如果更改了计算机的系统时间，则通过键入不带命令行选项的 at 可使 at 计划程序与修改后的系统时间同步。

存储命令
已计划的命令存储在注册表中。这样，如果重新启动“计划”服务，则不会丢失计划任务。

连接到网络驱动器
对于需要访问网络的计划作业，请不要使用已重新定向的驱动器。“计划”服务可能无法访问这些重定向的驱动器，或者，在该计划任务运行时如果有其他用户登录，则这些重定向的驱动器可能不会出现。因此，对于计划作业，请使用 UNC 路径。例如：

at 1:00pm my_backup \\server\share

请不要使用下述语法（其中 x: ?表示由用户建立的连接）：

at 1:00pm my_backup x:

如果计划了一个使用驱动器号的 at 命令来连接共享目录，则应包含一个 at 命令以使在完成该驱动器的使用时断开与驱动器的连接。如果不能断开与驱动器的连接，则在命令提示下，所指派的驱动器号将不可用。

范例
要显示 Marketing 服务器上已计划的命令列表，请键入：

at \\marketing
要了解服务器 Corp 上标识号为 3 的命令的详细信息，请键入：

at \\corp 3
要计划在上午 8:00 于 Corp 服务器上运行网络共享命令，并将该列表重定向到 Maintenance 服务器的 Corp.txt 文件（位于 Reports 共享目录下）中，请键入：

at \\corp 08:00 cmd /c "net share reports=d:\marketing\reports >> \\maintenance\reports\corp.txt"
为了在每五天后的午夜将 Marketing 服务器的硬盘驱动器备份到磁带驱动器，首先创建名为 Archive.cmd 的批处理程序（它含有备份命令），然后计划该批处理程序的运行，为此请键入：

at \\marketing 00:00 /every:5,10,15,20,25,30 archive
要取消当前服务器上已计划的所有命令，请按下述方法清除 at 计划信息：

at /delete
如果要运行的命令不是可执行 (.exe) 文件，请按如下所示的方法在该命令之前使用 cmd /c 来加载 Cmd.exe：

cmd /c dir > c:\test.out。
Rsh
在 运行 RSH 服务的远程计算机上运行命令。Windows XP 和 Windows 2000 不提供 RSH 服务。Windows 2000 Server Resource Kit 提供名为 Rshsvc.exe 的 RSH 服务。使用不带参数的 rsh 显示帮助。

语法
rsh [Host] [-l UserName] [-n] [Command]

参数
Host
指定运行 command 的远程计算机。
-l UserName
指定远程计算机上使用的用户名。在省略情况下，使用当前登录用户的名称。
-n
将 rsh 的输入重定向到 NULL 设备。这防止本地计算机命令结果的显示。
Command
指定要运行的命令。
/?
在命令提示符显示帮助。
注释
标准*作
rsh 命令将标准输入复制到远程 command，将远程 command 的标准输出复制到其标准输出，将远程 command 的标准错误复制到其标准错误。Rsh 通常在远程命令终止时终止。

使用重定向符号
为了使重定向在远程计算机上发生，要以引号引住重定向符号（例如 ">>"）。如果不使用引号，重定向会在本地计算机发生。例如，以下命令将远程文件“RemoteFile”附加到本地文件“LocalFile”中：

rsh othercomputer cat remotefile >> localfile

以下命令将远程文件 Remotefile 附加到远程文件 otherremotefile 中：

rsh othercomputer cat remotefile ">>" otherremotefile

使用 rsh
在使用已登录到某个域并且运行 Windows XP Professional 的计算机时，该域的主域控制器必须可用于确认用户名或 rsh 命令失败。

.rhosts 文件
.rhosts 文件通常许可 UNIX 系统的网络访问权限。.rhosts 文件列出可以访问远程计算机的计算机名及关联的登录名。在正确配置了 .rhosts 文件的远程计算机上运行 rcp、rexec 或 rsh 命令时，您不必提供远程计算机的登录和密码信息。

.rhosts 文件是一个文本文件，该文件中每一行为一个条目。条目由本地计算机名、本地用户名和有关该条目的所有注释组成。每个条目均由制表符或空格分开，注释用符号 (#) 打头。例如：

host7 #This computer is in room 31A

.rhosts 文件必须在远程计算机的用户主目录中。有关远程计算机 .rhosts 文件特定执行的详细信息，请参阅远程系统的文档。

只有当网际协议 (TCP/IP) 协议在 网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要以名称 admin1 在远程计算机 vax1 上执行 telcon 命令，请键入：

rsh vax1 -l admin1 telcon

Tftp
向运行平凡文件传输协议 (TFTP) 服务或 daemon 的远程计算机（尤其是运行 UNIX 的计算机）传输文件或从运行平凡文件传输协议 (TFTP) 服务或 daemon 的远程计算机（尤其是运行 UNIX 的计算机）传输文件。

语法
tftp [-i] [Host] [{get | put}] [Source] [Destination]

参数
-i
指 定二进制图像传送模式（也称为八进制模式）。在二进制图像模式下，文件以一个字节为单位进行传输。在传送二进制文件时使用该模式。如果省略了 -i，文件将以 ASCII 模式传送。这是默认的传送模式。该模式将行尾 (EOL) 字符转换为指定计算机的适当格式。传送文本文件时使用该模式。如果文件传送成功，将显示数据传输率。
Host
指定本地或远程计算机。
put
将本地计算机上的 Destination 文件传送到远程计算机上的 Source 文件。因为 TFTP 协议不支持用户身份验证，所以用户必须登录到远程计算机，同时文件在远程计算机上必须可写。
get
将远程计算机上的 Destination 文件传送到本地计算机上的 Source 文件。
Source
指定要传送的文件。
Destination
指定将文件传送到的位置。如果省略了 Destination，将假定它与 Source 同名。
/?
在命令提示符显示帮助。
注释
使用 get 参数
如果将本地计算机上的文件 FileTwo 传送到远程计算机上的文件 FileOne，则指定 put。如果将远程计算机上的文件 FileTwo 传送到远程计算机上的文件 FileOne，则指定 get。

Windows XP 或 Windows 2000 不提供一般用途的 TFTP 服务器。Windows 2000 提供的 TFTP 服务器服务只为 Windows XP 和 Windows 2000 客户端计算机提供远程引导功能。
只有当网际协议 (TCP/IP) 协议在 网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要从本地计算机将文件 Users.txt 传送到远程计算机 vax1 上的 Users19.txt，请键入：

tftp vax1 put users.txt users19.txt
Nbtstat
显 示本地计算机和远程计算机的基于 TCP/IP (NetBT) 协议的 NetBIOS 统计资料、NetBIOS 名称表和 NetBIOS 名称缓存。Nbtstat 可以刷新 NetBIOS 名称缓存和注册的 Windows Internet 名称服务 (WINS) 名称。使用不带参数的 nbtstat 显示帮助。

语法
nbtstat [-a RemoteName] [-A IPAddress] [-c] [-n] [-r] [-R] [-RR] [-s] [-S] [Interval]

参数
-a remotename
显示远程计算机的 NetBIOS 名称表，其中，RemoteName 是远程计算机的 NetBIOS 计算机名称。NetBIOS 名称表是运行在该计算机上的应用程序使用的 NetBIOS 名称列表。
-A IPAddress
显示远程计算机的 NetBIOS 名称表，其名称由远程计算机的 IP 地址指定（以小数点分隔）。
-c
显示 NetBIOS 名称缓存内容、NetBIOS 名称表及其解析的各个地址。
-n
显示本地计算机的 NetBIOS 名称表。Registered 中的状态表明该名称是通过广播或 WINS 服务器注册的。
-r
显示 NetBIOS 名称解析统计资料。在配置为使用 WINS 的 Windows XP 计算机上，该参数将返回已通过广播和 WINS 解析和注册的名称号码。
-R
清除 NetBIOS 名称缓存的内容并从 Lmhosts 文件中重新加载带有 #PRE 标记的项目。
-RR
重新释放并刷新通过 WINS 注册的本地计算机的 NetBIOS 名称。
-s
显示 NetBIOS 客户和服务器会话，并试图将目标 IP 地址转化为名称。
-S
显示 NetBIOS 客户和服务器会话，只通过 IP 地址列出远程计算机。
Interval
重新显示选择的统计资料，可以中断每个显示之间的 Interval 中指定的秒数。按 CTRL+C 停止重新显示统计信息。如果省略该参数， netstat 将只显示一次当前的配置信息。
/?
在命令提示符显示帮助。
注释
Nbtstat 命令行参数区分大小写。
下表列出了由 Nbtstat 生成的列标题。 标题 说明
Input 接收的字节数。
Output 发送的字节数。
In/Out 该连接是否从计算机（传出）或者其他计算机到本地计算机（传入）。
Lift 名称表缓存项在被清除之前所存留的时间。
Local Name 本地 NetBIOS 名称与连接相关联。
Remote Host 与远程计算机相关的名称或 IP 地址。
<03> 转化为十六进制的 NetBIOS 名称的最后一个字节。每个 NetBIOS 名称长度均为 16 个字符。由于最后一个字节通常有特殊的意义，因为相同的名称（只有最后一个字节不同）可能在一台计算机上出现几次。例如，<20> 在 ASCII 文本中是一个空格。
Type 名称类型。名称可以是单个名称，也可以是组名称。
Status 远程计算机上是否在运行 NetBIOS 服务（“已注册”），或同一计算机名是否已注册了相同的服务（“冲突”）。
State NetBIOS 连接的状态。

下表列出了可能的 NetBIOS 连接状态。 状态 说明
已连接 会话已建立。
关联 连接的终结点已经被创建并与 IP 地址关联。
正接听 该终结点对内向连接可用。
空闲 该结束点已被打开单不能接收连接。
正在连接 会话处于连接阶段。在此阶段正在解析所选目标的由名称到 IP 地址的映射。
接受 入站会话当前正在被接受，将在短期内连接。
重新连接 会话将试图重新连接（如果第一次连接失败）。
出站 会话正处于连接阶段。此阶段正在创建 TCP 连接。
入站 入站会话在连接期。
正在断开 会话正在断开连接。
已中断连接 本地计算机已断开连接，并正等待远程系统的确认。

只有当网际协议 (TCP/IP) 协议在 网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要显示 NetBIOS 计算机名为 CORP07 的远程计算机的 NetBIOS 名称表，请键入：

nbtstat -a CORP07

要显示所分配 IP 地址为 10.0.0.99 的远程计算机的 NetBIOS 名称表，请键入：

nbtstat -A 10.0.0.99

要显示本地计算机的 NetBIOS 名称表，请键入：

nbtstat -n

要显示本地计算机 NetBIOS 名称缓存的内容，请键入：

nbtstat -c

要清除 NetBIOS 名称缓存并重新装载本地 Lmhosts 文件中带标记 #PRE 的项目，请键入：

nbtstat -R

要释放通过 WINS 服务器注册的 NetBIOS 名称并对其重新注册，请键入：

nbtstat -RR

要每隔 5 秒以 IP 地址显示 NetBIOS 会话统计资料，请键入：

nbtstat -S 5

Netstat
显 示活动的 TCP 连接、计算机侦听的端口、以太网统计信息、IP 路由表、IPv4 统计信息（对于 IP、ICMP、TCP 和 UDP 协议）以及 IPv6 统计信息（对于 IPv6、ICMPv6、通过 IPv6 的 TCP 以及通过 IPv6 的 UDP 协议）。使用时如果不带参数，netstat 显示活动的 TCP 连接。

语法
netstat [-a] [-e] [-n] [-o] [-p Protocol] [-r] [-s] [Interval]

参数
-a
显示所有活动的 TCP 连接以及计算机侦听的 TCP 和 UDP 端口。
-e
显示以太网统计信息，如发送和接收的字节数、数据包数。该参数可以与 -s 结合使用。
-n
显示活动的 TCP 连接，不过，只以数字形式表现地址和端口号，却不尝试确定名称。
-o
显示活动的 TCP 连接并包括每个连接的进程 ID (PID)。可以在 Windows 任务管理器中的“进程”选项卡上找到基于 PID 的应用程序。该参数可以与 -a、-n 和 -p 结合使用。
-p Protocol
显 示 Protocol 所指定的协议的连接。在这种情况下，Protocol 可以是 tcp、udp、tcpv6 或 udpv6。如果该参数与 -s 一起使用按协议显示统计信息，则 Protocol 可以是 tcp、udp、icmp、ip、tcpv6、udpv6、icmpv6 或 ipv6。
-s
按协议显示统计信息。默认情况下，显示 TCP、UDP、ICMP 和 IP 协议的统计信息。如果安装了 Windows XP 的 IPv6 协议，就会显示有关 IPv6 上的 TCP、IPv6 上的 UDP、ICMPv6 和 IPv6 协议的统计信息。可以使用 -p 参数指定协议集。
-r
显示 IP 路由表的内容。该参数与 route print 命令等价。
Interval
每隔 Interval 秒重新显示一次选定的信息。按 CTRL+C 停止重新显示统计信息。如果省略该参数，netstat 将只打印一次选定的信息。
/?
在命令提示符显示帮助。
注释
与该命令一起使用的参数必须以连字符 (-) 而不是以短斜线 (/) 作为前缀。
Netstat 提供下列统计信息：
Proto
协议的名称（TCP 或 UDP）。

Local Address
本地计算机的 IP 地址和正在使用的端口号。如果不指定 -n 参数，就显示与 IP 地址和端口的名称对应的本地计算机名称。如果端口尚未建立，端口以星号（*）显示。

Foreign Address
连接该插槽的远程计算机的 IP 地址和端口号码。如果不指定 -n 参数，就显示与 IP 地址和端口对应的名称。如果端口尚未建立，端口以星号（*）显示。

(state)
表明 TCP 连接的状态。可能的状态如下：

CLOSE_WAIT

CLOSED

ESTABLISHED

FIN_WAIT_1

FIN_WAIT_2

LAST_ACK

LISTEN

SYN_RECEIVED

SYN_SEND

TIMED_WAIT

有关 TCP 连接状态的信息，请参阅 RFC 793。

只有当网际协议 (TCP/IP) 协议在 网络连接中安装为网络适配器属性的组件时，该命令才可用。
范例
要想显示以太网统计信息和所有协议的统计信息，请键入下列命令：

netstat -e -s

要想仅显示 TCP 和 UDP 协议的统计信息，请键入下列命令：

netstat -s -p tcp udp

要想每 5 秒钟显示一次活动的 TCP 连接和进程 ID，请键入下列命令：

nbtstat -o 5

要想以数字形式显示活动的 TCP 连接和进程 ID，请键入下列命令：

nbtstat -n –o

Runas
允许用户用其他权限运行指定的工具和程序，而不是用户当前登录提供的权限。

语法
runas [{/profile|/noprofile}] [/env] [/netonly] [/smartcard] [/showtrustlevels] [/trustlevel] /user:UserAccountName program

参数
/profile
加载用户的配置文件。/profile 是默认值。
/no profile
/noprofile 指定不加载用户的配置文件。这使应用程序载入的更加快速，但是在一些应用程序中也会引起错误。
/env
指定当前使用的网络环境，而不是用户的本地环境。
/netonly
指明指定的用户信息只用于远程访问。
/smartcard
/smartcard 表示凭据是否是由智能卡提供的。
/showtrustlevels
列出 /trustlevel 开关项。
/trustlevel
指定应用程序运行所在的授权级别。使用 /showtrustlevels 查看可用的信任级别。
/user:UserAccountName
指定在其下运行程序的用户帐户的名称。用户帐户的格式应是 user@domain 或 domain\user。
程序
指定要用在 /user 中指定的帐户运行的程序或命令。
/?
在命令提示符显示帮助。
注释
管理员可以使用一个权限受限制的帐户执行日常、非管理性的任务，只有在执行特定管理任务时，才使用一个权限更大的帐户。要不经过注销再重新登录就完成这样的任务，可以用一般帐户登录，然后使用 runas 命令来运行需要更大权限的工具。
有关 runas 命令的使用范例，请参阅“相关主题”。
尽管 runas 通常由 Administrator 帐户使用，但并非仅限于 Administrator 帐户。任何拥有多个帐户的用户均可以利用备用凭据，使用 runas 运行程序、MMC 控制台或“控制面板”项。
如果要在计算机上使用 Administrator 帐户，对于 /user:，键入下列参数之一：
/user:AdministratorAccountName@ComputerName

/user:ComputerName\AdministratorAccountName

如果想以域管理员身份使用这个命令，键入下列参数之一：
/user:AdministratorAccountName@DomainName

/useromainName\AdministratorAccountName

runas 命令允许您运行程序 (*.exe)、保存的 MMC 控制台 (*.msc)、程序和保存的 MMC 控制台的快捷方式及“控制面板”项。作为另一组（例如“Users”或“Power Users”组）的成员登录到计算机时，可以以管理员的身份运行。
可以使用 runas 命令来启动任何程序、MMC 控制器或“控制面板”项。只要提供适当的用户帐户和密码信息，用户帐户就具有登录到计算机的能力，并且程序、MMC 控制台、“控制面板”项在系统中及对该用户帐户均可用.
runas 命令允许您管理其他域的服务器（运行工具的计算机和要管理的服务器在不同的域中）。
如果尝试使用 runas 从网络位置启动程序、MMC 控制台或“控制面板”项，可能会因为用来连接网络共享的凭据与用来启动程序的凭据不同而失败。后者的凭据可能无法访问同一网络共享。
有些项，例如“打印机”文件夹和桌面项，间接由 Windows 2000 打开，而不能使用 runas 命令启动。
如果 runas 命令失败，则可能是没有运行 RunAs 服务或使用的用户帐户无效。要检查 RunAs 服务的状态，请在“计算机管理”中单击“服务和应用程序”，然后单击“服务”。要测试用户帐户，请尝试使用该帐户登录合适的域。
范例
要在本地计算机上以管理员身份启动 Windows 2000 命令提示行实例，请键入：

runas /user:localmachinename\administrator cmd
系统提示时，键入管理员密码。

要使用名为 companydomain\domainadmin 的域管理员帐户启动“计算机管理”管理单元实例，请键入：

runas /user:companydomain\domainadmin "mmc %windir%\system32\compmgmt.msc"
当提示时，键入帐户密码。

要使用名为 domain.microsoft.com 的域中的域管理员帐户 user 启动“记事本”实例，请键入：

runas /user:user@domain.microsoft.com "notepad my_file.txt"
当提示时，键入帐户密码。

要启动命令提示符行窗口、保存的 MMC 控制台、控制面板项或管理其他地点服务器的程序的一个实例，请键入：

runas /netonly /useromain\username "command"
domain\username 必须是有足够权限管理服务器的用户。当提示时，键入帐户密码。
Route
在本地 IP 路由表中显示和修改条目。使用不带参数的 route 可以显示帮助。

语法
route [-f] [-p] [Command [Destination] [mask Netmask] [Gateway] [metric Metric] [if Interface]

参数
-f
清 除所有不是主路由（网掩码为 255.255.255.255 的路由）、环回网络路由（目标为 127.0.0.0，网掩码为 255.255.255.0 的路由）或多播路由（目标为 224.0.0.0，网掩码为 240.0.0.0 的路由）的条目的路由表。如果它与命令之一（例如 add、change 或 delete）结合使用，表会在运行命令之前清除。
-p
与 add 命令共同使用时，指定路由被添加到注册表并在启动 TCP/IP 协议的时候初始化 IP 路由表。默认情况下，启动 TCP/IP 协议时不会保存添加的路由。与 print 命令一起使用时，则显示永久路由列表。所有其它的命令都忽略此参数。永久路由存储在注册表中的位置是 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\PersistentRoutes。
Command
指定要运行的命令。下表列出了有效的命令。 命令 目的
add 添加路由
change 更改现存路由
delete 删除路由
print 打印路由

Destination
指定路由的网络目标地址。目标地址可以是一个 IP 网络地址（其中网络地址的主机地址位设置为 0），对于主机路由是 IP 地址，对于默认路由是 0.0.0.0。
mask subnetmask
指 定与网络目标地址相关联的网掩码（又称之为子网掩码）。子网掩码对于 IP 网络地址可以是一适当的子网掩码，对于主机路由是 255.255.255.255 ，对于默认路由是 0.0.0.0。如果忽略，则使用子网掩码 255.255.255.255。定义路由时由于目标地址和子网掩码之间的关系，目标地址不能比它对应的子网掩码更为详细。换句话说，如果子网掩码的一位 是 0，则目标地址中的对应位就不能设置为 1。
Gateway
指定超过由网络目标和子网掩码定义的可达到的地址集的前一个或下一 个跃点 IP 地址。对于本地连接的子网路由，网关地址是分配给连接子网接口的 IP 地址。对于要经过一个或多个路由器才可用到的远程路由，网关地址是一个分配给相邻路由器的、可直接达到的 IP 地址。
metric Metric
为路由指定所需跃点数的整数值（范围是 1 ~ 9999），它用来在路由表里的多个路由中选择与转发包中的目标地址最为匹配的路由。所选的路由具有最少的跃点数。跃点数能够反映跃点的数量、路径的速度、路径可靠性、路径吞吐量以及管理属性。
if Interface
指定目标可以到达的接口的接口索引。使用 route print 命令可以显示接口及其对应接口索引的列表。对于接口索引可以使用十进制或十六进制的值。对于十六进制值，要在十六进制数的前面加上 0x。忽略 if 参数时，接口由网关地址确定。
/?
在命令提示符显示帮助。
注释
路 由表中 跃点数 一列的值较大是由于允许 TCP/IP 根据每个 LAN 接口的 IP 地址、子网掩码和默认网关的配置自动确定路由表中路由的跃点数造成的。默认启动的自动确定接口跃点数确定了每个接口的速度，调整了每个接口的路由跃点数， 因此最快接口所创建的路由具有最低的跃点数。要删除大跃点数，请在每个 LAN 连接的 TCP/IP 协议的高级属性中禁用自动确定接口跃点数。
如 果在 systemroot\System32\Drivers\Etc 文件夹的本地网络文件中存在适当的条目，名称可以用于 Destination。只要名称可以通过“域名系统” (DNS) 查询这样的标准主机名解析技术分解为 IP 地址，就可以将其用于 Gateway，DNS 查询使用存储在 systemroot\System32\Drivers\Etc 文件夹下的本地主机文件和 NetBIOS 名称解析。
如果是 print 或 delete 命令，可以忽略 Gateway 参数，使用通配符来表示目标和网关。Destination 的值可以是由星号 指定的通配符。如果指定目标含有一个星号 或问号 (?)，它被看作是通配符，只打印或删除匹配的目标路由。�