As noted earlier, the RDF Schema type system is similar in some respects to the type systems of object-oriented programming
languages such as Java. However, RDF differs from most programming language type systems in several important respects.
One important difference is that instead of describing a class as having a collection of specific properties, an RDF schema describes
properties as applying to specific classes of resources, using domain and range properties. For example, a typical object-oriented
programming language might define a class Book with an attribute called author having values of type Person. A corresponding RDF
schema would describe a class ex:Book, and, in a separate description, a property ex:author having a domain of ex:Book and a range
of ex:Person.
The difference between these approaches may seem to be only syntactic, but in fact there is an important difference. In the
programming language class description, the attribute author is part of the description of class Book, and applies only to instances of
class Book. Another class (say, softwareModule) might also have an attribute called author, but this would be considered a different
attribute. In other words, the scope of an attribute description in most programming languages is restricted to the class or type in
which it is defined. In RDF, on the other hand, property descriptions are, by default, independent of class definitions, and have, by
default, global scope (although they may optionally be declared to apply only to certain classes using domain specifications).
As a result, an RDF schema could describe a property exterms:weight without a domain being specified. This property could then be
used to describe instances of any class that might be considered to have a weight. One benefit of the RDF property-based approach
is that it becomes easier to extend the use of property definitions to situations that might not have been anticipated in the original
description. At the same time, this is a "benefit" which must be used with care, to insure that properties are not mis-applied in
inappropriate situations.
Another result of the global scope of RDF property descriptions is that it is not possible in an RDF schema to define a specific
property as having locally-different ranges depending on the class of the resource it is applied to. For example, in defining the
property ex:hasParent, it would be desirable to be able to say that if the property is used to describe a resource of class ex:Human,
then the range of the property is also a resource of class ex:Human, while if the property is used to describe a resource of class
ex:Tiger, then the range of the property is also a resource of class ex:Tiger. This kind of definition is not possible in RDF Schema.
Instead, any range defined for an RDF property applies to all uses of the property, and so ranges should be defined with care.
However, while such locally-different ranges cannot be defined in RDF Schema, they can be defined in some of the richer schema
languages discussed in Section 5.5.
Another important difference is that RDF Schema descriptions are not necessarily prescriptive in the way programming language type
declarations typically are. For example, if a programming language declares a class Book with an author attribute having values of type
Person, this is usually interpreted as a group of constraints. The language will not allow the creation of an instance of Book without
an author attribute, and it will not allow an instance of Book with an author attribute that does not have a Person as its value.
Moreover, if author is the only attribute defined for class Book, the language will not allow an instance of Book with some other
attribute.
RDF Schema, on the other hand, provides schema information as additional descriptions of resources, but does not prescribe how
these descriptions should be used by an application. For example, suppose an RDF schema states that an ex:author property has an
rdfs:range of class ex:Person. This is simply an RDF statement that RDF statements containing ex:author properties have instances of
ex:Person as objects.
This schema-supplied information might be used in different ways. One application might interpret this statement as specifying part
of a template for RDF data it is creating, and use it to ensure that any ex:author property has a value of the indicated (ex:Person)
class. That is, this application interprets the schema description as a constraint in the same way that a programming language might.
However, another application might interpret this statement as providing additional information about data it is receiving, information
which may not be provided explicitly in the original data. For example, this second application might receive some RDF data that
includes an ex:author property whose value is a resource of unspecified class, and use this schema-provided statement to conclude
that the resource must be an instance of class ex:Person. A third application might receive some RDF data that includes an ex:author
property whose value is a resource of class ex:Corporation, and use this schema information as the basis of a warning that "there
may be an inconsistency here, but on the other hand there may not be". Somewhere else there may be a declaration that resolves
the apparent inconsistency (e.g., a declaration to the effect that "a Corporation is a (legal) Person").
Moreover, depending on how the application interprets the property descriptions, a description of an instance might be considered
valid either without some of the schema-specified properties (e.g., there might be an instance of ex:Book without an ex:author
property, even if ex:author is described as having a domain of ex:Book), or with additional properties (there might be an instance of
ex:Book with an ex:technicalEditor property, even though the schema describing class ex:Book does not describe such a property).
In other words, statements in an RDF schema are always descriptions. They may also be prescriptive (introduce constraints), but only
if the application interpreting those statements wants to treat them that way. All RDF Schema does is provide a way of stating this
additional information. Whether this information conflicts with explicitly specified instance data is up to the application to determine
and act upon.
[返回] 中文XML论坛 - 专业的XML技术讨论区 →
W3CHINA.ORG讨论区 - Web新技术讨论 → 『 Semantic Web(语义Web)/描述逻辑/本体 』 → 我对本体定义和本体构建的理解
(订阅本版)
2007/2/2 16:14:00
新浪微博
我对本体定义和本体构建的理解
