JPH03157729A - Multiple succession control system - Google Patents

Abstract

PURPOSE:To simplify the hierarchical relation of succession of definition relating to an object by designating a succession destination at every group with a method retrieval part by referring to a message group correspondence table when controlling the succession of the nature of the object. CONSTITUTION:The system is equipped with an object managing table 4 provided with information relating to the definition of a class or a generated object, the message group correspondence table 5 representing the correspondence of a message as a result of the grouping of the message with the group, and the method retrieval part 3 which retrieves a method for the message sent to the object as referring to the definition of the object. When the succession of the nature of the object is controlled, the method retrieval part 3 designates the succession destination at every group by referring to the message group correspondence table 5. Thereby, it is possible to simplify the hierarchical relation of the succession of the definition in an object oriented program.

Description

[Detailed Description of the Invention] [Summary] Regarding a control method for inheritance of definitions related to objects in object-oriented programming, for the purpose of simplifying the hierarchical relationship of inheritance of definitions, messages resulting from grouping messages and It is equipped with a message/group correspondence table that shows the correspondence with groups, and a method search section that searches for a method for a message sent to an object while referring to the definition of the object. The method search section is configured to refer to the message/group correspondence table and specify inheritance light for each group.

[Industrial Application Field] The present invention is applicable to object-oriented programming.
This invention relates to a control method for inheritance of object definitions from classes, and in particular to a control method for simplifying class definitions and inheritance hierarchical relationships when adopting a multiple inheritance method that allows the specification of multiple inheritance lights.

[Background Art] In recent years, the concept of object-oriented programming has been in the spotlight. This pushed the conventional abstraction of data structures further, introduced a structure called an object that bundled data and the program that processes it, and performed programming by defining the properties of the object. Refers to style.

Accessing data and executing processing in an object-oriented program takes the form of sending a message to an object, executing a program (called a method) corresponding to the message, and returning the result. In this format, the message sender does not need to know the specific processing contents of the method to be executed, and can simply use the returned value, so it can be said to be desirable for program modularization.

For example, the processing to obtain the length of a string and the processing to find the length of an array are different, but in object orientation both send a message to the data (string or array) to "obtain the length", The format is to obtain the execution results. On the side sending the message, there is no need to worry about whether the data is a character string or an array, and there is no need to worry about the specific process to obtain the length.

One method used to define the data and methods that each object has is to specify the class to which the object belongs when the object is created.

A class describes a common definition of a group of objects with the same properties. Each object is said to be an instance of this class and inherits the definition of this class.

For example, the character string "ABC" is an instance of a class called "character string", and its properties inherit the definition of the class "character string". This definition is common to all instances of the "character string" class, and the only thing that differs from object to object is the data held by each object (this is called an instance variable). This saves you the trouble of writing the properties for every object.

FIG. 5 shows an example of the class definition described above.

In the example in the same figure, a class (a) called string and ar
A class 1lb) called ray is defined. Each has data as an instance variable,
Methods for messages such as length, get, and aref are defined. These types of objects return the same result in response to the message length, but the specific content they perform is different.

There are several possible ways to inherit the properties of instances and classes. The most common method is to introduce a superclass above a class, and the class also inherits the definition of the superclass.

By adopting this method, classes can have a hierarchical structure, with general concepts described in higher-level classes and more specific definitions in lower-level classes. Easier to define.

For example, if window functions are defined in an object-oriented manner in a multi-window system, the basic functions of a window are defined in a superclass called "window", and detailed functions are defined in individual classes. good. This way, you can roughly understand the nature of a class by looking at its superclass name.

FIG. 6 is a diagram showing an example of inheritance of definitions by introducing such a superclass. In the figure, the window (
As a class that inherits the properties of class 51 called mouse-window
ow) and a class 52 called key window (key-
A class 53 called ``window'' is defined. Objects of these classes are window class 51
It also inherits the properties defined in .

In addition to introducing a superclass, there is also a method (multiple inheritance method) that allows the specification of multiple inheritance lights. In this method, superclasses are treated as parts, and lower classes can be defined as combinations of those parts. In the window example above, you can define a superclass for each function, and then list those superclasses as inheritance lights in the class definition.

FIG. 7 is a diagram showing an example of such multiple inheritance. In the figure, the mouse-key window (mouse-key
A class 56 called y-window has a mouse window 54 and a key window.
It also inherits the properties of window (key-window) 55. mouse-window has mouse-related functions, and 1 (eye-window has key output-related functions defined, ITlouse-ke
y-window has both mouse and key output functions.

[Problems to be Solved by the Invention] When multiple inheritance is allowed as described above, a problem arises when methods for the same message are defined in multiple inheritance lights.

In such a case, some measure must be taken to resolve the method conflict.

FIG. 8 is a diagram showing an example of method conflict. Mouse/key/window (mouse-key-
window > 59 is the mouse window (mou
sewindow >, 57 and key window (ke
y-wi indow) 58, but
Both classes define methods for messages called 1nput and output.

In many cases, this solution involves searching the classes described in the object according to a certain method, and executing the first method found.

However, with this method, it is not possible to change the inherited light for each individual message. Therefore, a method has been proposed in which each message is designated as being inherited or not inherited. This allows inheritance to be controlled for each individual message.

FIG. 9 shows an example in which inheritance light is defined for each method in this way. In the same figure, for a 1nput message, mouse-window is inherited and ou
For tput messages, key-window is inherited. For messages for which inheritance light is not specified, a normal method search will be performed, so in some cases it may be necessary to write inheritance light for many messages.

However, specifying inheritance light for each individual message complicates the definition of the class and makes it difficult to understand its properties. Furthermore, the hierarchical relationship of inheritance becomes complicated, which impairs the modularization of the program.

In view of these conventional problems, the present invention enables the inheritance light to be freely specified in an object-oriented program without making the program unnecessarily complicated, and simplifies the hierarchical relationship of inheritance of definitions. The purpose is to provide a control method that can be used to control objects.

[Means for Solving the Problems] According to the present invention, the above objects are achieved by the means described in the claims. That is, the present invention
In object-oriented programming, it is a control method for inheritance of data and method definitions related to objects, and includes an object management table that has information related to the definitions of classes and generated objects, and messages that are the result of grouping messages. It is equipped with a message/group correspondence table that shows the correspondence between objects and groups, and a method search section that searches for a method for a message sent to an object while referring to the object definition, and controls the inheritance of object properties. In this case, the method search unit uses a multiple inheritance control method in which the method search unit specifies inheritance light for each group by referring to a message/group correspondence table.

[Function] In the present invention, messages are grouped in advance into related groups to create a message/group correspondence table, and this group can be used as a unit for specifying inherited light. By doing this,
It is possible to change the inheritance light for each group, and the class definition does not become unnecessarily complicated. Furthermore, if messages are grouped according to their functions, the properties inherited from the superclass will become clearer and the functions of the class will be easier to understand.

FIG. 1 is a diagram showing an example of class definition according to the present invention.

In the same figure, messages in the 1nput-message group inherit mouse-window and
Message of tput-message group is ke
Inherits y-window.

FIG. 2 is a diagram showing examples of tables used in the method of the present invention, in which (a) is a message/group correspondence table, (3) is a message management table, (C) is an object/superclass inheritance table, ( ) shows an object/group/message correspondence management table.

For example, in the same figure (a), 1nput, read
It is shown that the -char message belongs to the input-message, the output, and the write-char message belong to the output-message.

[Embodiment] FIG. 3 is a block diagram showing an embodiment of the present invention,
It shows the configuration of the multiple inheritance control system, where l is a program storage section, 2 is a program execution section, 3 is a method search section,
4 represents an object management table, 5 represents a message/group correspondence table, and 6 represents an inheritance control section.

In the figure, the program to be executed is stored in program storage B1.

The program execution section 2 is a section that executes the program, and when a message is sent in the program, it inquires of the inheritance system @ section 6 about the method to be executed.

The object management table 4 is a table for managing defined classes and generated objects.

The message/group correspondence table 5 is a table that associates messages with groups to which they belong, as shown in FIG.

The method search unit 3 searches for a method for a message sent to an object while referring to the definition of the object. At this time, it refers to the message/group correspondence table 5 to identify the group of the message and searches for each group. Specify inherited light.

Furthermore, the method of the present invention can be combined with other inheritance control methods. For example, if there is no specification of inheritance light for a group, the inheritance light may be determined using a method similar to the conventional method.

FIG. 4 shows a flowchart of method search in this case. The present invention will be explained in detail according to the flowchart of FIG. In the same figure, the part surrounded by a dotted line is an item to which the present invention is applied.

<Step l> Assume that some message has been sent from the program execution unit 2.

Store the object to which the message was sent in obj,
Store the sent message in msH. Also, search the message group correspondence table (Figure 2 (a)) for the sent message, find the message group,
Store it in gr.

The obj, msg, and gr are predetermined areas on the memory where programs are stored.

<Step 2: Search the object management table 4, and search the message management table (Fig. 2 et al.) for that object.
Search to see if the message exists.

For example, the object to which the message was sent is key-
Suppose that it is window. If the message is 1
If nput, the corresponding method 1nput
-key is pulled.

<Step 7> The method is returned to the program execution unit 2.

The program execution unit 2 executes the processing defined by the method.

Next, the case where there is no message in step 2 will be explained.

For example, assume that a message output is manually input to the key-window (object). The message management table (Figure 2) contains the object key-
No message output is defined for window.

Step 3> Search the object/group/message correspondence management table (FIG. 2(d)) to see if a group corresponding to the output is registered. outp
The group of ut is output-message (in step l, the message group correspondence table (second
This can be seen because Figure (a)) is searched and stored in gr. ) Next, when searching for the object inherited by the output-message, it is key-wi indo-. In other words, key-window and output-
What message inherits is A-window.

Step 5> Store 8-window in obj (i.e., o
Object written in bj key-w indo
w will be changed to 8-window). Thereafter, the process branches to step 2, and step 7 is executed.

If it is assumed that the inheritance destination is not defined in step 3, step 4 is executed.

<Step 4> Find if a superclass is defined.

For example, in the object/group/message correspondence management table (Fig. 2(d)), the object key-w
Assume that no output-message is defined for indo.

At this time, in step 4, the object superclass inheritance table (Figure 2 (C)) is referred to, and the key-wi
Find the superclass that ndow inherits from (in this case, object) window.

Step 6> Store window in obj (i.e., Ob)
The object written in? key-window will be changed to window). The process branches to subsequent step 2 and executes step 7. Furthermore, super class w1
It is assumed that the message and method of 0dow are defined in the message management table (Figure 2B).

If it is determined in step 4 that the superclass is not defined, then in step 8 it is determined that the method is undefined. In this case, the program execution unit 2 does not execute processing based on the message.

As another method, when used in conjunction with a format in which inheritance destinations are specified for each individual method, it is necessary to check whether an inheritance destination is defined for each method, and if so, give priority to that inheritance destination. It's okay.

[Effects of the Invention] As explained above, according to the method of the present invention, an inheritance destination can be freely specified in an object-oriented program without making the program unnecessarily complicated, and the specification is also easy to understand. This has the advantage of greatly reducing the effort required for software development.

[Brief explanation of the drawing]

FIG. 1 is a diagram showing an example of class definition according to the method of the present invention, FIG. 2 is a diagram showing an example of a correspondence table used in the method of the present invention, and FIG. 3 is a diagram showing an embodiment of the present invention. Block diagram, 4th
The figure is a flowchart of method search when the method of the present invention and the normal inheritance method are used together, Figure 5 is a diagram showing an example of class definition, and Figure 6 is an example of definition inheritance by introducing a super class. Figure 7 is a diagram showing an example of multiple inheritance,
FIG. 8 is a diagram showing an example of method conflict, and FIG. 9 is a diagram showing an example of defining inheritance light for each method. Book jj I5'wy4 method 7z Yorokura Hisashi's Togi's 1
FIG. 1 shows: 1...Program storage section, 2...Program execution section, 3...Method search function, 4...
...Object management table, 5...Message group correspondence table

Claims (1)

[Claims] A control method for inheritance of data and method definitions related to objects in object-oriented programming, comprising an object management table having information related to definitions of classes and generated objects, and message grouping. It is equipped with a message/group correspondence table that shows the correspondence between messages and groups as a result of performing this process, and a method search section that searches for a method corresponding to a message sent to an object while referring to the definition of the object. A multiple inheritance control method characterized in that, when controlling property inheritance, the method search unit specifies an inheritance destination for each group by referring to a message/group correspondence table.