The object-oriented model is based on a collection of
objects. An object contains values stored in instance variables
within the object. Thus objects contain objects to an
arbitrarily deep level of nesting. Attributes/properties: objects
will have at least one attribute. Possible slot types are
primitive types (integer, boolean, string etc.), references to
other objects (modeling relationships) and sets of values of
these types. An object also contains bodies of code that
operate on the object. These bodies of code are called
methods. Method/Operations: They are attached to classes or
slots and contain meta information, such as comments,
constraints and default values. Relationship/relations: they
represent the relation between objects/classes from objece
model (KB). Major classes of relations exist: relations
combining labels(the name we tend to give to things) and
concepts(the things themselves) and concepts and relations
combining concepts (the part-whole relation).
Objects that contain the same types of values and the same
methods are grouped into classes. A class may be viewed as a
type definition for objects. Analogy: the programming
language concept of an abstract data type. The only way in
which one object can access the data of another object is by
invoking the method of that other object. This is called
sending a message to the object. Internal parts of the object,
the instance variables and method code, are not visible
externally or some researchers called it as black box.
Object/Class represent the tangible things. For
example, an object representing a bank account. The object
contains instance variables number and balance. The object
contains a method pay-interest which adds interest to the
balance. Under most data models, changing the interest rate
entails changing code in application programs. In the object-
oriented model, this only entails a change within the pay-
interest method. In commonly-known object-oriented
data models attributes and associations are not defined with
the class specification itself. Instead, class properties are
first-class primitive themselves .
One approach for implementing objects is to have a class,
which defines the implementation for multiple objects. A
class defines what types the objects will implement, how to
perform the behavior required for the interface and how to
remember state information. Each object will then only need
to remember its individual state. Although using classes is by
far the most common object approach, it is not the only
approach (using prototypes is another approach) and is really
peripheral to the core concepts of object-oriented modeling.
Unified Modeling Languages (UML) is well known and
widely used object modeling that consist of concepts
/entitypes/classes in a specification hierarchy, the description
of concepts by attributes which have range and relationship
between concepts. UML defines several types of diagram that
can be used to model the static and dynamic behaviors of a
system. A UML object diagram does not define a standard set
of primitive types for attributes and operation declarations;
however, Object Constraint Languages (OCL) does and it is
proposed that these be used for ontology modeling with UML
Model an ontology as a static model consisting of a class
diagram to depict the classes in the domain and their
relationships, an object diagram to show particular named
instances of those classes.
Conceptual (or Ontology) modeling deals with the question
on how to describe in a declarative and abstract way the
domain information of an application, its relevant vocabulary,
and how to constrain the use of the data. Modeling languages
like UML and Object Data Management Group (ODMG)
have been developed for object oriented models in software
engineering. Common to all of these newer models is the
arrangement of concepts/entitytypes/classes in a specialization
hierarchy, the description of concepts by attributes which
have ranges and relationships between concepts. Concepts,
relationshiptypes and attributes abstract from concrete objects
or values and thus describe the schema (the ontology). On the
other hand concrete objects populate the concepts, concrete
values instantiate the attributes of these objects and concrete
relations instantiate relationships.
