1。 使用SAX解析：

/***
* @param xmlPath - XML文件路径
* @param schemaPath - Schema文件路径
*/
public void saxValidation(String xmlPath, String schemaPath){
try {
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
saxParserFactory.setNamespaceAware(true);
saxParserFactory.setValidating(true);
SAXParser saxParser = saxParserFactory.newSAXParser();
saxParser.setProperty("http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema");
saxParser.setProperty("http://java.sun.com/xml/jaxp/properties/schemaSource", schemaPath);
DefaultHandler handler = new DefaultHandler();
saxParser.parse(xmlPath, handler);
} catch(SAXException exc) {
exc.printStackTrace();
}
}

2。 使用DOM解析：

/***
* @param xmlPath - XML文件路径
* @param schemaPath - Schema文件路径
*/
public void domValidation(String xmlPath, String schemaPath){
try {
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
docBuilderFactory.setNamespaceAware(true);
docBuilderFactory.setValidating(true);
docBuilderFactory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema");
docBuilderFactory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaSource", schemaPath);
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document doc = docBuilder.parse(xmlPath);
} catch(DOMException exc) {
exc.printStackTrace();
}
}

搜索到很多解决方案，基本的归纳为两个步骤，首先要将彩色图片变为8bit灰度图片(grayscale image)，然后再进一步变为1bit的单色图片(1bit monochrome)。

方案一：使用ColorConvert和Dithering操作

1、代码

目前JAVA最新的图片处理包应该是JAI(Java Advanced Imaging)，在JAI API的FAQ页面上，找到了下面的方法来完成这两步工作：

public RenderedImage convertTo8BitGray(RenderedImage colorImage){
ParameterBlock pb = new ParameterBlock();
pb.addSource(colorImage);
ColorModel cm = new ComponentColorModel(
ColorSpace.getInstance(ColorSpace.CS_GRAY),
new int[]{8},
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
pb.add(cm);
RenderedImage grayImage = JAI.create("ColorConvert", pb);
return grayImage;
}

public  RenderedImage applyDithering(RenderedImage grayImage, boolean isErrorDiffusion){
// Load the ParameterBlock for the dithering operation
// and set the operation name.
ParameterBlock pb = new ParameterBlock();
pb.addSource(grayImage);
String opName = null;
if(isErrorDiffusion) {
opName = "errordiffusion";
LookupTableJAI lut = new LookupTableJAI(new byte[] {(byte)0x00, (byte)0xff});
pb.add(lut);
pb.add(KernelJAI.ERROR_FILTER_FLOYD_STEINBERG);
} else {
opName = "ordereddither";
ColorCube cube = ColorCube.createColorCube(DataBuffer.TYPE_BYTE,
0, new int[] {2}); //尝试改变2为其它值，可以得到不同效果
pb.add(cube);
pb.add(KernelJAI.DITHER_MASK_441);
}
// Create a layout containing an IndexColorModel which maps
// zero to zero and unity to 255.
ImageLayout layout = new ImageLayout();
byte[] map = new byte[] {(byte)0x00, (byte)0xff};
ColorModel cm = new IndexColorModel(1, 2, map, map, map);
layout.setColorModel(cm);
// Create a hint containing the layout.
RenderingHints hints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);
// Dither the image.
bwImage = JAI.create(opName, pb, hints);
return bwImage;
}

2、问题

这段sample code在很多地方都被提到过，我不知道别人是否能够让它顺利执行，但是在我的机器上是不行的。

问题主要出在第一个convertTo8BitGray()函数里的ColorConvert操作上。在执行完ColorConvert之后，图片的ColorModel的numberOfComponents变为1。我的理解是因为变为灰度图片，只有一个色了。

然而不知为什么，图片的SampleModel的numberOfBands却仍然保持了3，这就造成了SampleModel和ColorModel 不兼容，所以程序总是抛出java.lang.IllegalArgumentException: The specified ColorModel is incompatible with the image SampleModel…的错误。

方案二：使用重画到灰度图片上的方法

后来我在Code Beach看到了这篇文章，试用了里面的第二个方法 — 将彩色图片画到一个灰度图片上的方法，终于可以成功将彩色图片转化为8bit的灰度图片。代码如下：

BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
Graphics g = image.getGraphics();
g.drawImage(colorImage, 0, 0, null);
g.dispose();

转换的效果如下图所示：

转换前：彩色图片

转换后：灰度图片

使用Binarize将8bit灰度图片转换为1bit黑白图片

将彩色图片转换为灰度图片后，仍然可以用前面程序例子中的applyDithering()方法来将8bit灰度图片进一步转换为1bit黑白图片，得到的效果比较象报纸上的黑白图片，保留了很多灰度的层次。
为了能够更进一步得到版画效果的图片，可以使用Binarize操作。改变Binarize操作的域值(threshold)也可以得到不同效果。
代码：

/***
* Binarize image (convert image to 1 bit black and white)
* 输入图片必须为灰度图片，否则会出错。
*/
public RenderedImage applyBinarize(RenderedImage grayImage) {
// Generate a histogram.
Histogram histogram =
(Histogram)JAI.create("histogram", grayImage).getProperty("histogram");
// Get a threshold equal to the median.
double[] threshold = histogram.getPTileThreshold(0.4); //改变域值可以得到不同效果
// Binarize the image.
RenderedImage bwImage =
JAI.create("binarize", grayImage, new Double(threshold[0]));
return bwImage;
}//function applyBinarize

效果：

使用Dithering的效果	使用Binarizing的效果

翻译：Aqua  prglab.com

注：很多程序员包括本人在内都是先学会的Java，然后才学的C++，其实C++与Java有很多相似和互通之处，有相当的Java知识可以对应转化到C++概念，从而帮助我们快速上手。这篇文章介绍的内容就对从Java向C++转变很有帮助，所以翻译推荐给有同样需要的朋友。翻译中加入了本人的理解，不完全是全文照搬。有不明或异议，请参考原文，或留言讨论。还是那句话，推荐多读原版资料。

学习怎样从一种编程语言转移到另一种编程语言是今日的程序员必须面对的现实，还好，C++和Java有很多共同的特点，所以从Java转到C++就容易许多。C++比Java复杂很多，本文并没打算涵盖所有C++的功能。但是如果你能够熟练掌握本文中的所有知识点，也足够有效的使用C++了。

这里我们只讲Java与C++的不同之处。像流程控制(if, while, for)这些在C++与Java中完全一样的内容这里就不讲了。

本文是基于ANSI C++标准的，一些老的C++ 编译器可能不支持这里讲到的一些重要功能。要使用这些编译器，你需要更多学习C++中从C继承来的部分。那些都超出了本文的范畴，也就不介绍了。

1. 数据类型和变量

C++ 中的变量类型与Java很相似。像Java一样，C++ 有int 和 double 类型。但是这些数字类型的取值范围是依赖于机器的。比如在16位系统上，例如运行DOS 或Windows 3.x的PC机上，int 是双字节(2-byte)的，取值范围比Java的4-byte的int 要小很多。在这些机器上，如果 int 不够用的话，你需要使用长整型long。

C++ 有 short 和 unsigned 类型来更有效的存储数字。（我认为所谓有效是指更高的空间利用率。） 最好是尽量避免使用这些类型除非是空间利用的有效性对你的系统真的非常重要。

在C++中布尔型用 bool 表示，而不像在Java中用boolean。

C++ 中字符串类型用 string 表示。它与Java中的 String 类型非常相似，但是，还是要逐一以下几点不同之处：

1. C++ 字符串存储ASCII 码字符，而不是标准码Unicode 字符

2. C++ 字符串是可以被修改的，而Java字符串的内容是不可修改的(immutable)。

3. 取子字符串的操作在 C++ 中叫做 substr，这个命令s.substr(i, n) 从字符串s中取得从位置 i 开始长度为n的子字符串。

4. 在C++中，你只能够将字符串与其它字符串对象相串联(concatenate)，而不能够与任意的对象相串联。

5. C++中可以直接使用关系操作符 ==、 !=、 <、 <=、 >、 >= 来进行字符串比较，其中后面四个操作符是按字母顺序进行比较的。 这比Java中使用函数equals和compareTo来比较要方便很多。

2. 变量和常量

在C++中，本地变量的定义看起来与Java中相同，例如：

int n = 5;

实际上这正是C++和Java的一个重要不同之处。C++编译器不对本地变量进行初始化检验，所以在C++中很容易忘记初始化一个变量，这种情况下，变量的值该变量所占内存区域中刚好当前存在随机值。这显然是很容易产生程序出错的地方。

与Java一样， C++中类可以有数据域和静态变量。不同的是，C++中变量可以在函数甚至是类的外面定义，这些所谓的全局变量可以在程序的任何函数中被访问，因而不易被很好的管理。所C++中应该尽量避免使用全局变量。

在C++中，常量可以在任何地方被定义（记得在Java中，常量必须是类的静态数据static data)。 C++ 使用关键字 const 来定义常量，而Java中是 final。例如：

const int DAYS_PER_YEAR = 365;

3. 类

C++ 中对类的定义与Java有些不同，这里是一个例子：一个C++ 版本的 Point 类:

class Point /* C++ */

{

public:

Point();

Point(double xval, double yval);

void move(double dx, double dy);

double getX() const;

double getY() const;

private:

double x;

double y;

};

这里几点重要的不同是：

1. C++的类定义中分为公共和私有部分，分别以关键字 public 和 private开始。而在Java中，每一个元素都必须标明 public 或 private。

2. C++中类的定义只包含函数的声明，真正的实现另外单独列出。

3. 访问函数(accessor methods)标有关键字 const ，表明这个函数不会改变本对象的元素值。

4. 类定义的结尾处有分号

类中函数的实现跟在类的定义之后。因为函数是在类外面定义的，所以每一个函数的名字前面要加类名称作为前缀，并使用操作符双冒号::来分割类的名称和函数的名称。不改变隐含参数值（即当前对象的值）的访问函数用 const标明。如下所示是上面类定义中的函数的实现：

Point::Point() { x = 0; y = 0; }

void Point::move(double dx, double dy)

{

x = x + dx;

y = y + dy;

}

double Point::getX() const

{

return x;

}

4. 对象

Java 与 C++ 最主要的不同在于对象变量的使用。在 C++中，对象变量存储的是真正的对象的值，而不是对象引用(reference)。注意在C++中构造一个对象的时候是不使用关键字new的，只需要在变量的名字后面直接赋予构造函数的参数就可以了，例如：

Point p(1, 2); /* 构造对象 p */

如果不跟参数赋值，则使用默认构造函数，例如：

Time now; /* 默认使用构造函数 Time::Time() */

这一点与Java很不同。在Java中，这个命令仅仅生成一个没有初始化的reference，而在C++中，它生成一个实际的对象。

当一个对象被赋给另一个对象变量的时候，实际的值将被拷贝。而在Java中，拷贝一个对象变量只不过是建立了另外一个指向对象的reference。拷贝一个C++的对象就像在Java中调用clone这个函数一样，而修改拷贝的值不会改变原对象的值。例如：

Point q = p; /* 拷贝p到q */

q.move(1, 1); /* 移动q而p不动，即q的值变了，而p的不变*/

多数情况下，C++中这种对象直接对值操作的特性使用起来很方便，但是也有些时候不尽如人意：

1. 当需要一个函数中修改一个对象的值，必须记住要使用按引用调用call by reference (参见下面函数部分)

2. 两个对象变量不能指向同一个对象实体。如果你要在C++中实现这种效果，必须使用指针pointer（参见下面指针部分）

3. 一个对象变量只能存储一种特定的类型的值，如果你想要使用一个变量来存储不同子类的对象的值（多态ploymorphism)，则需要使用指针。

4. 如果你想在C++中使用一个变量来或者指向null或者指向一个实际的对象，则需要使用指针

5. 函数

在Java中，每一个函数必须或者是对象函数(instance method)，或者是静态函数(static function)或称类函数。C++同样支持对象函数和静态函数（类函数），但同时C++也允许定义不属于任何类的函数，这些函数叫做全局函数（global functions）。

特别的是，每一个C++ 程序都从一个叫做 main的全局函数开始执行：

int main()

{ . . .

}

还有另外一个格式的main函数可以用来捕捉命令行参数，类似于Java的main函数，但是它要求关于C格式的数组和字符串的知识，这里就不介绍了。

按照习惯，通常如果程序执行成功， main 函数返回0，否则返回非零整数。

同Java一样，函数参数是通过值传递的(passed by value)。在Java中，函数无论如何都是可以修改对象的值的。然而在C++中，因为对象直接存储的是实际的值，而不是指向值的reference，也就是说传入函数的是一个实际值的拷贝，因此也就无法修改原来对象的值。

所以，C++ 有两种参数传递机制，同Java一样的按值调用(call by value) ，以及按地址调用(call by reference)。当一个参数是按reference传递时，函数可以修改其原始值。Call by reference 的参数前面有一个地址号 & 跟在参数类型的后面，例如：

void raiseSalary(Employee& e, double by)

{ . . .

}

下面是一个典型的利用call by reference的函数，在Java中是无法实现这样的功能的。

void swap(int& a, int& b)

{ int temp = a;

a = b;

b = temp;

}

如果使用 swap(x, y)来调用这个函数，则reference参数 a 和 b 指向原实际参数x 和 y的位置，而不是它们的值的拷贝，因此这个函数可以实现实际交换这两个参数的值。

在 C++中，每当需要实现修改原参数的值时你就可以使用按地址调用 call by reference 。

6. 向量Vector

C++ 的向量结构结合了Java中数组和向量两者的优点。一个C++ 的向量可以方便的被访问，其容量又可以动态的增长。如果 T 是任意类型，则 vector<T> 是一个元素为 T 类型的动态数组。下面的语句

vector<int> a;

产生一个初始为空的向量。而语句

vector<int> a(100);

生成一个初始有100个元素的向量。你可以使用push_back 函数来添加元素：

a.push_back(n);

调用 a.pop_back() 从a中取出最后一个元素（操作后这个元素被从a中删掉)， 使用函数size 可以得到当前a中的元素个数。

你还可以通过我们熟悉的 [] 操作符来访问向量中元素，例如：

for (i = 0; i < a.size(); i++) {

sum = sum + a[i];

}

同Java中一样，数组索引必须为 0 和 a.size() - 1之间的值。但是与Java不同的是，C++中没有runtime的索引号合法性检验。试图访问非法的索引位置可能造成非常严重的出错。

就像所有其它 C++ 对象一样，向量也是值。如果你将一个向量赋值给另外一个向量变量，所有的元素都会被拷贝过去。

vector<int> b = a; /* 所有的元素都被拷贝了 */

对比Java中的情况，在Java中，一个数组变量是一个指向数组的reference。拷贝这个变量仅仅产生另外一个指向同一数组的reference，而不会拷贝每一个元素的值。

正因如此，如果一个C++函数要实现修改向量的值，必须使用reference参数：

void sort(vector<int>& a)

{ . . .

}

7. 输入和输出

在C++中，标准的输入输出流用对象 cin 和 cout 表示。我们使用 << 操作符写输出，例如：

cout << "Hello, World!";

也可以连着输出多项内容，例如：

cout << "The answer is " << x << "\n";

我们使用 >> 操作符来读入一个数字或单词，例如：

double x;

cout << "Please enter x: ";

cin >> x;

string fname;

cout << "Please enter your first name: ";

cin >> fname;

函数getline 可以读入整行的输入，例如：

string inputLine;

getline(cin, inputLine);

如果到达输入的结尾，或者一个数字无法被正确的读入，这个流对象会被设置为 failed 状态，我们可以使用函数 fail 来检验这个状态，例如：

int n;

cin >> n;

if (cin.fail()) cout << "Bad input";

一旦一个流的状态被设为failed，我们是很难重置它的状态的，所以如果你的程序需要处理错误输入的情况，应该使用函数 getline 然后人工处理得到的输入数据。

8. 指针pointer

我们已经知道在C++中，对象变量直接存储的是对象的值。这是与Java不同的，在Java中对象变量存储的是一个地址，该地址指向对象值实际存储的地方。有时在C++中也需要实现这样的布置，这就用到了指针pointer。在 C++中，一个指向对象的变量叫做指针。如果T是一种数据类型，则 T* 是指向这种数据类型的指针。 这里重点介绍C++与Java的不同，要详细了解C++中指针的使用，请参考本站另一篇文章“C++中Reference与指针（Pointer）的使用对比”。

就像 Java中一样，一个指针变量可以被初始化为空值 NULL，另外一个指针变量的值，或者一个调用new生成的新对象：

Employee* p = NULL;

Employee* q = new Employee("Hacker, Harry", 35000);

Employee* r = q;

实际上在C++中还有第四种可能，那就是指针可以被初始化为另外一个对象的地址，这需要使用地址操作符 & ：

Employee boss("Morris, Melinda", 83000);

Employee* s = &boss;

这实际上并不是什么好主意。保险的做法还是应该直接让指针指向使用 new生成的新对象。

到目前为止，C++ 指针看起来非常像 Java 的对象变量。然而，这里有一个很重要的语法的不同。我们必须使用星号操作符 * 来访问指针指向的对象。如果 p 是一个指向Employee对象的指针，则 *p 才代表了这个对象：

Employee* p = . . .;

Employee boss = *p;

当我们需要执行对象的函数或访问对象的一个数据域时，也需要使用 *p ：

(*p).setSalary(91000);

*p外面的括号是必需的，因为 . 操作符比 * 操作符有更高的优先级。C的设计者觉得这种写法很难看，所以他们提供了另外一种替代的写法，使用 -> 操作符来实现 * 和 . 操作符的组合功能。表达式

p->setSalary(91000);

可以调用对象*p的函数 setSalary 。你可以简单的记住 . 操作符是在对象上使用的，-> 操作符是在指针上使用的。

如果你不初始化一个指针，或者如果一个指针为空值 NULL 或指向的对象不再存在，则在它上面使用 * 或 -> 操作符就会出错。 不幸的是 C++ runtime 系统并不检查这个出错。如果你范了这个错误，你的程序可能会行为古怪或死机。

而在Java中，这些错误是不会发生的。所有的reference都必须初始化，所有的对象只要仍有reference指向它就不会被从内存中清除，因此你也不会有一个指向已被删除的对象的reference。Java的runtime 系统会检查reference是否为空，并在遇到空指针时抛出一个null pointer的例外(exception)。

C++ 和 Java还有一个显著的不同，就是 Java 有垃圾回收功能，能够自动回收被废弃的对象。而在C++中，需要程序员自己管理内存分配回收。

C++中当对象变量超出范围时可以自动被回收。但是使用new生成的对象必须用delete操作符手动删除，例如：

Employee* p = new Employee("Hacker, Harry", 38000);

. . .

delete p; /* 不在需要这个对象 */

如果你忘记删除一个对象，那么你的程序有可能最终用光所有内存。这就是我们常说的内存泄漏 (memory leak)。更重要的是，如果你如果删除了一个对象，然后又继续使用它，你可能覆盖不属于你的数据。如果你刚巧覆盖了用于处理内存回收的数据域，那么内存分配机制就可能运转失常而造成更严重的错误，而且很难诊断和修复。因此，在C++中最好尽量少用指针。

9. 继承

C++和Java中继承的基本语法是很相似的。在C++中，使用 : public 代替Java中的extends 来表示继承关系 。 (C++ 也支持私有继承的概念，但是不太有用。)

默认情况下，C++中的函数不是动态绑定的。如果你需要某个函数实现动态绑定，需要使用virtual声明它为虚函数，例如：

class Manager : public Employee

{

public:

Manager(string name, double salary, string dept);

virtual void print() const;

private:

string department;

};

同Java一样，构造函数中调用父类的构造函数有特殊的语法。 Java使用关键字 super。C++中必须在子类的构造函数体外调用父类的构造函数。下面是一个例子：

Manager::Manager(string name, double salary, string dept)

: Employee(name, salary) /* 调用父类的构造函数 */

{ department = dept;

}

Java 中在子类函数中调用父类的函数时也使用关键字 super 。而在C++中是使用父类的名称加上操作符 ::表示，例如：

void Manager::print() const

{ Employee::print(); /* 调用父类的函数 */

cout << department << "\n";

}

一个 C++ 对象变量只能存储特定类型的对象值。要想在C++中实现多态(polymorphism)，必须使用指针。一个 T* 指针可以指向类型为 T 或 T 的任意子类的对象，例如：

Employee* e = new Manager("Morris, Melinda", 83000, "Finance");

你可以将父类和不同子类的对象混合收集到一个元素均为指针的向量中，然后调用动态绑定的函数，如下所示：

vector<Employee*> staff;

. . .

for (i = 0; i < staff.size(); i++)

staff[i]->print();

Elliotte Rusty Harold的这本书Processing XML with Java详细介绍了如何使用Java编程语言处理XML文档，是一本实用而且综合的指南与教程。书中简要概述了 XML基础，包括XML语法、DTD、模式、有效性，样式单和XML协议XML-RPC、SOAP与RSS。本书的核心内容是深入介绍了Java编程人员用Java生成与操纵XML文档时所用的关键XML API，包括SAX、DOM（文档对象模型）和JDOM。此外，还介绍了这些核心API的许多重要补充，包括XPath，XSLT，TrAX与JAXP，是所有需要使用XML的Java编程人员的宝贵参考资料。

现在这本书的英文版全文已经在线发布在XML的资源网站Cafe con Leche。本书也有中文译本，名为《Java语言与XML处理教程:SAX,DOM,JDOM,JAXP与TrAX指南》，以前卓越可以找到，现在好像找不到了。

近10 年来，随着计算机技术和人工智能技术的飞速发展，尤其是网络技 术的进步，专家系统也有了新的重大发展，出现了以Java为核心技术的专家系统开发工具。由美国Sandia实验室推出的专家系统外壳Jess（Java expert system shell）就是其中的一个出色代表，本文将介绍它的来龙去脉和主要特点。

从LISP到CLIPS

专家系统工具，即专家系统语言，是一种比LISP或C语言层次更高的语言，它提供一个推理机去 执行该语言的语句。早期的专家系统工具大都由LISP开发， 20世纪80年代中至90年代初是LISP的黄金时期。但随着LISP的广泛应用，其问题也逐渐暴露。一是LISP的运行速度。直到1989年，LISP 应用程序只有在用LISP编写的操作系统上才具有较好的运行效率，所以，一些计算机公司专门设计了运行人工智能语言程序的专用机器，但这使每次软件的更新 或升级都要付出巨大的代价。二是LISP的嵌入性。当要解决一个非常复杂的问题时，LISP显得极其无能为力。这两点限制了LISP的发展，它只被使用在 某些特定的应用领域。

CLIPS（C Language Integrated Production System）正是为解决这些问题而出现的。它于1984年由美国航空航天局约翰逊空间中心（NASA’s Johnson Space Center）推出，意在克服LISP移植性差、开发工具和硬件成本高、嵌入性低的缺点。CLIPS是一个基于Rete算法的前向推理语言，用标准C语言 编写，目前最新的版本为6.10。它具有高移植性、高扩展性、强大的知识表达能力和编程方式以及低成本等特点。一经推出，立即受到欢迎，被广泛应用于政 府、工业和学术界，有力地推动了专家系统技术在各领域及各种运行环境下的应用。目前，CLIPS是一个自由软件，主要由原来在NASA工作的设计人员维 护。它提供了一个新闻讨论组，可作为从事CLIPS的开发人员交换信息的场所。此外，在NASA的组织下还成立了一个CLIPS用户协会，以推动 CLIPS的开发与应用。更详细的信息可访问它的官方网站http: //www.ghg.net/clips/CLIPS.html。 由于CLIPS的强大功能与良好性能，以及NASA对该软件采取的开放政策，CLIPS 在美国国内外都有众多用户，他们应用CLIPS开发了许多实用的专家系统，并根据各自的需要对CLIPS进行扩充和改造，如加拿大研究委员会在CLIPS 中加入了模糊推理功能，推出了FuzzyCLIPS，我们也成功地在CLIPS中加入了图形功能，推出了图形化专家系统工具GEST（Graphical Expert System Shell）。

新一代工具Jess

Jess是1995年由美国Sandia国家 实验室分布式系统计算组成员Ernest J. Friedman-Hill用Java实现的一个经过扩充的CLIPS版本。它以CLIPS的设计原理为基础进行编写，除继承了CLIPS的优点外，还具 有许多自己独特的特征，如支持正向和逆向推理，可以在系统运行环境下直接调用Java的类库等，这些特点将专家系统的开发过程同功能强大的Java语言结 合起来，使采用Jess语言开发的专家系统具有良好的移植性、嵌入性，可以方便地应用到网络上的不同机器中。另外，Java多线程机制使Jess可以与其 他应用程序并发执行，同步机制保证了对共享数据的正确操作，通过使用不同的线程完成特定的行为，就可以很容易地实现网络上的实时交互行为。目前，Jess 被广泛用于学术、工业、商业等领域，是一个有着广阔发展前景的专家系统开发平台。

1. Jess的基本组成和知识表示

同 大多数专家系统工具一样，Jess的核心也是由事实库、规则库、推理机三大部分组成，并采用产生式规则作为基本的知识表达模式。在Jess中，事实包括简 单事实和对象事实。简单事实就是一个描述事物的断言，而对象事实除此之外还封装了方法，可以接受外界信息改变自身的特征。这一概念本身并不是Jess首次 提出的，ART-IM、CLIPS都支持这一概念。但Jess表达对象事实的方法确实别具一格：它用Java而非系统本身的语言来定义对象。在CLIPS 6.0中，对象事实通过系统本身的语句defclass和make-instance来定义，但在Jess中，类的定义由Java语言书写，编译通过后即 可动态地加入系统中。用Java虚拟机编译通过后，通过defclass命令将该类加入系统，它就可以执行类似于CLIPS中对类的各种操作，如生成它的 一个实例、调用它的方法等。由此可见，Jess可以方便地调用Java中的类库，使用Java中的各种数据结构和方法，从而具备其他系统不可比拟的优良的 嵌入能力。

Jess通过模式匹配语言对事实进行操作。在Jess中，模式匹配操作符的类型有很多，从可以同任意事实进行匹配的单一操作符到 只能同满足特定约束值的事实进行匹配的复杂操作符。特别要指出的是，Jess中有“unique”条件元素，它告诉系统同该模式匹配的事实是惟一的。这 样，当模式发现一条事实同它匹配后，就会停止对事实库的检索，在实际应用中，这可以将系统的性能提高20％～30％，而CLIPS系统不支持这一条件元 素。在Jess中，规则的表达形式沿用了CLIPS的语法结构，通过对规则前件和后件的限定，它可以支持内容丰富的模式匹配语言。另外，Jess支持面向 过程的编程方式，它提供了一些语句来控制规则后件的操作流程，如使用if…then…else和while…do…语句，这样它就能很有效地利用面向过程 编程的优势。总之，Jess的这些特性使系统拥有很强的知识表示能力。

2．Jess的推理机制

Jess 支持前向和逆向推理两种方式，前向推理同CLIPS的原理相同，逆向推理则是Jess不同于CLIPS的一个显著特征。在Jess的逆向推理中，规则仍采 用if…then…结构，但是在逆向推理时，推理引擎执行的是前件没有得到满足的规则，这种行为常常被称为目标寻找。显然，Jess同时支持前向和逆向推 理的特点使其推理能力得到了加强。推理的效率很大程度上依赖于匹配算法的效率。Jess通过实现Rete匹配算法来提供非常高效的前向和逆向推理。 Rete算法利用了专家系统中时间冗余性和结构相似性这两个特点，有效地减少了用于匹配操作的次数。因此，当系统的性能是由匹配算法的质量决定时， Jess的优点将更为明显。应当指出的是，Rete算法是一个以空间换取时间的算法，所以，应用Jess时应当考虑内存的消耗。

3．开发环境和文档支持
Jess提供了一个交互式的、命令行的开发环境，但也可以使用文本编辑器编辑代码，然后再通过系统命令以批处理的方式载入到系统中。同时它还提供了一个简 单的图形开发环境。类似于CLIPS，Jess非常重视系统调试工具和错误跟踪这两方面。它的调试命令可以帮助使用者监视事实库、知识库中的内容，以及议 程表中被激活规则的情况，也可以监视某一规则前件的部分匹配的情况。在错误跟踪方面，Jess中的JessException类提供了丰富的错误信息，包 含了对出错问题的解释和堆栈跟踪表中的信息，如出错子函数的名字、相关的语句、出错的行数等，可以很好地帮助开发人员发现错误原因。

Jess提供了一个非常完备的电子文档，它可以帮助开发人员很快查询到需要的信息，将Jess嵌入到Java应用程序中。由于Jess在很大程度上是CLIPS的克隆版本，感兴趣的读者可参考CLIPS用户手册和参考手册。

4．Jess的进一步扩充——FuzzyJ Toolkit

Jess 自从问世以来就没有停止过对功能的扩展，有许多研究技术人员不断地在Jess的基础上添加新的辅助功能。加拿大国家研究委员会信息技术研究所的 R.A.Orchard早在1995年就扩展了CLIPS的功能，将模糊推理的功能加入到CLIPS中，推出了模糊专家系统外壳工具 FuzzyCLIPS。后随着Jess的推出，R.A.Orchard将工作重心转移到Jess上来，将模糊推理的功能加入到Jess中，推出了 FuzzyJ Toolkit。FuzzyJ Toolkit本身就是一个模糊专家系统外壳，但只支持模糊前件和模糊后件这些基本的推理方式。它可以和Jess结合，形成功能更为强大的专家系统外壳 FuzzyJess，FuzzyJess不但可以表达精确事实、模糊事实、执行模糊推理，还具有Jess的强大功能。